feat:优化职业技能关联实现

backend/core/basic/character/calc_equip.py

@@ -9,6 +9,7 @@ from .base import CharacterBase
 from .config_view import CalcConfigView
 from .effect_apply import apply_uppercase_attrs
 from ..skill_effects import skill_effect_batch
+from ..skill import Skill
 
 
 @cache
@@ -17,7 +18,10 @@ def get_skill_classes(module_name: str) -> tuple[type, ...]:
     return tuple(
         memberClass
         for name in dir(module)
-        if isinstance((memberClass := getattr(module, name)), type) and memberClass.__name__.startswith('Skill')
+        if isinstance((memberClass := getattr(module, name)), type)
+        and memberClass is not Skill
+        and issubclass(memberClass, Skill)
+        and memberClass.__name__.startswith('Skill')
     )
 
 

backend/core/basic/skill.py

@@ -9,6 +9,7 @@ from database.connect import get_redis_client
 from api.core.Redis import get_redis_info
 from api.utils.openapi_data import OPENAPI_CUSTOM_CN_PATH, logical_skill_detail_path
 from .skill_effects import CHARACTER_ATTRIBUTES, INPUT_ATTRIBUTES
+from .skill_effect_types import CharacterEffect, EffectDeclaration, SkillEffect
 
 if TYPE_CHECKING:
     from core.basic.character import Character
@@ -143,9 +144,11 @@ class Skill:
     """技能冷却倍率,直接体现在面板上,不被上限影响"""
     cdRecover: float = 1
     """技能冷却恢复"""
-    associate: list = []
+    associate: list[dict[str, Any] | EffectDeclaration] = []
     """关联声明；维护示例和扩展边界见 core/basic/skill_effects.py 文件顶部说明。
 
+    新规则可用 SkillEffect/CharacterEffect，与旧字典混用；目标仍使用技能名称数组。
+    新声明 value 是实际倍率/增量/覆盖值，以下 type、data、ratio 约定仅适用于旧字典。
     type 默认 '*skillDamage'：*乘算、+加算、=覆盖；$*PAtkP 等作用于角色。
     skills 默认 '*'，表示所有伤害技能；显式列表使用技能名称，可指定被动技能。
     exceptSkills 默认 []；weapon 默认职业武器选项；precondition() 控制前置条件。
@@ -240,6 +243,12 @@ class Skill:
         weapon_type = self.char.GetWeaponType()[0]
         weapon_options = self.char.武器选项
         for assoc in self.associate:
+            if isinstance(assoc, (SkillEffect, CharacterEffect)):
+                engine = getattr(self.char, 'skill_effects', None)
+                if engine is None:
+                    raise RuntimeError('类型化效果需要 SkillEffectEngine')
+                engine.collect_effect(self, assoc)
+                continue
             type = assoc.get('type', '*skillDamage')
             skills = assoc.get('skills', '*')
             data = assoc.get('data', [0] * self.maxLv)

backend/core/basic/skill_effect_types.py

@@ -0,0 +1,549 @@
+"""有类型的技能关联声明；完整维护说明见 skill_effects.py 文件顶部。
+
+表达式不可变、无副作用，并在求值前声明依赖。关联目标仍使用技能名称数组。
+公开类型、枚举成员和字段的中文文档用于编辑器补全与悬停提示。
+"""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from enum import Enum
+from math import isfinite
+from typing import TYPE_CHECKING, Literal, cast
+
+if TYPE_CHECKING:
+    from .skill import Skill
+
+
+class Operation(str, Enum):
+    """效果汇总运算：先覆盖基础值，再加算，最后乘算。"""
+    ADD = '+'
+    """加算：向目标属性增加 value；等级 +1 应传 1。"""
+    MULTIPLY = '*'
+    """乘算：目标属性乘以 value；提高 20% 应传 1.2。"""
+    ASSIGN = '='
+    """覆盖：用 value 替换基础值；不同来源的不同覆盖值会报冲突。"""
+
+
+class SkillAttribute(str, Enum):
+    """技能公共属性。等级、参数先求值；伤害、冷却随后汇总。"""
+    LEVEL = 'lv'
+    """技能等级：加级仅作用于已学习技能，共享等级应修改源技能。"""
+    RATIO = 'ratio'
+    """关联参数倍率：例如手雷精通的倍率参数，不是百分比除数。"""
+    MAX_LAYER = 'maxLayer'
+    """最大层数：可影响后续关联求值的状态参数。"""
+    VP = 'vp'
+    """技能进化选项：0 未选择、1/2 对应 VP 分支；只读外部输入。"""
+    UP = 'up'
+    """技能强化选项：只读外部输入，不接受关联效果写入。"""
+    DAMAGE = 'skillDamage'
+    """技能技攻倍率：影响最终伤害，不改变技能面板数据。"""
+    PANEL_RATIO = 'skillRation'
+    """技能面板倍率：改变返回的技能面板数据。"""
+    CD = 'cd'
+    """基础冷却时间，单位为秒。"""
+    CD_CUT = 'cdCut'
+    """冷却时间直接减少量，单位为秒。"""
+    CD_REDUCE = 'cdReduce'
+    """技能冷却缩减倍率：缩减 10% 应乘以 0.9。"""
+    CD_RATIO = 'cdRatio'
+    """面板冷却倍率：直接作用于面板冷却，不受冷却缩减上限影响。"""
+    CD_RECOVER = 'cdRecover'
+    """冷却恢复倍率：提高恢复速度应按实际倍率或增量声明。"""
+
+
+class ProfessionAttribute(str, Enum):
+    """职业专用输出属性的枚举基类；在职业文件中继承并为成员补充中文文档。
+
+    例如 HunterAttribute.MARK_RATIO = 'markRation'。仅用于效果写入，不可通过
+    Read 读取。需要参与依赖求值的状态属性，应在公共状态注册处显式维护。
+    属性名必须对应目标技能已有的数值字段；不接受公共属性或编号分段属性的重定义。
+    """
+
+
+class CharacterAttribute(str, Enum):
+    """当前支持关联的角色标量属性；特殊属性不能只添加枚举便直接套用。"""
+    STR = 'STR'
+    """角色力量。"""
+    INT = 'INT'
+    """角色智力。"""
+    SPIRIT = 'Spirit'
+    """角色精神。"""
+    VITALITY = 'Vitality'
+    """角色体力。"""
+    ATK_P = 'AtkP'
+    """物理攻击力数值。"""
+    ATK_M = 'AtkM'
+    """魔法攻击力数值。"""
+    ATK_I = 'AtkI'
+    """独立攻击力数值。"""
+    P_ATK_P = 'PAtkP'
+    """物理攻击力倍率，例如武器精通的物攻加成。"""
+    P_ATK_M = 'PAtkM'
+    """魔法攻击力倍率。"""
+    P_ATK_I = 'PAtkI'
+    """独立攻击力倍率。"""
+    P_STR = 'PSTR'
+    """力量倍率。"""
+    P_INT = 'PINT'
+    """智力倍率。"""
+
+
+class ComponentKind(str, Enum):
+    """技能分段属性类型，结合非负整数索引定位具体分段。"""
+    POWER = 'power'
+    """普通伤害分段倍率，对应 powerN。"""
+    EXTRA_DATA = 'dataplus'
+    """额外伤害数据，对应 dataplusN。"""
+    EXTRA_POWER = 'powerplus'
+    """额外伤害分段倍率，对应 powerplusN。"""
+    HIT = 'hit'
+    """分段攻击次数，对应 hitN。"""
+
+
+@dataclass(frozen=True)
+class ComponentAttribute:
+    """有编号的技能分段属性，例如 power13、dataplus0。"""
+    kind: ComponentKind
+    """分段属性类型。"""
+    index: int
+    """从 0 开始的分段索引。"""
+
+    def __post_init__(self):
+        if not isinstance(self.kind, ComponentKind) or type(self.index) is not int or self.index < 0:
+            raise ValueError('技能分段属性需要 ComponentKind 和非负整数索引')
+
+    @property
+    def value(self) -> str:
+        """底层技能属性名称，由分段类型与索引组成。"""
+        return f'{self.kind.value}{self.index}'
+
+
+def Power(index: int) -> ComponentAttribute:
+    """普通分段倍率。index 为从 0 开始的分段编号；Power(13) 对应 power13。"""
+    return ComponentAttribute(ComponentKind.POWER, index)
+
+
+def ExtraData(index: int) -> ComponentAttribute:
+    """额外伤害数据。index 为分段编号；ExtraData(0) 对应 dataplus0。"""
+    return ComponentAttribute(ComponentKind.EXTRA_DATA, index)
+
+
+def ExtraPower(index: int) -> ComponentAttribute:
+    """额外分段倍率。index 为分段编号；ExtraPower(0) 对应 powerplus0。"""
+    return ComponentAttribute(ComponentKind.EXTRA_POWER, index)
+
+
+def Hit(index: int) -> ComponentAttribute:
+    """分段攻击次数。index 为分段编号；Hit(0) 对应 hit0。"""
+    return ComponentAttribute(ComponentKind.HIT, index)
+
+
+STATE_ATTRIBUTES = frozenset({SkillAttribute.LEVEL.value, SkillAttribute.RATIO.value, SkillAttribute.MAX_LAYER.value})
+READ_ATTRIBUTES = STATE_ATTRIBUTES | {SkillAttribute.VP.value, SkillAttribute.UP.value}
+# VP/UP are configuration inputs, not writable association outputs.
+WRITE_ATTRIBUTES = frozenset(attr.value for attr in SkillAttribute) - {'vp', 'up'}
+
+
+def _number(value: float) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not isfinite(value):
+        raise TypeError(f'效果表达式需要有限数值，实际为 {value!r}')
+    return value
+
+
+class Expression:
+    """数值表达式基类，支持四则运算；新增节点必须同时实现求值和依赖提取。"""
+    def evaluate(self, source: Skill) -> float:
+        """使用来源技能的最终状态求值，不得修改技能或角色。"""
+        raise NotImplementedError
+
+    def dependencies(self) -> frozenset[Read]:
+        """返回全部潜在读取，包括当前未启用的条件分支。"""
+        raise NotImplementedError
+
+    def __add__(self, other: Expression | float) -> Expression:
+        return Binary(self, '+', expression(other))
+
+    def __radd__(self, other: Expression | float) -> Expression:
+        return expression(other) + self
+
+    def __sub__(self, other: Expression | float) -> Expression:
+        return Binary(self, '-', expression(other))
+
+    def __rsub__(self, other: Expression | float) -> Expression:
+        return expression(other) - self
+
+    def __mul__(self, other: Expression | float) -> Expression:
+        return Binary(self, '*', expression(other))
+
+    def __rmul__(self, other: Expression | float) -> Expression:
+        return expression(other) * self
+
+    def __truediv__(self, other: Expression | float) -> Expression:
+        return Binary(self, '/', expression(other))
+
+    def __rtruediv__(self, other: Expression | float) -> Expression:
+        return expression(other) / self
+
+
+def expression(value: Expression | float) -> Expression:
+    """将数值包装为常量表达式，已有表达式原样返回。"""
+    return value if isinstance(value, Expression) else Constant(value)
+
+
+@dataclass(frozen=True)
+class Constant(Expression):
+    """有限数值常量；声明中直接传入数字时会自动包装。"""
+    value: float
+    """常量数值，不接受布尔值、无穷大或 NaN。"""
+
+    def __post_init__(self):
+        _number(self.value)
+
+    def evaluate(self, source: Skill) -> float:
+        return self.value
+
+    def dependencies(self) -> frozenset[Read]:
+        return frozenset()
+
+
+@dataclass(frozen=True)
+class Read(Expression):
+    """读取技能状态或输入；可分析跨技能依赖，不支持读取最终伤害/冷却输出。
+
+    Args:
+        attribute: 要读取的等级、ratio、最大层数、VP 或 UP。
+        skill: 被读取技能的名称，省略时读取自身。
+    """
+    attribute: SkillAttribute
+    """要读取的等级、ratio、最大层数、VP 或 UP。"""
+    skill: str | None = None
+    """源技能名称；省略时读取声明所属技能自身。"""
+
+    def __post_init__(self):
+        if not isinstance(self.attribute, SkillAttribute) or self.attribute.value not in READ_ATTRIBUTES:
+            raise ValueError('Read 仅支持等级、ratio、maxLayer、VP、UP；不能读取尚未汇总的输出属性')
+        if self.skill is not None and (not isinstance(self.skill, str) or not self.skill):
+            raise TypeError('Read 的技能引用必须是非空技能名称，省略时读取自身')
+
+    def target(self, source: Skill) -> Skill:
+        """按名称解析被读取的技能，并检查目标属性是否存在。"""
+        target = source if self.skill is None else source.char.GetSkillByName(self.skill)
+        if target is None:
+            raise ValueError(f'效果表达式引用技能不存在: {source.name} -> {self.skill}')
+        if not hasattr(target, self.attribute.value):
+            raise ValueError(f'效果表达式引用属性不存在: {source.name} -> {target.name}.{self.attribute.value}')
+        return target
+
+    def evaluate(self, source: Skill) -> float:
+        return _number(getattr(self.target(source), self.attribute.value))
+
+    def dependencies(self) -> frozenset[Read]:
+        return frozenset({self})
+
+
+@dataclass(frozen=True)
+class Binary(Expression):
+    """四则运算节点，通常通过表达式之间的 +、-、*、/ 自动构造。"""
+    left: Expression
+    """左侧数值表达式。"""
+    operation: Literal['+', '-', '*', '/']
+    """四则运算符；与效果汇总运算 Operation 不同。"""
+    right: Expression
+    """右侧数值表达式；除法求值时不能为零。"""
+
+    def __post_init__(self):
+        if self.operation not in ('+', '-', '*', '/'):
+            raise ValueError(f'未知表达式运算: {self.operation}')
+        object.__setattr__(self, 'left', expression(self.left))
+        object.__setattr__(self, 'right', expression(self.right))
+
+    def evaluate(self, source: Skill) -> float:
+        left, right = self.left.evaluate(source), self.right.evaluate(source)
+        if self.operation == '+':
+            return _number(left + right)
+        if self.operation == '-':
+            return _number(left - right)
+        if self.operation == '*':
+            return _number(left * right)
+        if right == 0:
+            raise ValueError(f'效果表达式除数为零: {source.name}')
+        return _number(left / right)
+
+    def dependencies(self) -> frozenset[Read]:
+        return self.left.dependencies() | self.right.dependencies()
+
+
+@dataclass(frozen=True)
+class LevelTable(Expression):
+    """按等级查表；默认使用来源技能最终等级，越界返回 0，沿用旧表行为。
+
+    Args:
+        values: 等级数据数组，包含索引 0 对应的零级值。
+        level: 等级索引表达式，默认读取来源技能最终等级。
+    """
+    values: Sequence[float]
+    """等级数据数组，索引 0 表示零级；构造时复制为不可变元组。"""
+    level: Expression = field(default_factory=lambda: Read(SkillAttribute.LEVEL))
+    """等级索引表达式，可传 Read(SkillAttribute.LEVEL, '其他技能名称')。"""
+
+    def __post_init__(self):
+        object.__setattr__(self, 'values', tuple(_number(value) for value in self.values))
+        object.__setattr__(self, 'level', expression(self.level))
+
+    def evaluate(self, source: Skill) -> float:
+        level = self.level.evaluate(source)
+        if int(level) != level:
+            raise ValueError(f'等级表索引必须为整数: {source.name} -> {level}')
+        return self.values[int(level)] if 0 <= level < len(self.values) else 0
+
+    def dependencies(self) -> frozenset[Read]:
+        return self.level.dependencies()
+
+
+def Percent(value: Expression | float) -> Expression:
+    """百分数转小数：110 → 1.10。提高 110% 的倍率应写 1 + Percent(110)。"""
+    return expression(value) / 100
+
+
+class Condition:
+    """效果条件基类；条件的状态读取也必须声明为依赖。"""
+    def evaluate(self, source: Skill) -> bool:
+        """判断最终状态是否满足条件。"""
+        raise NotImplementedError
+
+    def dependencies(self) -> frozenset[Read]:
+        """返回条件判断需要读取的全部技能状态。"""
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class Equals(Condition):
+    """相等条件，例如 Equals(Read(SkillAttribute.VP), 1) 表示选择 VP1。"""
+    left: Expression | float
+    """左侧数值或表达式。"""
+    right: Expression | float
+    """右侧数值或表达式。"""
+
+    def __post_init__(self):
+        object.__setattr__(self, 'left', expression(self.left))
+        object.__setattr__(self, 'right', expression(self.right))
+
+    def evaluate(self, source: Skill) -> bool:
+        return cast(Expression, self.left).evaluate(source) == cast(Expression, self.right).evaluate(source)
+
+    def dependencies(self) -> frozenset[Read]:
+        return cast(Expression, self.left).dependencies() | cast(Expression, self.right).dependencies()
+
+
+@dataclass(frozen=True)
+class GreaterThan(Equals):
+    """大于条件，例如 GreaterThan(Read(SkillAttribute.LEVEL, '技能名称'), 0)。"""
+
+    def evaluate(self, source: Skill) -> bool:
+        return cast(Expression, self.left).evaluate(source) > cast(Expression, self.right).evaluate(source)
+
+
+@dataclass(frozen=True)
+class Not(Condition):
+    """条件取反，仍保留原条件的全部依赖。"""
+    condition: Condition
+    """需要取反的条件。"""
+
+    def __post_init__(self):
+        if not isinstance(self.condition, Condition):
+            raise TypeError('Not 需要 Condition 声明')
+
+    def evaluate(self, source: Skill) -> bool:
+        return not self.condition.evaluate(source)
+
+    def dependencies(self) -> frozenset[Read]:
+        return self.condition.dependencies()
+
+
+@dataclass(frozen=True)
+class All(Condition):
+    """全部条件成立；建图时收集全部条件依赖，不因短路判断遗漏依赖。"""
+    conditions: Sequence[Condition]
+    """条件数组，构造时复制为不可变元组。"""
+
+    def __post_init__(self):
+        if not all(isinstance(condition, Condition) for condition in self.conditions):
+            raise TypeError('All 需要 Condition 数组')
+        object.__setattr__(self, 'conditions', tuple(self.conditions))
+
+    def evaluate(self, source: Skill) -> bool:
+        return all(condition.evaluate(source) for condition in self.conditions)
+
+    def dependencies(self) -> frozenset[Read]:
+        return frozenset().union(*(condition.dependencies() for condition in self.conditions))
+
+
+@dataclass(frozen=True)
+class OutputTypeStartsWith(Condition):
+    """角色输出类型前缀条件，例如物理/魔法；读取计算准备阶段确定的角色输入。"""
+    prefix: str
+    """输出类型前缀，例如 '物理'。"""
+
+    def __post_init__(self):
+        if not isinstance(self.prefix, str) or not self.prefix:
+            raise ValueError('输出类型条件需要非空前缀')
+
+    def evaluate(self, source: Skill) -> bool:
+        return source.char.输出类型.startswith(self.prefix)
+
+    def dependencies(self) -> frozenset[Read]:
+        return frozenset()
+
+
+@dataclass(frozen=True)
+class WeaponCategoryContains(Condition):
+    """武器分类包含指定文本；匹配现有分类字段，如“传世武器”。"""
+    category: str
+    """武器分类中的匹配文本，支持“传世武器升级”等包含关系。"""
+
+    def __post_init__(self):
+        if not isinstance(self.category, str) or not self.category:
+            raise ValueError('武器分类条件需要非空名称')
+
+    def evaluate(self, source: Skill) -> bool:
+        return self.category in (source.char.GetWeaponType()[1] or '')
+
+    def dependencies(self) -> frozenset[Read]:
+        # Weapon facts are prepared by SetDetail before skill state evaluation.
+        return frozenset()
+
+
+@dataclass(frozen=True)
+class Select(Expression):
+    """条件选值：只求值实际分支，但建图时收集条件及两个分支的全部依赖。"""
+    condition: Condition
+    """选择分支的条件。"""
+    yes: Expression | float
+    """条件成立时使用的数值表达式。"""
+    no: Expression | float
+    """条件不成立时使用的数值表达式。"""
+
+    def __post_init__(self):
+        if not isinstance(self.condition, Condition):
+            raise TypeError('Select 需要 Condition 声明')
+        object.__setattr__(self, 'yes', expression(self.yes))
+        object.__setattr__(self, 'no', expression(self.no))
+
+    def evaluate(self, source: Skill) -> float:
+        branch = self.yes if self.condition.evaluate(source) else self.no
+        return cast(Expression, branch).evaluate(source)
+
+    def dependencies(self) -> frozenset[Read]:
+        return self.condition.dependencies() | cast(Expression, self.yes).dependencies() | cast(Expression, self.no).dependencies()
+
+
+def _names(values: Sequence[str], label: str) -> tuple[str, ...]:
+    if isinstance(values, str) or not all(isinstance(name, str) and name for name in values):
+        raise TypeError(f'{label} 必须是非空名称组成的数组')
+    return tuple(values)
+
+
+@dataclass(frozen=True, kw_only=True)
+class _Effect:
+    """效果声明公共字段；职业代码使用 SkillEffect 或 CharacterEffect。"""
+    value: Expression | float
+    """实际贡献值：乘算填倍率，加算填增量，覆盖填目标值，不隐式除以 100。"""
+    operation: Operation = Operation.MULTIPLY
+    """汇总运算，默认乘算。"""
+    when: Condition | None = None
+    """生效条件；省略表示不附加条件，来源技能仍须已学习。"""
+    weapon: Sequence[str] | None = None
+    """允许的武器类型数组，例如 ['光剑']；省略表示不限制武器类型。"""
+
+    def __post_init__(self):
+        object.__setattr__(self, 'value', expression(self.value))
+        if not isinstance(self.operation, Operation):
+            raise TypeError('效果运算必须使用 Operation')
+        if self.when is not None and not isinstance(self.when, Condition):
+            raise TypeError('效果条件必须使用 Condition 声明')
+        if self.weapon is not None:
+            object.__setattr__(self, 'weapon', _names(self.weapon, 'weapon'))
+
+    def dependencies(self) -> frozenset[Read]:
+        """贡献值与生效条件的全部状态依赖。"""
+        return cast(Expression, self.value).dependencies() | (self.when.dependencies() if self.when is not None else frozenset())
+
+    def evaluate(self, source: Skill) -> float:
+        """基于来源技能求出实际贡献值，并验证结果为有限数值。"""
+        return _number(cast(Expression, self.value).evaluate(source))
+
+
+class MissingTargetPolicy(str, Enum):
+    """缺失关联目标的处理方式；只对已确认的旧名称失配显式使用 SKIP。"""
+    ERROR = 'error'
+    """默认报错，避免新增规则静默失效。"""
+    SKIP = 'skip'
+    """跳过并记录 unresolved_targets，兼容旧规则中已存在的无效名称。"""
+
+
+@dataclass(frozen=True, kw_only=True)
+class SkillEffect(_Effect):
+    """作用于技能的效果声明；skills 继续接收技能名称数组，默认所有伤害技能。
+
+    Args:
+        value: 实际贡献值或表达式；乘算使用倍率，加算使用增量。
+        operation: 汇总运算，默认乘算。
+        attribute: 目标属性，默认技能技攻；也支持编号分段和职业专用输出属性。
+        skills: 目标技能名称数组，默认 '*' 表示所有伤害技能。
+        except_skills: 排除的技能名称数组。
+        when: 生效条件，默认无额外条件。
+        weapon: 允许的武器类型数组，默认不限制。
+        missing_target: 缺失目标时默认报错；迁移旧名称失配时可显式跳过并记录。
+    """
+    attribute: SkillAttribute | ProfessionAttribute | ComponentAttribute = SkillAttribute.DAMAGE
+    """目标属性，默认技能技攻；分段属性使用 Power/Hit/ExtraData/ExtraPower，职业属性使用 ProfessionAttribute 子类。"""
+    skills: Sequence[str] | Literal['*'] = '*'
+    """目标技能名称数组；'*' 仅选择伤害技能，指定名称时可关联被动技能。"""
+    except_skills: Sequence[str] = ()
+    """从目标中排除的技能名称数组。"""
+    missing_target: MissingTargetPolicy = MissingTargetPolicy.ERROR
+    """缺失目标处理策略；SKIP 仅用于保留已确认的旧名称失配行为。"""
+
+    def __post_init__(self):
+        super().__post_init__()
+        if isinstance(self.attribute, ProfessionAttribute):
+            name = self.attribute.value
+            if not isinstance(name, str) or not name.isidentifier() or name in {item.value for item in SkillAttribute}:
+                raise ValueError('职业属性必须使用独立的有效属性名，不能重定义公共属性')
+            if any(name.startswith(kind.value) and name[len(kind.value):].isdigit() for kind in ComponentKind):
+                raise ValueError('编号分段属性请使用 Power、Hit、ExtraData 或 ExtraPower')
+        elif not isinstance(self.attribute, ComponentAttribute) and (
+            not isinstance(self.attribute, SkillAttribute) or self.attribute.value not in WRITE_ATTRIBUTES
+        ):
+            raise ValueError('效果目标必须是可写的 SkillAttribute；VP/UP 只能作为外部输入')
+        if self.skills != '*':
+            object.__setattr__(self, 'skills', _names(self.skills, 'skills'))
+        object.__setattr__(self, 'except_skills', _names(self.except_skills, 'except_skills'))
+        if not isinstance(self.missing_target, MissingTargetPolicy):
+            raise TypeError('缺失目标策略必须使用 MissingTargetPolicy')
+
+
+@dataclass(frozen=True, kw_only=True)
+class CharacterEffect(_Effect):
+    """作用于角色标量属性的效果声明，沿用同一来源贡献汇总机制。
+
+    Args:
+        value: 实际贡献值或表达式，不隐式按百分比缩放。
+        attribute: 角色目标属性，例如 P_ATK_P 表示物理攻击力倍率。
+        operation: 汇总运算，默认乘算。
+        when: 生效条件，默认无额外条件。
+        weapon: 允许的武器类型数组，默认不限制。
+    """
+    attribute: CharacterAttribute
+    """角色目标属性，如 P_ATK_P（物理攻击力倍率）、SPIRIT（精神）。"""
+
+    def __post_init__(self):
+        super().__post_init__()
+        if not isinstance(self.attribute, CharacterAttribute):
+            raise TypeError('角色效果属性必须使用 CharacterAttribute')
+
+
+EffectDeclaration = SkillEffect | CharacterEffect
+"""类型化关联声明：技能效果或角色效果，均可放入 associate 数组。"""

backend/core/basic/skill_effects.py

@@ -16,12 +16,13 @@
 | 新增或修改的影响 | 维护位置 | 要点 |
 | --- | --- | --- |
 | 技伤、冷却、攻击段数等普通关联 | 对应 `core/character/GF/职业/角色.py` 的技能类 `associate` | 通常不改引擎；目标属性应有默认值 |
-| 随 VP、等级或自身参数变化的关联 | 来源技能的 `effect` | 每次生成完整声明，再调用 `super().effect(old, new)` |
+| 随 VP、等级或自身参数变化的关联 | `associate` 中的 `Read`、`LevelTable`、`Select`、`when` | 旧动态 `effect` 仍兼容，新规则优先用表达式 |
-| 技能给其他技能加级 | 来源技能的 `associate`，使用 `+lv` | 整数加级设置 `ratio=1`；只给已学习的目标加级 |
+| 技能给其他技能加级 | `SkillEffect(attribute=SkillAttribute.LEVEL, operation=Operation.ADD, ...)` | value 直接填整数增量；只给已学习的目标加级 |
 | 生命之树这类共享等级 | 目标技能的 `level_source` | 指向源技能名称，不再写等级 getter/no-op setter |
-| 新增会被关联修改、并影响后续关联的参数 | 技能类默认值 + `core/basic/skill_effects.py` 的 `STATE_ATTRIBUTES` | 例如现有 `ratio`、`maxLayer`；加入后自动属于输入属性 |
+| 新增会被关联修改、并影响后续关联的参数 | 技能类默认值 + `skill_effect_types.py` 的 `SkillAttribute`、`STATE_ATTRIBUTES` | 新参数同时检查读写范围；状态属性自动属于输入属性 |
 | 新增外部配置输入，改变它需要重新计算关联 | 技能类、配置赋值入口 + `INPUT_ATTRIBUTES` | 例如现有 `vp`；单纯登记不提供跨技能参数读取依赖 |
-| 新增角色属性关联 | `skill.py` 的角色贡献收集分支、`CHARACTER_ATTRIBUTES`，并核对 `character/base.py` 的 `SetStatus` | 当前仅支持对应标量字段；特殊运算需单独实现 |
+| 新增职业专用输出属性 | 职业文件内继承 `ProfessionAttribute` 定义枚举，并在目标技能设置数值默认值 | 成员紧跟中文文档字符串，IDE 可显示含义；不可通过 `Read` 读取 |
+| 新增角色属性关联 | `skill_effect_types.py` 的 `CharacterAttribute`，并核对 `character/base.py` 的 `SetStatus` | 当前仅支持对应标量字段；特殊运算需单独实现 |
 | 新增运算符、目标选择方式、跨技能非等级依赖 | `skill.py` 的公共关联入口 + `skill_effects.py` | 属于公共能力扩展，需配套单元测试 |
 | 装备改变技能等级或倍率 | 原装备规则及 `character/base.py` 的公共修改方法 | 使用已有批处理方法；低层直接写入须在 `batch()` 内 |
 | 仅影响单次技能展示/输出的模式、VP、UP 变换 | 原技能 `setMode`、`vp_N`、输出计算方法 | `skillInfo()` 使用临时副本，不要误改为持久关联 |
@@ -30,6 +31,61 @@
 
 ## 声明示例和数值约定
 
+新代码优先使用 `skill_effect_types.py` 的不可变声明，`associate` 继续是数组，目标仍然使用技能名称数组：
+
+```python
+associate = [
+    SkillEffect(skills=['目标技能名称'], value=1 + Percent(LevelTable(data0))),
+    SkillEffect(attribute=SkillAttribute.LEVEL, operation=Operation.ADD,
+                skills=['目标精通名称'], value=Read(SkillAttribute.LEVEL) + 1),
+    SkillEffect(attribute=Power(13), operation=Operation.ADD,
+                skills=['破军升龙击'], value=Percent(LevelTable(data2))),
+]
+```
+
+`SkillEffect` 作用于技能，`CharacterEffect` 作用于角色。Operation 明确区分加算、乘算、覆盖；
+新声明的 value 是实际贡献值，不再自动按百分比缩放，也不根据属性名称推测冷却公式。
+例如增加 20% 技伤使用 `1 + Percent(20)`，缩减 10% 冷却使用 `1 - Percent(10)`。
+旧 data[0] 不为零的规则迁移时必须保留零级基准的除法/减法，不能直接省略。
+
+`Read(SkillAttribute.RATIO, '技能名称')` 可分析跨技能状态依赖；省略名称表示读取自身。
+`LevelTable` 按来源最终等级取表，`Select` 按条件选值，`when=Equals(Read(SkillAttribute.VP), 1)` 控制是否生效。
+条件和未选分支也声明全部依赖，建图阶段不计算实际数值，避免在临时状态下发生除零或遗漏依赖。
+当前 Read 支持等级、ratio、maxLayer、VP、UP，不能读取尚未汇总的伤害/冷却输出。
+武器类型用 `weapon=['光剑']`，武器分类用 `WeaponCategoryContains('传世武器')`；武器信息来自提前完成的 SetDetail。
+
+编号属性通过 `Power(n)`、`Hit(n)`、`ExtraData(n)`、`ExtraPower(n)` 构造，分别对应 powerN、hitN、dataplusN、powerplusN。
+名称数组和等级表在构造时复制为元组，外部修改原数组不会影响已注册声明。
+新类型、枚举成员、字段和构造函数的中文文档可供编辑器悬停和补全查看。
+
+GF 职业的关联现已使用类型化声明，原 associate、动态 effect 和专用更新函数紧邻新实现注释保留。
+男/女大枪的等级目标、黑暗武士的连招目标仍在 effect 内动态组装技能名称数组；贡献值和条件使用类型化声明。
+模式、VP、UP 对临时技能副本的变换保留原实现，不属于持久关联。
+旧名称失配显式使用 `MissingTargetPolicy.SKIP`，继续记录 unresolved_targets；新规则默认报错，不要为了消除报错批量设置 SKIP。
+原先未生效的错误角色字段及特殊字典键保持原有效计算行为，迁移不同时修正规则。
+
+### 职业专用属性
+
+公共 `SkillAttribute` 仅维护通用字段。专用输出字段就近放在职业模块中，例如：
+
+```python
+class HunterAttribute(ProfessionAttribute):
+    '''猎人专用输出属性。'''
+    MARK_RATIO = 'markRation'
+    '''每层标记对应的技能伤害增量。'''
+
+# 目标技能先定义 markRation = 0，然后声明：
+associate = [SkillEffect(attribute=HunterAttribute.MARK_RATIO,
+                         operation=Operation.ADD, value=Percent(LevelTable(data0)))]
+```
+
+不同职业可各自定义同名字段。枚举值必须对应目标技能的实际数值属性；不能重定义公共字段或编号分段字段。
+专用枚举只用于最终输出，不自动加入状态依赖。将来某参数需要被后续关联读取时，应先登记公共状态/读写范围，
+再使用 Read 表达式，不能直接读取尚未汇总的输出。条件可组合 `All`、`Not`、`GreaterThan`；
+角色输出类型用 `OutputTypeStartsWith` 判断，所有条件均在建图时提供完整依赖。
+
+### 旧字典兼容
+
 以下片段放在对应技能类内，`data0` 为该来源技能的等级数据表：
 
 ```python
@@ -62,15 +118,16 @@ def effect(self, old, new):
 
 ## 职业规则
 
-静态 `associate` 格式不变。现有动态 `effect(old, new)` 作为兼容入口，在收集模式下以 `(0, 最终等级)` 执行；公共 `apply_association` / `update_skill_attribute` 记录贡献，不修改目标。每次收集都从原始 `associate` 声明开始，取消 VP 时不会保留上一次分支。
+`associate` 可以混用新声明和旧字典。现有动态 `effect(old, new)` 作为兼容入口，在收集模式下以 `(0, 最终等级)` 执行；公共入口记录贡献，不修改目标。每次收集都从原始 `associate` 声明开始，取消 VP 时不会保留上一次分支。
 
 动态规则只能生成关联声明，不能在收集过程中直接修改角色或目标技能。需要修改关联产生方式时，应改用声明，而不是另写参数 setter 撤销旧倍率。元素师原先的 `ratio` 补偿 setter 已移除，避免与公共引擎重复应用。
 
 引擎在创建时保存初始声明和状态默认值。动态分支应新建并赋值 `self.associate`，不要对共享的类级列表执行 `append` 或原地改写；也不要把运行后修改 `associate` 当作注册新规则。一次重算可能多次调用 `effect`，因此不能在其中累计计数、直接调用角色加成方法或依赖随机结果。
 
 依赖图目前自动识别三类依赖：共享等级源、收集时跨技能 `.lv` 读取、指向状态属性的关联。
-直接读取另一个技能的 `.ratio` 等非等级参数不会自动建立依赖。
+类型化表达式的 Read 额外提供跨技能状态参数依赖；普通 Python 代码直接读取其他技能的 `.ratio` 仍不会自动建立依赖。
-新增这类规则时需要先扩展公共依赖机制并验证顺序；单独加入 `INPUT_ATTRIBUTES` 只会触发重算，不能解决求值先后问题。
+新规则请使用 Read；单独加入 INPUT_ATTRIBUTES 只会触发重算，不能解决求值先后问题。
+本阶段仍使用技能级拓扑图，因此同一技能的状态回写、相互引用等可能被保守判定为循环；尚未升级为属性级依赖图。
 初次建图后新出现的等级读取或状态目标会报错；不要靠最终状态临时增加依赖边。
 
 每条贡献包含来源技能、条目索引、目标、属性、运算及数值，可从 `character.skill_effects.contributions` 检查。角色属性支持原 `SetStatus` 中相应的标量加算/乘算字段。
@@ -111,6 +168,7 @@ with character.skill_effects.batch():
 ## 诊断和验证
 
 找不到目标的旧关联仍按原逻辑跳过，同时记录在 `unresolved_targets`，供职业规则审查。例如刺客现存的“终结追击”名称失配；本次未推测其数值意图并修改规则。
+类型化声明的缺失目标/引用、错误属性/运算、非有限数值会报错，避免新规则继续静默失效。
 
 测试覆盖女弹药 2.32 场景及后续升降级、旅人条件、大枪加级、VP 切换、装备基线、角色属性、共享等级及链式共享、零覆盖、赋值冲突和循环依赖。全职业测试使用全部学习等级，在无 VP/VP1/VP2 下交换输入顺序，并另测搭配职业武器的情况。
 
@@ -122,6 +180,7 @@ with character.skill_effects.batch():
 
 ```sh
 backend/.venv/bin/pytest backend/tests/unit/test_skill_effects.py -q
+backend/.venv/bin/pytest backend/tests/unit/test_typed_skill_effects.py -q
 backend/.venv/bin/pytest backend/tests/smoke/test_calc_availability.py -k configuration_order -q
 ```
 
@@ -133,29 +192,36 @@ from dataclasses import dataclass
 from functools import wraps
 from graphlib import CycleError, TopologicalSorter
 from math import prod
+from .skill_effect_types import (
+    CharacterAttribute, CharacterEffect, EffectDeclaration, MissingTargetPolicy, Operation,
+    SkillEffect, STATE_ATTRIBUTES,
+)
 
 
-# 会被关联修改、且参与后续关联求值的属性在此登记，并在技能类上提供默认值。
+# 状态属性定义在 skill_effect_types；技能类仍须提供相应默认值。
-STATE_ATTRIBUTES = frozenset({'lv', 'ratio', 'maxLayer'})
 # 外部赋值触发重算的输入；登记在此不等于自动跟踪跨技能的该属性读取。
 INPUT_ATTRIBUTES = STATE_ATTRIBUTES | {'vp', 'up', 'comboCol', 'stage', 'currentMode'}
 # These are the scalar keys actually supported by CharacterBase.SetStatus.
 # 扩展前核对 SetStatus 的实际运算语义；特殊字段不能仅加入白名单。
-CHARACTER_ATTRIBUTES = frozenset({
+CHARACTER_ATTRIBUTES = frozenset(attribute.value for attribute in CharacterAttribute)
-    'STR', 'INT', 'Spirit', 'Vitality', 'AtkP', 'AtkM', 'AtkI',
-    'PAtkP', 'PAtkM', 'PAtkI', 'PSTR', 'PINT',
-})
 _MISSING = object()
 
 
 @dataclass(frozen=True)
 class SkillContribution:
+    """统一后的来源贡献；新声明和旧字典最终都编译为此结构。"""
     source: object
+    """提供本条效果的来源技能实例。"""
     index: int
+    """同一来源收集到的贡献序号，用于稳定汇总顺序。"""
     target: object
+    """接受贡献的技能或角色实例。"""
     attribute: str
+    """目标实例的底层属性名称。"""
     operation: str
+    """汇总运算：'+' 加算、'*' 乘算、'=' 覆盖。"""
     value: float
+    """已经完成等级取值、百分比转换和条件求值的实际贡献值。"""
 
 
 def skill_effect_batch(method):
@@ -186,6 +252,7 @@ class SkillEffectEngine:
         self._depth = 0
         self.resolving = False
         self.collecting = None
+        self._discovering = False
         self._pending = []
         self._reads = set()
         self._dirty = True
@@ -241,21 +308,87 @@ class SkillEffectEngine:
     def missing_target(self, source, name):
         self.unresolved_targets.add((source.name, name))
 
-    def _collect(self, skill):
+    def collect_effect(self, source, declaration: EffectDeclaration):
+        """Compile typed declarations into the same contributions as legacy rules.
+
+        Discovery reads structure only: no arithmetic or conditional branch is
+        evaluated before upstream state is ready. Inactive branches still expose
+        dependencies and possible state targets.
+        """
+        if self.collecting is not source:
+            raise RuntimeError('类型化效果只能由技能关联引擎收集')
+        for dependency in declaration.dependencies():
+            target = dependency.target(source)
+            if target is not source and dependency.attribute.value in STATE_ATTRIBUTES:
+                self._reads.add(target)
+
+        attribute = declaration.attribute.value
+        if isinstance(declaration, CharacterEffect):
+            targets = [self.character]
+        else:
+            targets = self.character.GetSkills('all', True) if declaration.skills == '*' else []
+            if declaration.skills != '*':
+                for name in declaration.skills:
+                    if name in declaration.except_skills:
+                        continue
+                    target = self.character.GetSkillByName(name)
+                    if target is None:
+                        if declaration.missing_target == MissingTargetPolicy.ERROR:
+                            raise ValueError(f'类型化效果目标不存在: {source.name} -> {name}')
+                        self.missing_target(source, name)
+                    else:
+                        targets.append(target)
+            targets = [target for target in targets if target.name not in declaration.except_skills]
+            for target in targets:
+                if attribute in STATE_ATTRIBUTES - {'lv'} and (target, attribute) not in self._state_base:
+                    raise ValueError(f'类型化效果状态缺少默认值: {source.name} -> {target.name}.{attribute}')
+
+        if self._discovering:
+            # Retain legacy precondition level reads, but never prune graph edges
+            # based on its provisional result. New conditions should use `when`.
+            source.precondition()
+            value = 0
+        else:
+            if not source.precondition():
+                return
+            if declaration.weapon is not None and self.character.GetWeaponType()[0] not in declaration.weapon:
+                return
+            if declaration.when is not None and not declaration.when.evaluate(source):
+                return
+            value = declaration.evaluate(source)
+
+        for target in targets:
+            if target is not self.character and attribute == 'lv':
+                if target.level_source is not None:
+                    continue
+                if not self._discovering and declaration.operation == Operation.ADD and not self.is_learned(target):
+                    continue
+            self.record(source, target, attribute, declaration.operation.value, value)
+
+    def _collect(self, skill, *, discover=False):
         # 一个重算周期会多次调用 effect；职业实现只能构造声明并调用公共收集入口。
         self._pending = []
         self._reads = set()
-        if not skill.association_source or skill.lv <= 0:
+        if not skill.association_source:
             return (), set()
         # VP branches often only assign associate when enabled. Start from the
         # declaration every time so disabling VP also removes the old branch.
         skill.associate = self._associations[skill]
         self.collecting = skill
+        self._discovering = discover
         try:
-            skill.effect(0, skill.lv)
+            if skill.lv > 0:
+                skill.effect(0, skill.lv)
+            elif discover:
+                # A typed level assignment can activate an initially unlearned
+                # source; its static dependencies must already be in the graph.
+                for declaration in skill.associate:
+                    if isinstance(declaration, (SkillEffect, CharacterEffect)):
+                        self.collect_effect(skill, declaration)
             return tuple(self._pending), self._reads.copy()
         finally:
             self.collecting = None
+            self._discovering = False
 
     @staticmethod
     def _combine(base, contributions):
@@ -280,7 +413,7 @@ class SkillEffectEngine:
 
     def resolve_states(self):
         # 依赖来源：level_source、跨技能 lv 读取、指向 STATE_ATTRIBUTES 的关联。
-        # 其他跨技能属性读取不会自动建边；新增此类规则须先扩展依赖机制。
+        # 类型化 Read 可声明跨技能状态参数依赖；普通 Python 属性读取仍不会自动建边。
         if self.resolving or not self._state_dirty:
             return
         self.resolving = True
@@ -299,7 +432,7 @@ class SkillEffectEngine:
                     if source is None:
                         raise ValueError(f'共享等级源技能不存在: {skill.name} -> {skill.level_source}')
                     graph[skill].add(source)
-                contributions, reads = self._collect(skill)
+                contributions, reads = self._collect(skill, discover=True)
                 graph[skill].update(reads)
                 for item in contributions:
                     if item.target is not self.character and item.attribute in STATE_ATTRIBUTES:

backend/core/character/GF/archer/chimera.py

@@ -1,6 +1,14 @@
 #b9cb48777665de22c006fabaf9a560b3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "archer/chimera/cn/skillDetail"
 
 
@@ -98,7 +106,11 @@ class Skill2(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{"type":"*skillDamage","data":[i-100 if i>0 else 0 for i in data0],"skills":["华丽回收"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*skillDamage","data":[i-100 if i>0 else 0 for i in data0],"skills":["华丽回收"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['华丽回收']),
+    ]
 
 # 受身蹲伏
 # archer/chimera/ce26c6b69d02a440a81b552bec94f03b
@@ -180,7 +192,11 @@ class Skill5(PassiveSkill):
     # 回收武器后，移动速度提升持续时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [ {"type":"*cdRatio","data":data0,"skills":['投掷匕首', '首足连击', '空翻刃袭', '利剑四重奏', '土星环', '环形毒液', '狂锯旋斧', '刺猬困境', '王冠粉碎者', '巨镰斯诺克', '环阿拉德狂飙']}, ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*cdRatio","data":data0,"skills":['投掷匕首', '首足连击', '空翻刃袭', '利剑四重奏', '土星环', '环形毒液', '狂锯旋斧', '刺猬困境', '王冠粉碎者', '巨镰斯诺克', '环阿拉德狂飙']}, ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_RATIO, value=1 - Percent(LevelTable(data0)), skills=['投掷匕首', '首足连击', '空翻刃袭', '利剑四重奏', '土星环', '环形毒液', '狂锯旋斧', '刺猬困境', '王冠粉碎者', '巨镰斯诺克', '环阿拉德狂飙']),
+    ]
 
 # 技能连招
 # archer/chimera/10b31c7e8cd2d60b9bcf3b1d3ada4b0a
@@ -559,9 +575,14 @@ class Skill18(ActiveSkill):
     # 异常状态持续时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"*skillDamage","data":data0},
+    #     {"type":"*skillDamage","data":data1,"exceptSkills":["华丽回收"]},
+    # ]
     associate = [
-        {"type":"*skillDamage","data":data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {"type":"*skillDamage","data":data1,"exceptSkills":["华丽回收"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), except_skills=['华丽回收']),
     ]
 
 # 空翻刃袭
@@ -718,7 +739,11 @@ class Skill23(PassiveSkill):
     # 移动速度增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [ {"type":"*skillDamage","data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*skillDamage","data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 土星环
 # archer/chimera/e862146efac2fce3de3a12f038f4116b
@@ -832,10 +857,14 @@ class Skill25(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"data":[0]+[-26]*self.maxLv,"skills":["瞬影"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"data":[0]+[-26]*self.maxLv,"skills":["瞬影"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-26] * maxLv)), skills=['瞬影'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 环形毒液
 # archer/chimera/854997c3bdfc3a2b498b4c4001f69e06
@@ -1038,7 +1067,11 @@ class Skill29(PassiveSkill):
     # 物理防御力增加 : {value1}
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [ {"type":"*skillDamage","data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*skillDamage","data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 重力加速度
 # archer/chimera/94c450d6214cafdc673f763badceeaf1
@@ -1198,7 +1231,11 @@ class Skill33(PassiveSkill):
     # 物理暴击率增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [ {"type":"*skillDamage","data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*skillDamage","data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 巨镰斯诺克
 # archer/chimera/0dbdeaf846356f8b9380f8fbb8e97377
@@ -1430,7 +1467,11 @@ class Skill37(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [ {"type":"*skillDamage","data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*skillDamage","data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 颠倒之浩劫
 # archer/chimera/bbc15561bec24f9c1e79e23d715b1dd2

backend/core/character/GF/archer/hunter.py

@@ -1,6 +1,27 @@
 # b9cb48777665de22c006fabaf9a560b3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data, _get_skill_damage_suffixes, _get_skill_dataplus_suffixes
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class HunterAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    MARK_RATIO = 'markRation'
+    """猎人：每层标记对应的技能伤害增量。"""
+    NORMAL_RATIO = 'normalRation'
+    """猎人：不消耗标记的技能伤害增量。"""
+
 
 prefix = "archer/hunter/cn/skillDetail"
 
@@ -131,7 +152,11 @@ class Skill2(PassiveSkill):
     # 转职技能冷却时间减少 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*cdReduce', 'exceptSkills': ['联合作战 : 围猎', '完美瞄准', '联合作战 : 最终一役']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*cdReduce', 'exceptSkills': ['联合作战 : 围猎', '完美瞄准', '联合作战 : 最终一役']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['联合作战 : 围猎', '完美瞄准', '联合作战 : 最终一役']),
+    ]
 
 # 帕伊卡 : 奇袭
 # archer/hunter/38612d8f2561edc2eb68d5057a837bfa
@@ -250,7 +275,11 @@ class Skill6(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['急速扳机']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['急速扳机']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['急速扳机']),
+    ]
 
 # 受身蹲伏
 # archer/hunter/ce26c6b69d02a440a81b552bec94f03b
@@ -561,7 +590,12 @@ class Skill16(PassiveSkill):
     # 单个敌人最大可标记层数 : {value4}
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{'data': data0, 'type': '+normalRation'}, {'data': data1, 'type': '+markRation'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '+normalRation'}, {'data': data1, 'type': '+markRation'}]
+    associate = [
+        SkillEffect(attribute=HunterAttribute.NORMAL_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data0))),
+        SkillEffect(attribute=HunterAttribute.MARK_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data1))),
+    ]
 
 # 帕伊卡 : 刃羽
 # archer/hunter/c77a417c43de80c4ce32c1ed405d174a
@@ -758,7 +792,11 @@ class Skill22(PassiveSkill):
     # 魔法值消耗量减少 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 重型穿甲箭
 # archer/hunter/8572675ec6a1f50b6eff6a867376c2de
@@ -929,8 +967,12 @@ class Skill27(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [重型穿甲箭]弩箭速度增加量 : 25%
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0, 'skills': ['重型穿甲箭']},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0, 'skills': ['重型穿甲箭']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['重型穿甲箭']),
     ]
     # [重型穿甲箭]弩箭速度增加量 : 25%
 
@@ -995,10 +1037,14 @@ class Skill28(HunterActiveSkill):
         self.cd = 24
         self.skillRation *= 1.6
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-20] * self.maxLv, 'skills': ['霰弹之箭']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-20] * self.maxLv, 'skills': ['霰弹之箭']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-20] * maxLv)), skills=['霰弹之箭'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 帕伊卡 : 困兽之网
 # archer/hunter/5152480fdde81362575a488d4cec4af9
@@ -1226,7 +1272,11 @@ class Skill32(PassiveSkill):
     # 暴击伤害增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data2, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 联合作战 : 围猎
 # archer/hunter/1812a1ece67bb37b6b44b54766450064
@@ -1432,7 +1482,11 @@ class Skill36(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 终结穿刺
 # archer/hunter/b89c9ab317bc0a443f6497b7cca2f6a8
@@ -1635,7 +1689,11 @@ class Skill40(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 联合作战 : 扭转战局
 # archer/hunter/e0daa922b19cdc35de879e938361464e

backend/core/character/GF/archer/muse.py

@@ -1,6 +1,12 @@
 #944b9aab492c15a8474f96947ceeb9e4
 from core.basic.skill import PassiveBufferSkill,ActiveBufferSkill,ActiveSkill,PassiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+)
 prefix = "archer/muse/cn/skillDetail"
 
 
@@ -515,7 +521,11 @@ class Skill15(PassiveBufferSkill):
     data13 = get_data(f'{prefix}/{uuid}', 13)
 
     Spirit = data0
-    associate = [{"data":data0,"type":"$+Spirit","ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"type":"$+Spirit","ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data0)),
+    ]
     CarryRatio = [0]+ [((1 + i / 100) ** 3) * 100 - 100 for i in data8]# noqa: E501
 
 # 乐力全开 : 力
@@ -1261,7 +1271,11 @@ class Skill33(PassiveBufferSkill):
 
     STRINT = data0
     Spirit = data1
-    associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data1)),
+    ]
 
 # 梦想的舞台
 # archer/muse/c61f5a010370101402b05b21916c2071
@@ -1511,7 +1525,11 @@ class Skill38(PassiveBufferSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
     Spirit = data0
-    associate = [{"data": data0,"type": "$+Spirit","ratio":1}]  # type: ignore
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data0,"type": "$+Spirit","ratio":1}]  # type: ignore
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data0)),
+    ]
 
 # 巨星登场
 # archer/muse/1721e94897e9961d5c98130a13392f17
@@ -1758,7 +1776,11 @@ class Skill43(PassiveBufferSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
     Spirit = data1
-    associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data1)),
+    ]
 
 # 梦幻三重奏
 # archer/muse/51a08fd0c90f0a5276cd552047fac93d

backend/core/character/GF/archer/traveler.py

@@ -1,6 +1,31 @@
 # b9cb48777665de22c006fabaf9a560b3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    All,
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    GreaterThan,
+    LevelTable,
+    MissingTargetPolicy,
+    Not,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class TravelerAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    TRAVELER_CDR = 'travelerCDR'
+    """旅人：装载模式的冷却缩减参数。"""
+    TRAVELER_DAMAGE = 'travelerDamage'
+    """旅人：装载模式的伤害加成参数。"""
+
 
 prefix = "archer/traveler/cn/skillDetail"
 
@@ -172,7 +197,11 @@ class Skill4(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['迷雾箭雨']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['迷雾箭雨']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['迷雾箭雨']),
+    ]
 
 # 受身蹲伏
 # archer/traveler/ce26c6b69d02a440a81b552bec94f03b
@@ -592,7 +621,11 @@ class Skill17(PassiveSkill):
     # 命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 暴击
 # archer/traveler/fc1262c19f3d0477ee8eda47b8db8696
@@ -790,7 +823,11 @@ class Skill23(ActiveSkill):
     # 暴击伤害增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [ {"data": data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"data": data3}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
+    ]
 
 # 高原雾花
 # archer/traveler/42c82812f86ff6704ae9952a2e6093a4
@@ -932,7 +969,11 @@ class Skill26(ActiveSkill):
     # 空中施放技能结束后霸体护甲持续时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '=travelerDamage', 'skills': ['装置驱动', '浓雾暴雨', '登跃飞锚', '神雾兵仗·妖旋风', '流雾疾风', '装载 : 烟花漫天', '装置驱动·星云', '神雾兵仗·流星']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '=travelerDamage', 'skills': ['装置驱动', '浓雾暴雨', '登跃飞锚', '神雾兵仗·妖旋风', '流雾疾风', '装载 : 烟花漫天', '装置驱动·星云', '神雾兵仗·流星']}]
+    associate = [
+        SkillEffect(attribute=TravelerAttribute.TRAVELER_DAMAGE, operation=Operation.ASSIGN, value=LevelTable(data0), skills=['装置驱动', '浓雾暴雨', '登跃飞锚', '神雾兵仗·妖旋风', '流雾疾风', '装载 : 烟花漫天', '装置驱动·星云', '神雾兵仗·流星'], missing_target=MissingTargetPolicy.SKIP),
+    ]
 
 # 浓雾暴雨
 # archer/traveler/ade01c1d6afc8a05055225045e89fe49
@@ -1106,7 +1147,11 @@ class Skill29(PassiveSkill):
     # 技能和消耗品生命值、 魔法值恢复效果增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 旷野火炎
 # archer/traveler/506e7ed77d517419a6e1c437a2cedb17
@@ -1175,7 +1220,11 @@ class Skill31(PassiveSkill):
     # 增益最大持续时间 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '=travelerCDR', 'skills': ['装置驱动', '浓雾暴雨', '登跃飞锚', '神雾兵仗·妖旋风', '流雾疾风', '装载 : 烟花漫天', '装置驱动·星云', '神雾兵仗·流星']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '=travelerCDR', 'skills': ['装置驱动', '浓雾暴雨', '登跃飞锚', '神雾兵仗·妖旋风', '流雾疾风', '装载 : 烟花漫天', '装置驱动·星云', '神雾兵仗·流星']}]
+    associate = [
+        SkillEffect(attribute=TravelerAttribute.TRAVELER_CDR, operation=Operation.ASSIGN, value=LevelTable(data0), skills=['装置驱动', '浓雾暴雨', '登跃飞锚', '神雾兵仗·妖旋风', '流雾疾风', '装载 : 烟花漫天', '装置驱动·星云', '神雾兵仗·流星'], missing_target=MissingTargetPolicy.SKIP),
+    ]
 
 # 登跃飞锚
 # archer/traveler/a5fa08f5d509e6ff2ebc68856a470b5a
@@ -1311,10 +1360,14 @@ class Skill33(TravelerActiveSkill):
         self.cd = 22.5
         self.skillRation *= 0.5
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-17] * self.maxLv, 'skills': ['绝技袭击']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-17] * self.maxLv, 'skills': ['绝技袭击']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-17] * maxLv)), skills=['绝技袭击'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 流浪之星的纹章
 # archer/traveler/8ee0099656df08a0b39225f8a21d514b
@@ -1343,12 +1396,17 @@ class Skill34(PassiveSkill):
     # [神雾兵仗·流星]冷却时间减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.char.GetSkillByName('自动操作模式').lv > 0 and self.char.GetSkillByName('神雾兵仗·流星').vp != 2:
+    # def effect(self, old, new):
-            self.associate = [{'data': self.data0, 'type': '*skillDamage'}]
+    #     if self.char.GetSkillByName('自动操作模式').lv > 0 and self.char.GetSkillByName('神雾兵仗·流星').vp != 2:
-        else:
+    #         self.associate = [{'data': self.data0, 'type': '*skillDamage'}]
-            self.associate = [{'data': self.data0, 'type': '*skillDamage'}, {'data': self.data1, 'type': '*cdReduce', 'skills': ['神雾兵仗·流星']}]
+    #     else:
-        return super().effect(old, new)
+    #         self.associate = [{'data': self.data0, 'type': '*skillDamage'}, {'data': self.data1, 'type': '*cdReduce', 'skills': ['神雾兵仗·流星']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), skills=['神雾兵仗·流星'], when=Not(All([GreaterThan(Read(SkillAttribute.LEVEL, '自动操作模式'), 0), Not(Equals(Read(SkillAttribute.VP, '神雾兵仗·流星'), 2))]))),
+    ]
 
 # 流雾疾风
 # archer/traveler/da6e37c1e3f0e8867f70007d89c239ff
@@ -1486,10 +1544,14 @@ class Skill37(TravelerActiveSkill):
         - [装置驱动]爆炸时追加小型烟花漫天\n
         """
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-26.6] * self.maxLv, 'skills': ['装置驱动']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-26.6] * self.maxLv, 'skills': ['装置驱动']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-26.6] * maxLv)), skills=['装置驱动'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 神雾兵仗·北极星
 # archer/traveler/a6c8f69107f8c4f5d1a0c7a57d000290
@@ -1567,7 +1629,11 @@ class Skill39(TravelerActiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data2, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 装置驱动 : 星云
 # archer/traveler/03bb5314ffd41e9458d67ef924fef38f

backend/core/character/GF/archer/vigilante.py

@@ -1,6 +1,12 @@
 # b9cb48777665de22c006fabaf9a560b3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "archer/vigilante/cn/skillDetail"
 
@@ -192,7 +198,11 @@ class Skill5(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['妖爪']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['妖爪']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['妖爪']),
+    ]
 
 # 受身蹲伏
 # archer/vigilante/ce26c6b69d02a440a81b552bec94f03b
@@ -653,7 +663,11 @@ class Skill19(PassiveSkill):
     # 妖兽形物理/魔法防御力增加 : {value2}
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 暴击
 # archer/vigilante/fc1262c19f3d0477ee8eda47b8db8696
@@ -1015,7 +1029,11 @@ class Skill28(PassiveSkill):
     # 命中率增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 狂妖风暴
 # archer/vigilante/8e358ecf99ac9df31a6132aeafe378a9
@@ -1191,7 +1209,11 @@ class Skill31(PassiveSkill):
     # [鲜活宴场]生命值恢复量增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 鲜活宴场
 # archer/vigilante/0e409ac3e1c1f3976b3ef2bfe4c13069
@@ -1380,7 +1402,11 @@ class Skill35(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 卸骨
 # archer/vigilante/527cdc3ecca985e18ef819d456532b26
@@ -1581,7 +1607,11 @@ class Skill39(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 神妖之爪
 # archer/vigilante/dd32a9825ec1af42a91f2223be6658e5

backend/core/character/GF/demonic_lancer/dragoon.py

@@ -1,6 +1,17 @@
 # 3deb7be5f01953ac8b1ecaa1e25e0420
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "demonic_lancer/dragoon/cn/skillDetail"
 
@@ -123,7 +134,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['猎杀枪']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['猎杀枪']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['猎杀枪']),
+    ]
 
 # 受身蹲伏
 # demonic_lancer/dragoon/ce26c6b69d02a440a81b552bec94f03b
@@ -535,8 +550,12 @@ class Skill17(PassiveSkill):
     # 攻击速度增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkM', 'data': data0},
+    # ]
     associate = [
-        {'type': '$*PAtkM', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 猎杀枪
@@ -672,7 +691,11 @@ class Skill21(PassiveSkill):
     # 命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 暴击
 # demonic_lancer/dragoon/fc1262c19f3d0477ee8eda47b8db8696
@@ -1159,7 +1182,12 @@ class Skill32(PassiveSkill):
     # 技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': [-i for i in data0], 'type': '+cd', 'skills': ['猎杀枪'], 'ratio': 1}, {'data': data1, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': [-i for i in data0], 'type': '+cd', 'skills': ['猎杀枪'], 'ratio': 1}, {'data': data1, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([-i for i in data0]), skills=['猎杀枪']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 逐云灭龙杀
 # demonic_lancer/dragoon/4f2e001e9a19eb7bae50ad1840dfb329
@@ -1258,10 +1286,14 @@ class Skill34(ActiveSkill):
         - 掠食攻击力 : 基础攻击力的74%\n
         """
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-26] * self.maxLv, 'skills': ['猎杀枪 : 穿心', '猎杀枪 : 掠食']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-26] * self.maxLv, 'skills': ['猎杀枪 : 穿心', '猎杀枪 : 掠食']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-26] * maxLv)), skills=['猎杀枪 : 穿心', '猎杀枪 : 掠食'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 地龙狩
 # demonic_lancer/dragoon/8572675ec6a1f50b6eff6a867376c2de
@@ -1316,10 +1348,14 @@ class Skill35(ActiveSkill):
         突进过程中所受伤害 -75%\n
         """
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-23] * self.maxLv, 'skills': ['光焰枪']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-23] * self.maxLv, 'skills': ['光焰枪']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-23] * maxLv)), skills=['光焰枪'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 狩猎之心
 # demonic_lancer/dragoon/2a0a39184de92acf1c1375e00b77404c
@@ -1349,7 +1385,11 @@ class Skill36(PassiveSkill):
     # 命中率增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 凌空之狩
 # demonic_lancer/dragoon/9dc8438e4572d39243c97da31c113acc
@@ -1404,10 +1444,14 @@ class Skill37(ActiveSkill):
         self.cd = 20
         self.skillRation *= 0.5
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-27] * self.maxLv, 'skills': ['利刃收割']}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-27] * self.maxLv, 'skills': ['利刃收割']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-27] * maxLv)), skills=['利刃收割'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
 # 无尽毁灭
 # demonic_lancer/dragoon/3fb8395ae3b81bd608e0c4223a8eb534
@@ -1534,7 +1578,11 @@ class Skill40(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [蛮横冲撞]按向前方向键时前进距离额外增加 : 30%
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # [蛮横冲撞]按向前方向键时前进距离额外增加 : 30%
 
 # 瞬光猎杀枪

backend/core/character/GF/demonic_lancer/impaler.py

@@ -1,6 +1,15 @@
 # 3deb7be5f01953ac8b1ecaa1e25e0420
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "demonic_lancer/impaler/cn/skillDetail"
 
@@ -491,32 +500,60 @@ class Skill16(PassiveSkill):
     # 减速状态下敌人攻击速度和移动速度减少率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'type': '*skillDamage'},
+    #     {'data': data1, 'type': '*power0', 'skills': ['双重投射']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['暗矛投射']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['绝望枪']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['连锁侵蚀']},
+    #     {'data': data1, 'type': '*power1', 'skills': ['连锁侵蚀']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['暗蚀螺旋枪']},
+    #     {'data': data1, 'type': '*power2', 'skills': ['暗蚀螺旋枪']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['坠蚀之雨']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['暗蚀爆雷杀']},
+    #     {'data': data1, 'type': '*power1', 'skills': ['暗蚀爆雷杀']},
+    #     {'data': data1, 'type': '*power2', 'skills': ['暗蚀爆雷杀']},
+    #     {'data': data1, 'type': '*power2', 'skills': ['无尽侵蚀 : 缚魂']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['黑蚀酷刑']},
+    #     {'data': data1, 'type': '*power1', 'skills': ['黑蚀酷刑']},
+    #     {'data': data1, 'type': '*power3', 'skills': ['黑蚀酷刑']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['冥夜裂空']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['冥蚀脉冲']},
+    #     {'data': data1, 'type': '*power1', 'skills': ['冥蚀脉冲']},
+    #     {'data': data1, 'type': '*power3', 'skills': ['冥蚀脉冲']},
+    #     {'data': data1, 'type': '*power1', 'skills': ['幽影暗蚀 : 寂灭']},
+    #     {'data': data1, 'type': '*power0', 'skills': ['虚空碎灭']},
+    #     {'data': data1, 'type': '*power1', 'skills': ['虚空碎灭']},
+    #     {'data': data1, 'type': '*power3', 'skills': ['虚空碎灭']},
+    #     {'data': data1, 'type': '*power2', 'skills': ['暗·渊灭禁绝']},
+    # ]
     associate = [
-        {'data': data0, 'type': '*skillDamage'},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {'data': data1, 'type': '*power0', 'skills': ['双重投射']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['双重投射']),
-        {'data': data1, 'type': '*power0', 'skills': ['暗矛投射']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['暗矛投射']),
-        {'data': data1, 'type': '*power0', 'skills': ['绝望枪']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['绝望枪']),
-        {'data': data1, 'type': '*power0', 'skills': ['连锁侵蚀']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['连锁侵蚀']),
-        {'data': data1, 'type': '*power1', 'skills': ['连锁侵蚀']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data1)), skills=['连锁侵蚀']),
-        {'data': data1, 'type': '*power0', 'skills': ['暗蚀螺旋枪']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['暗蚀螺旋枪']),
-        {'data': data1, 'type': '*power2', 'skills': ['暗蚀螺旋枪']},
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable(data1)), skills=['暗蚀螺旋枪']),
-        {'data': data1, 'type': '*power0', 'skills': ['坠蚀之雨']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['坠蚀之雨']),
-        {'data': data1, 'type': '*power0', 'skills': ['暗蚀爆雷杀']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['暗蚀爆雷杀']),
-        {'data': data1, 'type': '*power1', 'skills': ['暗蚀爆雷杀']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data1)), skills=['暗蚀爆雷杀']),
-        {'data': data1, 'type': '*power2', 'skills': ['暗蚀爆雷杀']},
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable(data1)), skills=['暗蚀爆雷杀']),
-        {'data': data1, 'type': '*power2', 'skills': ['无尽侵蚀 : 缚魂']},
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable(data1)), skills=['无尽侵蚀 : 缚魂']),
-        {'data': data1, 'type': '*power0', 'skills': ['黑蚀酷刑']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['黑蚀酷刑']),
-        {'data': data1, 'type': '*power1', 'skills': ['黑蚀酷刑']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data1)), skills=['黑蚀酷刑']),
-        {'data': data1, 'type': '*power3', 'skills': ['黑蚀酷刑']},
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable(data1)), skills=['黑蚀酷刑']),
-        {'data': data1, 'type': '*power0', 'skills': ['冥夜裂空']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['冥夜裂空']),
-        {'data': data1, 'type': '*power0', 'skills': ['冥蚀脉冲']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['冥蚀脉冲']),
-        {'data': data1, 'type': '*power1', 'skills': ['冥蚀脉冲']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data1)), skills=['冥蚀脉冲']),
-        {'data': data1, 'type': '*power3', 'skills': ['冥蚀脉冲']},
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable(data1)), skills=['冥蚀脉冲']),
-        {'data': data1, 'type': '*power1', 'skills': ['幽影暗蚀 : 寂灭']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data1)), skills=['幽影暗蚀 : 寂灭']),
-        {'data': data1, 'type': '*power0', 'skills': ['虚空碎灭']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data1)), skills=['虚空碎灭']),
-        {'data': data1, 'type': '*power1', 'skills': ['虚空碎灭']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data1)), skills=['虚空碎灭']),
-        {'data': data1, 'type': '*power3', 'skills': ['虚空碎灭']},
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable(data1)), skills=['虚空碎灭']),
-        {'data': data1, 'type': '*power2', 'skills': ['暗·渊灭禁绝']},
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable(data1)), skills=['暗·渊灭禁绝']),
     ]
 
 # 帝国枪术
@@ -688,8 +725,12 @@ class Skill21(PassiveSkill):
     # 命中增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkM', 'data': data0},
+    # ]
     associate = [
-        {'type': '$*PAtkM', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 暴击
@@ -921,7 +962,11 @@ class Skill28(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 连锁侵蚀
 # demonic_lancer/impaler/2c9d9a36c8401bddff6cdb80fab8dc24
@@ -1218,7 +1263,11 @@ class Skill33(PassiveSkill):
     # 暗蚀持续时间增加 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 无尽侵蚀 : 缚魂
 # demonic_lancer/impaler/e0daa922b19cdc35de879e938361464e
@@ -1431,7 +1480,11 @@ class Skill37(PassiveSkill):
     # 暗蚀领域持续时间 : {value4}秒
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 冥夜裂空
 # demonic_lancer/impaler/7ec521d063d2190e1fcc5bd229af9bcf
@@ -1642,7 +1695,11 @@ class Skill41(PassiveSkill):
     # 总投掷次数 : 15次
     # 绝望枪攻击力 : 原有[绝望枪]投掷魔枪攻击力的60%
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # [绝望枪]
     # 总投掷次数 : 15次
     # 绝望枪攻击力 : 原有[绝望枪]投掷魔枪攻击力的60%

backend/core/character/GF/demonic_lancer/skirmisher.py

@@ -1,6 +1,14 @@
 # 3deb7be5f01953ac8b1ecaa1e25e0420
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "demonic_lancer/skirmisher/cn/skillDetail"
 
@@ -490,9 +498,14 @@ class Skill15(PassiveSkill):
     # 命中率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0},
+    #     {'type': '*cdReduce', 'data': data1, 'exceptSkills': ['流云幻灭', '极影无形杀', '问鼎·千军破云']},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
-        {'type': '*cdReduce', 'data': data1, 'exceptSkills': ['流云幻灭', '极影无形杀', '问鼎·千军破云']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=['流云幻灭', '极影无形杀', '问鼎·千军破云']),
     ]
 
 # 行云诀
@@ -825,7 +838,11 @@ class Skill25(PassiveSkill):
     # 技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 无畏波动枪
 # demonic_lancer/skirmisher/8c2379737c5acc935c1731f67f607655
@@ -1167,12 +1184,20 @@ class Skill31(PassiveSkill):
     # 基本攻击和其他技能的攻击力增加率 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'type': '*skillDamage', 'skills': ['行云 : 风']},
+    #     {'data': data1, 'type': '*skillDamage', 'skills': ['行云 : 疾']},
+    #     {'data': data2, 'type': '*skillDamage', 'skills': ['行云 : 落']},
+    #     {'data': data3, 'type': '*skillDamage', 'skills': ['连环枪']},
+    #     {'data': data4, 'type': '*skillDamage', 'exceptSkills': ['行云 : 风', '行云 : 疾', '行云 : 落']},
+    # ]
     associate = [
-        {'data': data0, 'type': '*skillDamage', 'skills': ['行云 : 风']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['行云 : 风']),
-        {'data': data1, 'type': '*skillDamage', 'skills': ['行云 : 疾']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['行云 : 疾']),
-        {'data': data2, 'type': '*skillDamage', 'skills': ['行云 : 落']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), skills=['行云 : 落']),
-        {'data': data3, 'type': '*skillDamage', 'skills': ['连环枪']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), skills=['连环枪']),
-        {'data': data4, 'type': '*skillDamage', 'exceptSkills': ['行云 : 风', '行云 : 疾', '行云 : 落']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), except_skills=['行云 : 风', '行云 : 疾', '行云 : 落']),
     ]
 
 # 流云幻灭
@@ -1407,7 +1432,13 @@ class Skill35(PassiveSkill):
     # 除行云系外的技能攻击力增加率 : {value9}%
     data9 = get_data(f'{prefix}/{uuid}', 9)
 
-    associate = [{'data': data2, 'type': '*skillDamage', 'skills': ['行云 : 风', '行云 : 疾', '行云 : 落']}, {'data': data3, 'type': '*skillDamage', 'skills': ['刺击', '双重刺击']}, {'data': data4, 'type': '*skillDamage', 'exceptSkills': ['行云 : 风', '行云 : 疾', '行云 : 落', '刺击', '双重刺击']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2, 'type': '*skillDamage', 'skills': ['行云 : 风', '行云 : 疾', '行云 : 落']}, {'data': data3, 'type': '*skillDamage', 'skills': ['刺击', '双重刺击']}, {'data': data4, 'type': '*skillDamage', 'exceptSkills': ['行云 : 风', '行云 : 疾', '行云 : 落', '刺击', '双重刺击']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), skills=['行云 : 风', '行云 : 疾', '行云 : 落']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), skills=['刺击', '双重刺击']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), except_skills=['行云 : 风', '行云 : 疾', '行云 : 落', '刺击', '双重刺击']),
+    ]
 
 # 无双突刺
 # demonic_lancer/skirmisher/bc11d28c04e01923a093d65752c55516
@@ -1604,7 +1635,11 @@ class Skill39(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 双龙流云灭
 # demonic_lancer/skirmisher/4c5271b0ecce120d7fc113f377fae76f

backend/core/character/GF/demonic_lancer/vanguard.py

@@ -1,6 +1,15 @@
 # 3deb7be5f01953ac8b1ecaa1e25e0420
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "demonic_lancer/vanguard/cn/skillDetail"
 
@@ -125,7 +134,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['霸王戟']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['霸王戟']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['霸王戟']),
+    ]
 
 # 受身蹲伏
 # demonic_lancer/vanguard/ce26c6b69d02a440a81b552bec94f03b
@@ -596,7 +609,11 @@ class Skill18(PassiveSkill):
     # 被领主怪物攻击时，不会僵直的伤害量上限 : 生命值最大值的{value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 破军突击
 # demonic_lancer/vanguard/c27418ae613c647527200a7ca17d97fd
@@ -761,7 +778,11 @@ class Skill23(ActiveSkill):
     # 斩击范围比率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'type': '$*PAtkP', 'data': data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data3}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data3))),
+    ]
 
     def getSkillCD(self, mode=None):
         return self.cd
@@ -1055,7 +1076,11 @@ class Skill29(PassiveSkill):
     # [第2阶段]被击时，不会进入僵直的伤害量上限增加 : 生命值最大值的{value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 千魂弑
 # demonic_lancer/vanguard/d0cdaca82892e54097f22a1f60817048
@@ -1292,7 +1317,11 @@ class Skill34(PassiveSkill):
     # [战戟猛攻]能量层数增加量 : {value1}
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 断魂裂岩斩
 # demonic_lancer/vanguard/ca75c965f20a150f99f54155a37400df
@@ -1420,7 +1449,12 @@ class Skill37(PassiveSkill):
     # 命中时能量恢复时间减少量 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}, {'data': [-i for i in data1], 'type': '+cd', 'skills': ['战戟猛攻'], 'ratio': 1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}, {'data': [-i for i in data1], 'type': '+cd', 'skills': ['战戟猛攻'], 'ratio': 1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([-i for i in data1]), skills=['战戟猛攻']),
+    ]
 
 # 镇狱裂地枪
 # demonic_lancer/vanguard/78b86e64fbb74c1db1b71c50a5ac21cd

backend/core/character/GF/extra/creator.py

@@ -1,6 +1,14 @@
 # b522a95d819a5559b775deb9a490e49a
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "extra/creator/cn/skillDetail"
 
@@ -510,7 +518,11 @@ class Skill16(PassiveSkill):
     # 施放速度增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '$*PAtkI'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '$*PAtkI'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_I, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 具象强化
 # extra/creator/ef9d26746effee9199b54541f01b8752
@@ -536,7 +548,11 @@ class Skill17(PassiveSkill):
     # 各系列攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 烈焰飓风
 # extra/creator/e788de1a4498c99fcc790302c4d41fed
@@ -877,7 +893,11 @@ class Skill25(PassiveSkill):
     # 烈炎、 寒冰、 守护、 风暴系列能量增加量 : {value1}
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 自我觉醒
 # extra/creator/845e0ce3235e19f60cc82a082d072cba
@@ -911,7 +931,11 @@ class Skill26(PassiveSkill):
     # 独立攻击力增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data3, 'type': '$*PAtkI'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data3, 'type': '$*PAtkI'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_I, value=1 + Percent(LevelTable(data3))),
+    ]
 
 # 终末狂想
 # extra/creator/5536486eaf9b13c9a8283447cb5e77ab
@@ -1220,7 +1244,11 @@ class Skill33(PassiveSkill):
     # 烈炎、 寒冰、 守护、 风暴系列能量增加量 : {value1}
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 虚空
 # extra/creator/dacd5c2848a1eb33489e5471f1a73759
@@ -1484,7 +1512,11 @@ class Skill39(PassiveSkill):
     # [冰霜之球]能量恢复率 :  {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 创生
 # extra/creator/1bf9711f3f15865e38d7dce51c6b5a8c

backend/core/character/GF/extra/dark_knight.py

@@ -2,21 +2,37 @@
 from core.basic.character.calc_carry import _skill_error_context
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Not,
+    Operation,
+    OutputTypeStartsWith,
+    Percent,
+    Read,
+    Select,
+    SkillAttribute,
+    SkillEffect,
+    WeaponCategoryContains,
+)
 
 prefix = "extra/dark_knight/cn/skillDetail"
 
 
-def apply_weapon_mastery(skill: PassiveSkill, old: int, new: int, weapon_type: str):
+# 迁移前武器精通辅助函数（保留对照）：
-    weapon = skill.char.GetWeaponType()
+# def apply_weapon_mastery(skill: PassiveSkill, old: int, new: int, weapon_type: str):
-    if weapon[0] != weapon_type:
+#     weapon = skill.char.GetWeaponType()
-        return None
+#     if weapon[0] != weapon_type:
-
+#         return None
-    physical = skill.char.输出类型.startswith('物理')
+#
-    inherited = '传世武器' in weapon[1]
+#     physical = skill.char.输出类型.startswith('物理')
-    data_index = (3 if physical else 4) if inherited else (0 if physical else 1)
+#     inherited = '传世武器' in weapon[1]
-    attack_type = '$*PAtkP' if physical else '$*PAtkM'
+#     data_index = (3 if physical else 4) if inherited else (0 if physical else 1)
-    skill.associate = [{'type': attack_type, 'data': getattr(skill, f'data{data_index}')}]
+#     attack_type = '$*PAtkP' if physical else '$*PAtkM'
-    return PassiveSkill.effect(skill, old, new)
+#     skill.associate = [{'type': attack_type, 'data': getattr(skill, f'data{data_index}')}]
+#     return PassiveSkill.effect(skill, old, new)
 
 class DarkKnightSkill(ActiveSkill):
     # 默认5阶段
@@ -208,7 +224,11 @@ class Skill5(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['挑击']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['挑击']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['挑击']),
+    ]
 
 # 受身蹲伏
 # extra/dark_knight/ce26c6b69d02a440a81b552bec94f03b
@@ -666,8 +686,13 @@ class Skill19(PassiveSkill):
     # 命中率增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        return apply_weapon_mastery(self, old, new, '光剑')
+    # def effect(self, old, new):
+    #     return apply_weapon_mastery(self, old, new, '光剑')
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data3), LevelTable(data0))), weapon=['光剑'], when=OutputTypeStartsWith('物理')),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data4), LevelTable(data1))), weapon=['光剑'], when=Not(OutputTypeStartsWith('物理'))),
+    ]
 
 # 暗 · 短剑精通
 # extra/dark_knight/01c3a2fb793d293a25ed8dc7a0d70c1a
@@ -705,8 +730,13 @@ class Skill20(PassiveSkill):
     # 命中率增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        return apply_weapon_mastery(self, old, new, '短剑')
+    # def effect(self, old, new):
+    #     return apply_weapon_mastery(self, old, new, '短剑')
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data3), LevelTable(data0))), weapon=['短剑'], when=OutputTypeStartsWith('物理')),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data4), LevelTable(data1))), weapon=['短剑'], when=Not(OutputTypeStartsWith('物理'))),
+    ]
 
 # 暗 · 太刀精通
 # extra/dark_knight/8f73f243041c2d27739fe7696f02bf9b
@@ -744,8 +774,13 @@ class Skill21(PassiveSkill):
     # 命中率增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        return apply_weapon_mastery(self, old, new, '太刀')
+    # def effect(self, old, new):
+    #     return apply_weapon_mastery(self, old, new, '太刀')
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data3), LevelTable(data0))), weapon=['太刀'], when=OutputTypeStartsWith('物理')),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data4), LevelTable(data1))), weapon=['太刀'], when=Not(OutputTypeStartsWith('物理'))),
+    ]
 
 # 暗 · 巨剑精通
 # extra/dark_knight/8c2379737c5acc935c1731f67f607655
@@ -783,8 +818,13 @@ class Skill22(PassiveSkill):
     # 命中率增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        return apply_weapon_mastery(self, old, new, '巨剑')
+    # def effect(self, old, new):
+    #     return apply_weapon_mastery(self, old, new, '巨剑')
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data3), LevelTable(data0))), weapon=['巨剑'], when=OutputTypeStartsWith('物理')),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data4), LevelTable(data1))), weapon=['巨剑'], when=Not(OutputTypeStartsWith('物理'))),
+    ]
 
 # 暗 · 钝器精通
 # extra/dark_knight/9cb6f9ed646fa87f9b7680a42ce83d1a
@@ -822,8 +862,13 @@ class Skill23(PassiveSkill):
     # 命中率增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        return apply_weapon_mastery(self, old, new, '钝器')
+    # def effect(self, old, new):
+    #     return apply_weapon_mastery(self, old, new, '钝器')
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data3), LevelTable(data0))), weapon=['钝器'], when=OutputTypeStartsWith('物理')),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data4), LevelTable(data1))), weapon=['钝器'], when=Not(OutputTypeStartsWith('物理'))),
+    ]
 
 # 暗劲爆发
 # extra/dark_knight/506e7ed77d517419a6e1c437a2cedb17
@@ -882,7 +927,11 @@ class Skill25(PassiveSkill):
     hasUP = False
     custom = get_data(f'{prefix}/{uuid}', 'custom')  # noqa: E501
 
-    associate = [{'type': '+lv', 'data': [i + 1 if i > 0 else i for i in range(0, maxLv + 3)], 'ratio': 1, 'skills': ['暗 · 光剑精通', '暗 · 钝器精通', '暗 · 太刀精通', '暗 · 巨剑精通', '暗 · 短剑精通']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+lv', 'data': [i + 1 if i > 0 else i for i in range(0, maxLv + 3)], 'ratio': 1, 'skills': ['暗 · 光剑精通', '暗 · 钝器精通', '暗 · 太刀精通', '暗 · 巨剑精通', '暗 · 短剑精通']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.LEVEL, operation=Operation.ADD, value=LevelTable([i + 1 if i > 0 else i for i in range(0, maxLv + 3)]), skills=['暗 · 光剑精通', '暗 · 钝器精通', '暗 · 太刀精通', '暗 · 巨剑精通', '暗 · 短剑精通']),
+    ]
 
 
 # 暗影鞭
@@ -1692,7 +1741,11 @@ class Skill44(PassiveSkill):
     # 施放连续技期间所受伤害减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 幽魂剑
 # extra/dark_knight/ce7cd04a44e32212e80f120f4421996e
@@ -1783,7 +1836,12 @@ class Skill46(PassiveSkill):
     # 物理、 魔法攻击力增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'type': '$*PAtkP', 'data': data3}, {'type': '$*PAtkM', 'data': data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data3}, {'type': '$*PAtkM', 'data': data3}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data3))),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data3))),
+    ]
 
 # 暗炎冥魂波
 # extra/dark_knight/5c00ce6d7dbbb5e9a0f6e1071d486832
@@ -1920,7 +1978,12 @@ class Skill49(PassiveSkill):
     # 物理、 魔法暴击率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'type': '$*PSTR', 'data': data2}, {'type': '$*PINT', 'data': data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PSTR', 'data': data2}, {'type': '$*PINT', 'data': data2}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_STR, value=1 + Percent(LevelTable(data2))),
+        CharacterEffect(attribute=CharacterAttribute.P_INT, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 邪影升龙斩
 # extra/dark_knight/b1732acfaf117f8e9ff130f47d3ed0e7
@@ -1971,6 +2034,19 @@ class Skill50(DarkKnightSkill):
         """
         self.stage = 6
 
+    # 迁移前实现（保留对照）：
+    # def effect(self, old, new):
+    #     # 选择该vp之后，当前列的连招列的其他技能都没有伤害
+    #     skills = []
+    #     for index in self.char.combos[self.comboCol]:
+    #          if str(index) != str(self.id):
+    #              skill = self.char.GetSkillByID(index)
+    #              if skill:
+    #                  skills.append(skill.name)
+    #     if self.vp == 2:
+    #         self.associate = [{"type":"=skillDamage","data":[0] + [0]*self.maxLv,"skills":skills}]
+    #     return super().effect(old, new)
+    # 仅动态枚举目标名称，贡献值与 VP 条件交由类型化声明处理。
     def effect(self, old, new):
         # 选择该vp之后，当前列的连招列的其他技能都没有伤害
         skills = []
@@ -1979,8 +2055,9 @@ class Skill50(DarkKnightSkill):
                  skill = self.char.GetSkillByID(index)
                  if skill:
                      skills.append(skill.name)
-        if self.vp == 2:
+        self.associate = [
-            self.associate = [{"type":"=skillDamage","data":[0] + [0]*self.maxLv,"skills":skills}]
+            SkillEffect(attribute=SkillAttribute.DAMAGE, operation=Operation.ASSIGN, value=LevelTable([0] + [0] * self.maxLv), skills=skills, when=Equals(Read(SkillAttribute.VP), 2)),
+        ]
         return super().effect(old, new)
 
 # 超时空碎裂
@@ -2048,7 +2125,11 @@ class Skill52(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [时空主宰]效果持续时间 : 5秒
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # [时空主宰]效果持续时间 : 5秒
 
 # 暗黑溯回斩

backend/core/character/GF/fighter_female/brawler_female.py

@@ -2,6 +2,25 @@
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data, _get_skill_damage_suffixes, _get_skill_dataplus_suffixes
 from core.basic.character import Character
 from core.basic.enum.skill import EnumDamageType
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Hit,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class BrawlerFemaleAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    ENCHANT_POISON_RATIO = 'enchantPoisonRatio'
+    """女街霸：涂毒附加伤害倍率。"""
+
 prefix = "fighter_female/brawler_female/cn/skillDetail"
 
 
@@ -783,10 +802,14 @@ class Skill23(ActiveSkill):
     # 技能中包含的[涂毒]中毒攻击力变化率 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{
+    # 迁移前实现（保留对照）：
-        "type": "*enchantPoisonRatio",
+    # associate = [{
-        "data": [0] + [enchantPoisonRatio * 100] * maxLv,
+    #     "type": "*enchantPoisonRatio",
-    }]
+    #     "data": [0] + [enchantPoisonRatio * 100] * maxLv,
+    # }]
+    associate = [
+        SkillEffect(attribute=BrawlerFemaleAttribute.ENCHANT_POISON_RATIO, value=1 + Percent(LevelTable([0] + [enchantPoisonRatio * 100] * maxLv))),
+    ]
 
 # 袭刺
 # fighter_female/brawler_female/dde3b443bd5e61d90c34e5ee771e2c28
@@ -877,11 +900,18 @@ class Skill25(ActiveSkill):
     # [爆碎砖袭]爆炸范围增加率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"skills": ["街头风暴"],"data": [0] + [50] * maxLv , "type": "=hit0", 'ratio': 1},
+    #     {"skills": ["街头风暴"],"data": [0] + [50] * maxLv , "type": "=hit8", 'ratio': 1},
+    #     {"skills": ["抛沙"],"data": [0] + [2] * maxLv , "type": "=hit0", 'ratio': 1},
+    #     {"skills": ["抛沙"],"data": [0] + [2] * maxLv , "type": "=hit5", 'ratio': 1}
+    # ]
     associate = [
-        {"skills": ["街头风暴"],"data": [0] + [50] * maxLv , "type": "=hit0", 'ratio': 1},
+        SkillEffect(attribute=Hit(0), operation=Operation.ASSIGN, value=LevelTable([0] + [50] * maxLv), skills=['街头风暴']),
-        {"skills": ["街头风暴"],"data": [0] + [50] * maxLv , "type": "=hit8", 'ratio': 1},
+        SkillEffect(attribute=Hit(8), operation=Operation.ASSIGN, value=LevelTable([0] + [50] * maxLv), skills=['街头风暴']),
-        {"skills": ["抛沙"],"data": [0] + [2] * maxLv , "type": "=hit0", 'ratio': 1},
+        SkillEffect(attribute=Hit(0), operation=Operation.ASSIGN, value=LevelTable([0] + [2] * maxLv), skills=['抛沙']),
-        {"skills": ["抛沙"],"data": [0] + [2] * maxLv , "type": "=hit5", 'ratio': 1}
+        SkillEffect(attribute=Hit(5), operation=Operation.ASSIGN, value=LevelTable([0] + [2] * maxLv), skills=['抛沙']),
     ]
 
 # 毒影针
@@ -1025,7 +1055,12 @@ class Skill29(PassiveSkill):
     # 出血持续时间 : {value6}秒
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{"data":data0,"type":"$*PAtkP"},{"data":data1,"type":"$*PAtkM"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"type":"$*PAtkP"},{"data":data1,"type":"$*PAtkM"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 砖袭
 # fighter_female/brawler_female/bc11d28c04e01923a093d65752c55516
@@ -1197,7 +1232,11 @@ class Skill33(ActiveSkill):
     # 控制型异常状态抗性减少范围 : {value5}px
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{"data":data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 天罗地网
 # fighter_female/brawler_female/d0cdaca82892e54097f22a1f60817048
@@ -1394,7 +1433,13 @@ class Skill36(PassiveSkill):
     data11 = get_data(f'{prefix}/{uuid}', 11)
 
 
-    associate = [{'data':data2, 'type': '*power3', 'skills': ['伏虎霸王拳']},{'data': [i * 3 for i in data3], 'skills': ['伏虎霸王拳']},{'data':data9, 'type': '*power6', 'skills': ['伏虎霸王拳']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data':data2, 'type': '*power3', 'skills': ['伏虎霸王拳']},{'data': [i * 3 for i in data3], 'skills': ['伏虎霸王拳']},{'data':data9, 'type': '*power6', 'skills': ['伏虎霸王拳']}]
+    associate = [
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable(data2)), skills=['伏虎霸王拳']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * 3 for i in data3])), skills=['伏虎霸王拳']),
+        SkillEffect(attribute=Power(6), value=1 + Percent(LevelTable(data9)), skills=['伏虎霸王拳']),
+    ]
 
     def vp_1(self):
         """
@@ -1607,7 +1652,11 @@ class Skill39(PassiveSkill):
     # 中毒生成持续时间 : {value6}秒
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'data':data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data':data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 死亡毒雾
 # fighter_female/brawler_female/ca75c965f20a150f99f54155a37400df
@@ -1863,7 +1912,11 @@ class Skill43(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data':data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data':data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 连环毒爆弹
 # fighter_female/brawler_female/faf9cd66281078b51be2ee0b0f6c5530
@@ -2076,13 +2129,22 @@ class Skill46(PassiveSkill):
     # 毒爆弹爆炸攻击时中毒攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data':data0,'type':'*power0', 'skills':['连环毒爆弹']},
+    #     {'data':data1,'type':'*power1', 'skills':['连环毒爆弹']},
+    #     {'data':data1,'type':'*power10', 'skills':['连环毒爆弹']},
+    #     {'data':data1,'type':'*power13', 'skills':['连环毒爆弹']},
+    #     {'data':data2,'type':'*power16', 'skills':['连环毒爆弹']},
+    #     {'data':data2,'type':'*power17', 'skills':['连环毒爆弹']}
+    # ]
     associate = [
-        {'data':data0,'type':'*power0', 'skills':['连环毒爆弹']},
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data0)), skills=['连环毒爆弹']),
-        {'data':data1,'type':'*power1', 'skills':['连环毒爆弹']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data1)), skills=['连环毒爆弹']),
-        {'data':data1,'type':'*power10', 'skills':['连环毒爆弹']},
+        SkillEffect(attribute=Power(10), value=1 + Percent(LevelTable(data1)), skills=['连环毒爆弹']),
-        {'data':data1,'type':'*power13', 'skills':['连环毒爆弹']},
+        SkillEffect(attribute=Power(13), value=1 + Percent(LevelTable(data1)), skills=['连环毒爆弹']),
-        {'data':data2,'type':'*power16', 'skills':['连环毒爆弹']},
+        SkillEffect(attribute=Power(16), value=1 + Percent(LevelTable(data2)), skills=['连环毒爆弹']),
-        {'data':data2,'type':'*power17', 'skills':['连环毒爆弹']}
+        SkillEffect(attribute=Power(17), value=1 + Percent(LevelTable(data2)), skills=['连环毒爆弹']),
     ]
 
 # 万毒噬心诀
@@ -2166,7 +2228,11 @@ class Skill47(ActiveSkill):
 
     mode = ['平x一轮']
 
-    associate = [{"data":data10 }]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data10 }]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data10))),
+    ]
 
     def setMode(self, mode):
         if mode == '平x一轮':
@@ -2241,7 +2307,11 @@ class Skill49(PassiveSkill):
     # [擒月炎]攻击可抓取敌人时的控制持续时间 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0 }]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0 }]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 钻心毒爆
 # fighter_female/brawler_female/f4a561e272cc434a4905b3aa0c0de090

backend/core/character/GF/fighter_female/grappler_female.py

@@ -1,6 +1,21 @@
 #a7a059ebe9e6054c0644b40ef316d6e9
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class GrapplerFemaleAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    USE_ADAPT = 'useAdapt'
+    """女柔道：是否启用被动调整后的技能形态。"""
+
 prefix = "fighter_female/grappler_female/cn/skillDetail"
 
 
@@ -620,7 +635,11 @@ class Skill19(PassiveSkill):
     # 周围攻击范围比率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 抛投
 # fighter_female/grappler_female/c27418ae613c647527200a7ca17d97fd
@@ -757,7 +776,11 @@ class Skill24(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0,"skills":["背摔","抛投","霹雳肘击","空绞锤","螺旋彗星落","地狱摇篮","裂石破天","末日风暴","死亡摇篮","末日摇篮","风暴之舞","苍宇彗星落","送葬舞步","女皇时代·辉煌舞台"]}]# noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"skills":["背摔","抛投","霹雳肘击","空绞锤","螺旋彗星落","地狱摇篮","裂石破天","末日风暴","死亡摇篮","末日摇篮","风暴之舞","苍宇彗星落","送葬舞步","女皇时代·辉煌舞台"]}]# noqa: E501
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['背摔', '抛投', '霹雳肘击', '空绞锤', '螺旋彗星落', '地狱摇篮', '裂石破天', '末日风暴', '死亡摇篮', '末日摇篮', '风暴之舞', '苍宇彗星落', '送葬舞步', '女皇时代·辉煌舞台']),
+    ]
 
 # 折颈
 # fighter_female/grappler_female/ecc23c980ea71450c0ad0c3fd232f329
@@ -1323,7 +1346,11 @@ class Skill38(PassiveSkill):
     # 抓取准备动作时回避率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 末日风暴
 # fighter_female/grappler_female/d296043df164385a14cb973c8c7c4d07
@@ -1524,7 +1551,11 @@ class Skill42(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 效果叠加次数上限 : {value2}次
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 末日摇篮
 # fighter_female/grappler_female/fc458e449ee00b01dbf88d09aae65462
@@ -1647,8 +1678,12 @@ class Skill44(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # [苍宇彗星落]攻击力增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"+useAdapt","skills":["裂石破天","死亡摇篮","末日摇篮","苍宇彗星落"],"data":[0,100]}
+    # ]
     associate = [
-        {"type":"+useAdapt","skills":["裂石破天","死亡摇篮","末日摇篮","苍宇彗星落"],"data":[0,100]}
+        SkillEffect(attribute=GrapplerFemaleAttribute.USE_ADAPT, operation=Operation.ADD, value=Percent(LevelTable([0, 100])), skills=['裂石破天', '死亡摇篮', '末日摇篮', '苍宇彗星落']),
     ]
 
 # 风暴之舞
@@ -1841,7 +1876,11 @@ class Skill48(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 露西飞身踢攻击力 : [背摔]攻击力的{value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 女皇时代·辉煌舞台
 # fighter_female/grappler_female/c91a62dc0a18360acf5031ac0ebf09f5

backend/core/character/GF/fighter_female/nenmaster_female.py

@@ -1,6 +1,16 @@
 # a7a059ebe9e6054c0644b40ef316d6e9
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "fighter_female/nenmaster_female/cn/skillDetail"
 
@@ -159,7 +169,11 @@ class Skill5(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['念兽 : 龙虎啸']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['念兽 : 龙虎啸']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['念兽 : 龙虎啸']),
+    ]
 
 # 受身蹲伏
 # fighter_female/nenmaster_female/ce26c6b69d02a440a81b552bec94f03b
@@ -820,7 +834,12 @@ class Skill25(PassiveSkill):
     # 学习念气归元后搜寻敌人范围比率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': data0, 'skills': ['分身'], 'ratio': 1}, {'type': '+cd', 'data': [0] + [3] * maxLv, 'skills': ['分身'], 'ratio': 1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0, 'skills': ['分身'], 'ratio': 1}, {'type': '+cd', 'data': [0] + [3] * maxLv, 'skills': ['分身'], 'ratio': 1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + LevelTable(data0), skills=['分身']),
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [3] * maxLv), skills=['分身']),
+    ]
 
 # 蓄念炮
 # fighter_female/nenmaster_female/c7bf7ccab413009640e65ca6f2f0263a
@@ -852,7 +871,11 @@ class Skill26(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 增加念气波发射速度 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'type': '*power0', 'data': data0, 'skills': ['念气波']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*power0', 'data': data0, 'skills': ['念气波']}]
+    associate = [
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data0)), skills=['念气波']),
+    ]
 
 # 疾风连击
 # fighter_female/nenmaster_female/8572675ec6a1f50b6eff6a867376c2de
@@ -1002,9 +1025,13 @@ class Skill31(ActiveSkill):
     # 学习念气归元后，念气珠爆炸大小比率 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     # 总共两个珠子
+    #     {'type': '*skillDamage', 'data': data3, 'ratio': 100 / 2}
+    # ]
     associate = [
-        # 总共两个珠子
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + (LevelTable(data3) / (100 / 2))),
-        {'type': '*skillDamage', 'data': data3, 'ratio': 100 / 2}
     ]
 
     def getSkillCD(self, mode=None):
@@ -1279,7 +1306,11 @@ class Skill36(ActiveSkill):
     # 队员魔法防御力增加 : {value16}
     data16 = get_data(f'{prefix}/{uuid}', 16)
 
-    associate = [{'type': '*skillDamage', 'data': data12}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data12}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data12))),
+    ]
 
 # 狂龙升天破
 # fighter_female/nenmaster_female/dbf8b30c7057032af0d68fcfa289fdae
@@ -1368,7 +1399,11 @@ class Skill38(PassiveSkill):
     # 重新盛开所需时间 : {value5}秒
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'type': '*skillDamage', 'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 千莲怒放
 # fighter_female/nenmaster_female/51a08fd0c90f0a5276cd552047fac93d
@@ -1580,10 +1615,14 @@ class Skill42(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-33] * self.maxLv, 'skills': ['狮子吼']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-33] * self.maxLv, 'skills': ['狮子吼']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-33] * maxLv)), skills=['狮子吼'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 念花守心
 # fighter_female/nenmaster_female/547ab2b2bd860d3e37355a9cfbc1077c
@@ -1624,7 +1663,11 @@ class Skill43(PassiveSkill):
     data4 = get_data(f'{prefix}/{uuid}', 4)
     # 分身生成距离减少率 : 50%
 
-    associate = [{'type': '*skillDamage', 'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
     # 分身生成距离减少率 : 50%
 
 # 击电奔星
@@ -1811,7 +1854,11 @@ class Skill47(PassiveSkill):
     # [念气环绕]爆炸攻击力 : 每个念气珠攻击力的400%
     # 念气珠发射后再次生成间隔 : {value3}秒
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 天雷分身步
 # fighter_female/nenmaster_female/85f7c810ad503790e8626439fe936d56

backend/core/character/GF/fighter_female/striker_female.py

@@ -1,6 +1,14 @@
 #a7a059ebe9e6054c0644b40ef316d6e9
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "fighter_female/striker_female/cn/skillDetail"
 
 
@@ -614,7 +622,11 @@ class Skill19(PassiveSkill):
 
     # 冷却时间减少率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0,"type":"*cdReduce","exceptSkills":["武神强踢","极尽 : 霸皇断空拳","陨星灭天击"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"type":"*cdReduce","exceptSkills":["武神强踢","极尽 : 霸皇断空拳","陨星灭天击"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['武神强踢', '极尽 : 霸皇断空拳', '陨星灭天击']),
+    ]
 
 # 强拳
 # fighter_female/striker_female/dcd536f1674630f01fc9667bb202b851
@@ -859,7 +871,11 @@ class Skill27(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 基本攻击力和转职技能攻击力增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{"data":data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 旋风腿
 # fighter_female/striker_female/202edb928046f4fa6dedf6337377efd5
@@ -927,7 +943,11 @@ class Skill29(PassiveSkill):
     data4 = get_data(f'{prefix}/{uuid}', 4)
     # [决斗场]
     # 起始冷却时间 : 10秒
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # [决斗场]
     # 起始冷却时间 : 10秒
 
@@ -1208,7 +1228,11 @@ class Skill34(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 移动速度增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 武神强踢
 # fighter_female/striker_female/47bd4871f29defc2a0021ee9261d7a5b
@@ -1313,10 +1337,14 @@ class Skill36(ActiveSkill):
         self.skillRation *= 0.5
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"type":"*skillRation","data":[0] + [-25]*self.maxLv,"skills":["崩拳"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"type":"*skillRation","data":[0] + [-25]*self.maxLv,"skills":["崩拳"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-25] * maxLv)), skills=['崩拳'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 回天连环击
 # fighter_female/striker_female/e0daa922b19cdc35de879e938361464e
@@ -1429,7 +1457,11 @@ class Skill38(PassiveSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
     # [霸体护甲]移动速度增加 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 虎啸神拳
 # fighter_female/striker_female/128b9ddef2262f40723deae4407bdb42
@@ -1621,7 +1653,11 @@ class Skill42(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 雷霆之舞
 # fighter_female/striker_female/dac8d8207618150c162e4c6f9e168527

backend/core/character/GF/fighter_male/brawler_male.py

@@ -1,6 +1,19 @@
 # ca0f0e0e9e1d55b5f9955b03d9dd213c
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    Hit,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "fighter_male/brawler_male/cn/skillDetail"
 
@@ -161,7 +174,11 @@ class Skill5(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['罗网投掷']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['罗网投掷']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['罗网投掷']),
+    ]
 
 # 受身蹲伏
 # fighter_male/brawler_male/ce26c6b69d02a440a81b552bec94f03b
@@ -996,9 +1013,14 @@ class Skill30(PassiveSkill):
     # 命中率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0},
+    #     {'type': '$*MAtkP', 'data': data1},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
-        {'type': '$*MAtkP', 'data': data1},
+        # 原角色字段 MAtkP 未被旧引擎支持，原先不生效；本次迁移保留此行为。
     ]
 
 # 毒针投掷
@@ -1298,7 +1320,11 @@ class Skill36(ActiveSkill):
     # 前方挑衅射程 : {value5}px
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'type': '*skillDamage', 'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 罗网投掷
 # fighter_male/brawler_male/d0cdaca82892e54097f22a1f60817048
@@ -1381,10 +1407,14 @@ class Skill37(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '+power2', 'data': [0] + [31.3] * self.maxLv, 'skills': ['毒针投掷']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '+power2', 'data': [0] + [31.3] * self.maxLv, 'skills': ['毒针投掷']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=Power(2), operation=Operation.ADD, value=Percent(LevelTable([0] + [31.3] * maxLv)), skills=['毒针投掷'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 螺旋滑铲
 # fighter_male/brawler_male/e0a072e8cef2d77893aad5f68aeed56a
@@ -1467,6 +1497,9 @@ class Skill39(PassiveSkill):
         攻击异常状态的敌人时，伤害会更加强大，冲击波范围也会增加 (最多叠加3次)。\n
     """
 
+    # 条件声明在未学习时也参与依赖检查，显式提供 VP 输入默认值。
+    vp = 0
+
     name = '狂 · 霸王拳'
     cellPos = (5,9)
     learnLv = 40
@@ -1510,12 +1543,20 @@ class Skill39(PassiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        self.associate = [{'data': [i - 100 if i > 0 else i for i in self.data0], 'skills': ['伏虎霸王拳']}, {'type': '+hit0', 'data': [0] + [-200] * self.maxLv, 'skills': ['伏虎霸王拳']}, {'data': [i * 3 for i in self.data3], 'skills': ['伏虎霸王拳']}]
+    # def effect(self, old, new):
-        if self.vp == 2:
+    #     self.associate = [{'data': [i - 100 if i > 0 else i for i in self.data0], 'skills': ['伏虎霸王拳']}, {'type': '+hit0', 'data': [0] + [-200] * self.maxLv, 'skills': ['伏虎霸王拳']}, {'data': [i * 3 for i in self.data3], 'skills': ['伏虎霸王拳']}]
-            self.associate.append({'data': [0] + [-200] * self.maxLv, 'skills': ['伏虎霸王拳'], 'type': '*cdRatio'})
+    #     if self.vp == 2:
-            self.associate.append({'type': '*skillRation', 'data': [0] + [200] * self.maxLv, 'skills': ['伏虎霸王拳']})
+    #         self.associate.append({'data': [0] + [-200] * self.maxLv, 'skills': ['伏虎霸王拳'], 'type': '*cdRatio'})
-        return super().effect(old, new)
+    #         self.associate.append({'type': '*skillRation', 'data': [0] + [200] * self.maxLv, 'skills': ['伏虎霸王拳']})
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else i for i in data0])), skills=['伏虎霸王拳']),
+        SkillEffect(attribute=Hit(0), operation=Operation.ADD, value=Percent(LevelTable([0] + [-200] * maxLv)), skills=['伏虎霸王拳']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * 3 for i in data3])), skills=['伏虎霸王拳']),
+        SkillEffect(attribute=SkillAttribute.CD_RATIO, value=1 - Percent(LevelTable([0] + [-200] * maxLv)), skills=['伏虎霸王拳'], when=Equals(Read(SkillAttribute.VP), 2)),
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [200] * maxLv)), skills=['伏虎霸王拳'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 毒雷引爆
 # fighter_male/brawler_male/6a1d1f08a6572be420bb3a256c44c015
@@ -1680,9 +1721,14 @@ class Skill42(PassiveSkill):
     # 物理、 魔法暴击率增加量 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data5, 'type': '*skillDamage'},
+    #     {'data': data4, 'type': '*cdReduce', 'skills': ['抛沙', '毒瓶投掷', '毒针投掷', '砖块投掷', '罗网投掷']},
+    # ]
     associate = [
-        {'data': data5, 'type': '*skillDamage'},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data5))),
-        {'data': data4, 'type': '*cdReduce', 'skills': ['抛沙', '毒瓶投掷', '毒针投掷', '砖块投掷', '罗网投掷']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data4)), skills=['抛沙', '毒瓶投掷', '毒针投掷', '砖块投掷', '罗网投掷']),
     ]
 
 # 天崩地裂
@@ -1797,10 +1843,14 @@ class Skill44(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-50] * self.maxLv}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-50] * self.maxLv}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-50] * maxLv)), when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 千锁乱舞
 # fighter_male/brawler_male/dac8d8207618150c162e4c6f9e168527
@@ -1892,7 +1942,11 @@ class Skill46(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data1, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 暗街夺命锁
 # fighter_male/brawler_male/2b39a776471c142f581ad3cc8bb89e55
@@ -1975,10 +2029,14 @@ class Skill47(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-30] * self.maxLv, 'skills': ['砖块投掷']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-30] * self.maxLv, 'skills': ['砖块投掷']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-30] * maxLv)), skills=['砖块投掷'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 飞沙走石
 # fighter_male/brawler_male/b306cc4c67c775ab7ddff9785a3fe6a4
@@ -2054,10 +2112,14 @@ class Skill48(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-40] * self.maxLv, 'skills': ['毒针投掷']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-40] * self.maxLv, 'skills': ['毒针投掷']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-40] * maxLv)), skills=['毒针投掷'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 燃火轰天炮
 # fighter_male/brawler_male/949849d5791944973d60af7e2a7eefb0
@@ -2099,7 +2161,11 @@ class Skill49(ActiveSkill):
     data4 = get_data(f'{prefix}/{uuid}', 4)
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'type': '*skillDamage', 'data': [i * 3 if i > 0 else i for i in data3], 'skills': ['燃火轰天炮']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i * 3 if i > 0 else i for i in data3], 'skills': ['燃火轰天炮']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * 3 if i > 0 else i for i in data3])), skills=['燃火轰天炮']),
+    ]
 
 # 逆道·爆狱
 # fighter_male/brawler_male/dec8961c485edb02036ba00c789010f0
@@ -2200,7 +2266,11 @@ class Skill51(PassiveSkill):
     # 强化毒瓶投掷毒雾持续时间 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 逆道·幽链之界
 # fighter_male/brawler_male/f1fdc6c2482ecc510a2a9f04201ba125

backend/core/character/GF/fighter_male/grappler_male.py

@@ -1,6 +1,14 @@
 #ca0f0e0e9e1d55b5f9955b03d9dd213c
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "fighter_male/grappler_male/cn/skillDetail"
 
 
@@ -76,8 +84,12 @@ class Skill2(PassiveSkill):
     # 魔法值消耗量减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*cdReduce", 'exceptSkills': ['死亡旋律', '一字传承 : 极义震天破', '黑震流·山岳崩颓']}
+    # ]
     associate = [
-        {"data":data0,"type":"*cdReduce", 'exceptSkills': ['死亡旋律', '一字传承 : 极义震天破', '黑震流·山岳崩颓']}
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['死亡旋律', '一字传承 : 极义震天破', '黑震流·山岳崩颓']),
     ]
 
 # 后跳
@@ -635,7 +647,11 @@ class Skill21(PassiveSkill):
     # 附近攻击范围比率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 抛投
 # fighter_male/grappler_male/c27418ae613c647527200a7ca17d97fd
@@ -775,9 +791,13 @@ class Skill26(PassiveSkill):
     # 暴击伤害额外增加效果持续 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        self.associate = [{"data":[(self.data0[i] + self.data1[i]) for i in range(0,self.maxLv + 1)]}]
+    # def effect(self, old, new):
-        return super().effect(old, new)
+    #     self.associate = [{"data":[(self.data0[i] + self.data1[i]) for i in range(0,self.maxLv + 1)]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0) + LevelTable(data1))),
+    ]
 
 # 折颈
 # fighter_male/grappler_male/ecc23c980ea71450c0ad0c3fd232f329
@@ -1314,7 +1334,11 @@ class Skill39(PassiveSkill):
     # 基本攻击和抓取攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"type":"$*PAtkP","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"$*PAtkP","data":data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 死亡旋律
 # fighter_male/grappler_male/d296043df164385a14cb973c8c7c4d07
@@ -1525,9 +1549,13 @@ class Skill43(PassiveSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        self.associate = [{"data":[(self.data0[i] + self.data2[i]) for i in range(0,self.maxLv + 1)]}]
+    # def effect(self, old, new):
-        return super().effect(old, new)
+    #     self.associate = [{"data":[(self.data0[i] + self.data2[i]) for i in range(0,self.maxLv + 1)]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0) + LevelTable(data2))),
+    ]
 
 # 黑震旋风
 # fighter_male/grappler_male/e6cb8eaa955de77107f746a4e6c731ab
@@ -1743,7 +1771,11 @@ class Skill47(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"type":"$*PAtkP","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"$*PAtkP","data":data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 黑震流·殒灭
 # fighter_male/grappler_male/68062215e75d92575958873ac8ede31a

backend/core/character/GF/fighter_male/nenmaster_male.py

@@ -1,6 +1,16 @@
 # ca0f0e0e9e1d55b5f9955b03d9dd213c
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "fighter_male/nenmaster_male/cn/skillDetail"
 
@@ -159,7 +169,11 @@ class Skill5(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['念兽 : 龙虎啸']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['念兽 : 龙虎啸']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['念兽 : 龙虎啸']),
+    ]
 
 # 受身蹲伏
 # fighter_male/nenmaster_male/ce26c6b69d02a440a81b552bec94f03b
@@ -752,9 +766,14 @@ class Skill23(ActiveSkill):
     # 施放速度增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkM', 'data': [0] + [48.7] * maxLv},
+    #     {'data': [0] + [21] * maxLv},
+    # ]
     associate = [
-        {'type': '$*PAtkM', 'data': [0] + [48.7] * maxLv},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable([0] + [48.7] * maxLv))),
-        {'data': [0] + [21] * maxLv},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [21] * maxLv))),
     ]
 
 # 念气环绕
@@ -796,7 +815,11 @@ class Skill24(ActiveSkill):
     data5 = data2
     hit5 = 0
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
     mode = ['常规', '御']
 
@@ -837,7 +860,11 @@ class Skill25(PassiveSkill):
     # 发射速度增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*power0', 'data': data0, 'skills': ['念气波']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*power0', 'data': data0, 'skills': ['念气波']}]
+    associate = [
+        SkillEffect(attribute=Power(0), value=1 + Percent(LevelTable(data0)), skills=['念气波']),
+    ]
 
 # 疾风连击
 # fighter_male/nenmaster_male/8572675ec6a1f50b6eff6a867376c2de
@@ -1061,7 +1088,12 @@ class Skill32(PassiveSkill):
     # 分身爆炸大小比率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'type': '*skillDamage', 'data': data0, 'skills': ['分身'], 'ratio': 1}, {'type': '+cd', 'data': [0] + [5] * maxLv, 'skills': ['分身'], 'ratio': 1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0, 'skills': ['分身'], 'ratio': 1}, {'type': '+cd', 'data': [0] + [5] * maxLv, 'skills': ['分身'], 'ratio': 1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + LevelTable(data0), skills=['分身']),
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [5] * maxLv), skills=['分身']),
+    ]
 
 # 念兽 : 龙虎啸
 # fighter_male/nenmaster_male/1b1cfab062e0768bcc889e33e1f30dbf
@@ -1133,7 +1165,11 @@ class Skill33(ActiveSkill):
     # 范围比率 : {value15}%
     data15 = get_data(f'{prefix}/{uuid}', 15)
 
-    associate = [{'type': '*skillDamage', 'data': data12}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data12}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data12))),
+    ]
 
     mode = ['一轮平x', '前冲', '跳跃']
 
@@ -1178,7 +1214,11 @@ class Skill34(ActiveSkill):
     # 范围比率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*power5', 'data': [i - 100 if i > 0 else i for i in data0], 'skills': ['念气环绕']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*power5', 'data': [i - 100 if i > 0 else i for i in data0], 'skills': ['念气环绕']}]
+    associate = [
+        SkillEffect(attribute=Power(5), value=1 + Percent(LevelTable([i - 100 if i > 0 else i for i in data0])), skills=['念气环绕']),
+    ]
 
 # 狮子吼
 # fighter_male/nenmaster_male/9cb6f9ed646fa87f9b7680a42ce83d1a
@@ -1467,7 +1507,11 @@ class Skill39(PassiveSkill):
     # 魔法暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 念兽 : 审判之金雷虎
 # fighter_male/nenmaster_male/51a08fd0c90f0a5276cd552047fac93d
@@ -1741,7 +1785,12 @@ class Skill44(ActiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # [念气环绕 ： 袭]、 [念气环绕 ： 御]的念气球范围增加 : 50%
 
-    associate = [{'data': data0}, {'data': data1, 'skills': ['狮子吼', '天雷虎踢', '螺旋念气场', '念兽 : 猛虎震地', '念兽 : 审判之金雷虎', '念之战矛', '冲云念气场', '奔雷螺旋击', '禅语·形灭']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}, {'data': data1, 'skills': ['狮子吼', '天雷虎踢', '螺旋念气场', '念兽 : 猛虎震地', '念兽 : 审判之金雷虎', '念之战矛', '冲云念气场', '奔雷螺旋击', '禅语·形灭']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['狮子吼', '天雷虎踢', '螺旋念气场', '念兽 : 猛虎震地', '念兽 : 审判之金雷虎', '念之战矛', '冲云念气场', '奔雷螺旋击', '禅语·形灭']),
+    ]
     # [念气环绕 ： 袭]、 [念气环绕 ： 御]的念气球范围增加 : 50%
 
 # 风雷引
@@ -1946,7 +1995,11 @@ class Skill48(PassiveSkill):
     # 风雷能量自然恢复周期 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 禅语·形灭
 # fighter_male/nenmaster_male/33ad4930f4724a7d025c3046c6f6074b

backend/core/character/GF/fighter_male/striker_male.py

@@ -1,6 +1,14 @@
 #ca0f0e0e9e1d55b5f9955b03d9dd213c
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "fighter_male/striker_male/cn/skillDetail"
 
 
@@ -626,8 +634,12 @@ class Skill20(PassiveSkill):
 
     # 冷却时间减少率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*cdReduce", 'exceptSkills': ['双重释放', '烈焰焚步', '极武霸皇踢', '焚火逐日拳']}
+    # ]
     associate = [
-        {"data":data0,"type":"*cdReduce", 'exceptSkills': ['双重释放', '烈焰焚步', '极武霸皇踢', '焚火逐日拳']}
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['双重释放', '烈焰焚步', '极武霸皇踢', '焚火逐日拳']),
     ]
 
 # 强拳
@@ -867,8 +879,12 @@ class Skill28(PassiveSkill):
     # [鹰踏]攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"*skillDamage","data":data0,"skills":["鹰踏"]},
+    # ]
     associate = [
-        {"type":"*skillDamage","data":data0,"skills":["鹰踏"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['鹰踏']),
     ]
 
 # 弱点感知
@@ -960,7 +976,11 @@ class Skill31(PassiveSkill):
     # - [决斗场] -
     # 起始冷却时间 : 10秒
 
-    associate = [{"type":"*skillDamage","data":data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*skillDamage","data":data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
     # - [决斗场] -
     # 起始冷却时间 : 10秒
 
@@ -1280,7 +1300,11 @@ class Skill38(PassiveSkill):
     # 魔法值消耗量减少率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{"type":"$*PAtkP","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"$*PAtkP","data":data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 烈焰焚步
 # fighter_male/striker_male/01384bbfc346775d1267fa0bc4ca605f
@@ -1327,9 +1351,14 @@ class Skill39(ActiveSkill):
     # [柔化肌肉]蓄气时间减少 : {value9}秒
     data9 = get_data(f'{prefix}/{uuid}', 9)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data1,"type":"*cdReduce", 'exceptSkills': ['双重释放', '烈焰焚步', '极武霸皇踢', '焚火逐日拳']},
+    #     {"type":"*skillDamage","data":data5},
+    # ]
     associate = [
-        {"data":data1,"type":"*cdReduce", 'exceptSkills': ['双重释放', '烈焰焚步', '极武霸皇踢', '焚火逐日拳']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=['双重释放', '烈焰焚步', '极武霸皇踢', '焚火逐日拳']),
-        {"type":"*skillDamage","data":data5},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data5))),
     ]
 
 # 双重释放
@@ -1565,7 +1594,11 @@ class Skill44(PassiveSkill):
     # [柔化肌肉]强制中断次数增加 : {value2}
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [ {"type":"*skillDamage","data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*skillDamage","data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 烈火强拳
 # fighter_male/striker_male/e1daab884dd07fc9e70d08b83d1790eb
@@ -1681,7 +1714,11 @@ class Skill47(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [ {"type":"*skillDamage","data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*skillDamage","data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 炼狱坠星腿
 # fighter_male/striker_male/5536486eaf9b13c9a8283447cb5e77ab

backend/core/character/GF/gunblader/agent.py

@@ -1,6 +1,15 @@
 # 986c2b3d72ee0e4a0b7fcfbe786d4e02
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "gunblader/agent/cn/skillDetail"
 
@@ -120,7 +129,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['斩射']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['斩射']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['斩射']),
+    ]
 
 # 受身蹲伏
 # gunblader/agent/ce26c6b69d02a440a81b552bec94f03b
@@ -511,7 +524,11 @@ class Skill16(PassiveSkill):
     # 暴击伤害增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 源能护盾
 # gunblader/agent/0232c151ef3731c2dede51931a374723
@@ -689,7 +706,11 @@ class Skill21(PassiveSkill):
     # 命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 暴击
 # gunblader/agent/fc1262c19f3d0477ee8eda47b8db8696
@@ -1108,7 +1129,11 @@ class Skill31(PassiveSkill):
     # 寻敌范围增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 毁灭绝击
 # gunblader/agent/01c3a2fb793d293a25ed8dc7a0d70c1a
@@ -1287,9 +1312,14 @@ class Skill35(PassiveSkill):
     # 迅步突袭冷却时间缩短 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data1},
+    #     {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['迅步突袭'], 'ratio': 1},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data1},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
-        {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['迅步突袭'], 'ratio': 1},
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [-1] * maxLv), skills=['迅步突袭']),
     ]
 
 # 月光镇魂曲
@@ -1481,7 +1511,11 @@ class Skill39(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 夜影迷踪
 # gunblader/agent/c5a2956d8ed3af1746ed2f76ca971a09

backend/core/character/GF/gunblader/hitman.py

@@ -1,6 +1,19 @@
 # 986c2b3d72ee0e4a0b7fcfbe786d4e02
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    Hit,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "gunblader/hitman/cn/skillDetail"
 
@@ -524,9 +537,14 @@ class Skill16(PassiveSkill):
     # 命中率增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0},
+    #     {'type': '*cdReduce', 'data': data2, 'exceptSkills': ['电光飞掠', '集结·暮光之翼', '暮光密令 : 黎明决战']},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
-        {'type': '*cdReduce', 'data': data2, 'exceptSkills': ['电光飞掠', '集结·暮光之翼', '暮光密令 : 黎明决战']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data2)), except_skills=['电光飞掠', '集结·暮光之翼', '暮光密令 : 黎明决战']),
     ]
 
 # 捷影步
@@ -778,7 +796,11 @@ class Skill23(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 潜行射击
 # gunblader/hitman/6e33d47e6622ce03b6defdd912140270
@@ -1157,7 +1179,11 @@ class Skill31(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 电光飞掠
 # gunblader/hitman/669f1428193f61f9d92c743b72438c4d
@@ -1335,10 +1361,14 @@ class Skill34(ActiveSkill):
         self.cd = 25
         self.skillRation *= 0.5
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-50] * self.maxLv, 'skills': ['潜行射击']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-50] * self.maxLv, 'skills': ['潜行射击']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-50] * maxLv)), skills=['潜行射击'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # B.C精锐特训
 # gunblader/hitman/38612d8f2561edc2eb68d5057a837bfa
@@ -1366,7 +1396,11 @@ class Skill35(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 致命焰火
 # gunblader/hitman/6a1d1f08a6572be420bb3a256c44c015
@@ -1453,10 +1487,14 @@ class Skill36(ActiveSkill):
         self.cd = 20
         self.skillRation *= 0.5
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-50] * self.maxLv, 'skills': ['潜行射击']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-50] * self.maxLv, 'skills': ['潜行射击']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-50] * maxLv)), skills=['潜行射击'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 碧波瞬斩
 # gunblader/hitman/a2d943797daca862a6f321aca6ac9bfa
@@ -1592,7 +1630,13 @@ class Skill39(PassiveSkill):
     # [轮盘连射]罗朗斩击攻击力 : [轮盘连射]攻击力总和的{value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}, {'data': data1, 'type': '=hit2', 'skills': ['轮盘连射'], 'ratio': 1}, {'data': [i - 100 if i > 0 else 0 for i in data2], 'type': '*power2', 'skills': ['轮盘连射']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}, {'data': data1, 'type': '=hit2', 'skills': ['轮盘连射'], 'ratio': 1}, {'data': [i - 100 if i > 0 else 0 for i in data2], 'type': '*power2', 'skills': ['轮盘连射']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=Hit(2), operation=Operation.ASSIGN, value=LevelTable(data1), skills=['轮盘连射']),
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data2])), skills=['轮盘连射']),
+    ]
 
 # 燃情协战
 # gunblader/hitman/e5c09f9132a48dc1d695968592cc5878

backend/core/character/GF/gunblader/specialist.py

@@ -1,6 +1,14 @@
 # 986c2b3d72ee0e4a0b7fcfbe786d4e02
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "gunblader/specialist/cn/skillDetail"
 
@@ -629,8 +637,12 @@ class Skill18(PassiveSkill):
     # 攻击速度增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkM', 'data': data0},
+    # ]
     associate = [
-        {'type': '$*PAtkM', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 镭射源能枪
@@ -756,7 +768,11 @@ class Skill22(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 源能波刃
 # gunblader/specialist/8572675ec6a1f50b6eff6a867376c2de
@@ -1190,7 +1206,11 @@ class Skill31(PassiveSkill):
     # [源能提炼]累积数上限增加 : {value1}个
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 超能场域
 # gunblader/specialist/fc458e449ee00b01dbf88d09aae65462
@@ -1406,7 +1426,11 @@ class Skill35(PassiveSkill):
     # [源能应用]物理/魔法防御力额外增加 : {value3}
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 绝望圆舞
 # gunblader/specialist/2c9d9a36c8401bddff6cdb80fab8dc24
@@ -1606,7 +1630,11 @@ class Skill39(PassiveSkill):
     # [源能提炼]能量获得额外增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 临界源能弹
 # gunblader/specialist/d429147c372b549c3dadcabcba50787f

backend/core/character/GF/gunblader/trouble_shooter.py

@@ -1,6 +1,16 @@
 # 986c2b3d72ee0e4a0b7fcfbe786d4e02
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "gunblader/trouble_shooter/cn/skillDetail"
 
@@ -273,8 +283,12 @@ class Skill8(ActiveSkill):
     # 爆炸范围比率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data1, 'type': '+power0', 'skills': ['G型手榴弹']},
+    # ]
     associate = [
-        {'data': data1, 'type': '+power0', 'skills': ['G型手榴弹']},
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['G型手榴弹']),
     ]
 
 # 瞬击
@@ -602,7 +616,11 @@ class Skill18(PassiveSkill):
     # 僵直度增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 爆烈斩击
 # gunblader/trouble_shooter/547ab2b2bd860d3e37355a9cfbc1077c
@@ -793,7 +811,11 @@ class Skill24(PassiveSkill):
     # 目标技能攻击范围增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # G型火焰爆弹
 # gunblader/trouble_shooter/9bff7f2559e003766fee2853dca00631
@@ -1107,7 +1129,11 @@ class Skill30(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # G型烬灭榴弹
 # gunblader/trouble_shooter/1dad88963abdc96b091fcab185a8820d
@@ -1318,7 +1344,11 @@ class Skill34(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 爆弹华尔兹
 # gunblader/trouble_shooter/762c4e6d030eaf0abbfe1fec2b298574
@@ -1512,9 +1542,14 @@ class Skill38(PassiveSkill):
     # [广域散射]射击范围增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'type': '*skillDamage'},
+    #      {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['矫捷翻滚'], 'ratio': 1},
+    # ]
     associate = [
-        {'data': data0, 'type': '*skillDamage'},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-         {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['矫捷翻滚'], 'ratio': 1},
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [-1] * maxLv), skills=['矫捷翻滚']),
     ]
 
 # 铁腕爆弹

backend/core/character/GF/gunner_female/launcher_female.py

@@ -1,6 +1,17 @@
 #944b9aab492c15a8474f96947ceeb9e4
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_female/launcher_female/cn/skillDetail"
 
 
@@ -622,10 +633,16 @@ class Skill20(PassiveSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
     # 技能冷却时间减少率 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"$*PAtkP","data":data2},
+    #     {"data":data3},
+    #     {"type":"*cdReduce","data":data4,"exceptSkills":['远古粒子炮', '火力全开', '制胜·最终兵器']},
+    # ]
     associate = [
-        {"type":"$*PAtkP","data":data2},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data2))),
-        {"data":data3},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
-        {"type":"*cdReduce","data":data4,"exceptSkills":['远古粒子炮', '火力全开', '制胜·最终兵器']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data4)), except_skills=['远古粒子炮', '火力全开', '制胜·最终兵器']),
     ]
 
 # 空中射击
@@ -679,12 +696,23 @@ class Skill22(PassiveSkill):
     hasUP = False
     custom = get_data(f'{prefix}/{uuid}', "custom") # noqa: E501
 
+    # 迁移前实现（保留对照）：
+    # def effect(self, old, new):
+    #     skills = []
+    #     for i in self.char.skills:
+    #         if i.type == "active" and i.learnLv not in [50,85,100] and i.damage and self.char.skill_effects.is_learned(i):
+    #             skills.append(i.name)
+    #     self.associate = [{"type":"+lv","data":[0] + [1]*self.maxLv,"ratio":1,"skills":skills}]
+    #     super().effect(old, new)
+    # 仅动态枚举目标名称，贡献值与 VP 条件交由类型化声明处理。
     def effect(self, old, new):
         skills = []
         for i in self.char.skills:
             if i.type == "active" and i.learnLv not in [50,85,100] and i.damage and self.char.skill_effects.is_learned(i):
                 skills.append(i.name)
-        self.associate = [{"type":"+lv","data":[0] + [1]*self.maxLv,"ratio":1,"skills":skills}]
+        self.associate = [
+            SkillEffect(attribute=SkillAttribute.LEVEL, operation=Operation.ADD, value=LevelTable([0] + [1] * self.maxLv), skills=skills),
+        ]
         super().effect(old, new)
 
 
@@ -904,7 +932,11 @@ class Skill29(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data1,"skills":["激光炮"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1,"skills":["激光炮"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['激光炮']),
+    ]
 
 # 脉冲雷达-63
 # gunner_female/launcher_female/9376d04c476cd41d60ed1974ca69ab95
@@ -929,7 +961,11 @@ class Skill30(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 物理攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data1,"type":"$*PAtkP"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1,"type":"$*PAtkP"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 聚焦喷火器
 # gunner_female/launcher_female/04883563896fe1adac7505c6146b5f59
@@ -1297,10 +1333,14 @@ class Skill37(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{"type":"*skillRation","data":[0] + [-12.5]*self.maxLv,"skills":["激光炮"]}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{"type":"*skillRation","data":[0] + [-12.5]*self.maxLv,"skills":["激光炮"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-12.5] * maxLv)), skills=['激光炮'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
 # 超温重火器
 # gunner_female/launcher_female/5892d1fa4462e561ac8f8d2c74892b0a
@@ -1323,7 +1363,11 @@ class Skill38(PassiveSkill):
 
     # 基本攻击和重火器攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 远古粒子炮
 # gunner_female/launcher_female/2ba299855fc22192cba4f73db75e9d0e
@@ -1524,7 +1568,11 @@ class Skill42(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 发射后僵直时间减少率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 集束炸弹
 # gunner_female/launcher_female/68062215e75d92575958873ac8ede31a
@@ -1718,7 +1766,11 @@ class Skill46(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [M-3喷火器]、 [聚焦喷火器]、 [等离子放射器]、 [UHT-03爆炎喷火器]移动速度比率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # UHT-03爆炎喷火器
 # gunner_female/launcher_female/3a691a432c58abebc08211df45c4f4bd

backend/core/character/GF/gunner_female/mechanic_female.py

@@ -1,6 +1,23 @@
 # 944b9aab492c15a8474f96947ceeb9e4
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class MechanicFemaleAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    BLOW_POWER = 'blow_power'
+    """女机械：空战机械爆炸分段倍率。"""
+    G_RATIO = 'ratio_g'
+    """女机械：G 系列技能的相互强化倍率。"""
+
 
 prefix = "gunner_female/mechanic_female/cn/skillDetail"
 
@@ -720,9 +737,14 @@ class Skill23(ActiveSkill):
     # 爆炸攻击力变化率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': [i - 100 if i > 100 else i for i in data1], 'skills': ['RX-78追击者', 'EZ-8爆破者']},
+    #     {'type':'*blow_power' ,'data': [i - 100 if i > 100 else i for i in data1], 'skills': ['空战机械 : 狂风']}
+    # ]
     associate = [
-        {'data': [i - 100 if i > 100 else i for i in data1], 'skills': ['RX-78追击者', 'EZ-8爆破者']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 100 else i for i in data1])), skills=['RX-78追击者', 'EZ-8爆破者']),
-        {'type':'*blow_power' ,'data': [i - 100 if i > 100 else i for i in data1], 'skills': ['空战机械 : 狂风']}
+        SkillEffect(attribute=MechanicFemaleAttribute.BLOW_POWER, value=1 + Percent(LevelTable([i - 100 if i > 100 else i for i in data1])), skills=['空战机械 : 狂风']),
     ]
 
 # G-14手雷
@@ -784,7 +806,11 @@ class Skill25(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 危机追击者
 # gunner_female/mechanic_female/dc1ffbe7bfcc6dc2be737951960da9ad
@@ -815,7 +841,11 @@ class Skill26(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
     # 按期望计算
-    associate = [{'data': data0, 'type': '*skillDamage', 'skills': ['RX-78追击者']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage', 'skills': ['RX-78追击者']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['RX-78追击者']),
+    ]
 
 # G-1科罗纳
 # gunner_female/mechanic_female/1b1cfab062e0768bcc889e33e1f30dbf
@@ -865,9 +895,14 @@ class Skill27(ActiveSkill):
 
     ratio_g = 1.0
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data6, 'type': '+ratio_g', 'skills': ['改装 : G-2旋雷者']},
+    #     {'data': data7, 'type': '+ratio_g', 'skills': ['改装 : G-3捕食者']}
+    # ]
     associate = [
-        {'data': data6, 'type': '+ratio_g', 'skills': ['改装 : G-2旋雷者']},
+        SkillEffect(attribute=MechanicFemaleAttribute.G_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data6)), skills=['改装 : G-2旋雷者']),
-        {'data': data7, 'type': '+ratio_g', 'skills': ['改装 : G-3捕食者']}
+        SkillEffect(attribute=MechanicFemaleAttribute.G_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data7)), skills=['改装 : G-3捕食者']),
     ]
 
     def getSkillCD(self, mode=None):
@@ -1009,9 +1044,14 @@ class Skill31(ActiveSkill):
     # 电波前方攻击范围比率 : {value7}%
     data7 = get_data(f'{prefix}/{uuid}', 7)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data5, 'type': '+ratio_g', 'skills': ['G-1科罗纳']},
+    #     {'data': data6, 'type': '+ratio_g', 'skills': ['改装 : G-3捕食者']}
+    # ]
     associate = [
-        {'data': data5, 'type': '+ratio_g', 'skills': ['G-1科罗纳']},
+        SkillEffect(attribute=MechanicFemaleAttribute.G_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data5)), skills=['G-1科罗纳']),
-        {'data': data6, 'type': '+ratio_g', 'skills': ['改装 : G-3捕食者']}
+        SkillEffect(attribute=MechanicFemaleAttribute.G_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data6)), skills=['改装 : G-3捕食者']),
     ]
 
     def getSkillCD(self, mode=None):
@@ -1060,7 +1100,11 @@ class Skill32(PassiveSkill):
     # 魔法暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage', 'exceptSkills': ['G-1科罗纳', '改装 : G-2旋雷者', '改装 : G-3捕食者', 'G-磁力弹']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage', 'exceptSkills': ['G-1科罗纳', '改装 : G-2旋雷者', '改装 : G-3捕食者', 'G-磁力弹']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), except_skills=['G-1科罗纳', '改装 : G-2旋雷者', '改装 : G-3捕食者', 'G-磁力弹']),
+    ]
 
 # 伪装
 # gunner_female/mechanic_female/4b2c90ec226fd40e967875aa5eabefb2
@@ -1145,9 +1189,14 @@ class Skill34(ActiveSkill):
     # 捕食者移动范围 : {value7}px
     data7 = get_data(f'{prefix}/{uuid}', 7)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data5, 'type': '+ratio_g', 'skills': ['G-1科罗纳']},
+    #     {'data': data6, 'type': '+ratio_g', 'skills': ['改装 : G-2旋雷者']}]
     associate = [
-        {'data': data5, 'type': '+ratio_g', 'skills': ['G-1科罗纳']},
+        SkillEffect(attribute=MechanicFemaleAttribute.G_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data5)), skills=['G-1科罗纳']),
-        {'data': data6, 'type': '+ratio_g', 'skills': ['改装 : G-2旋雷者']}]
+        SkillEffect(attribute=MechanicFemaleAttribute.G_RATIO, operation=Operation.ADD, value=Percent(LevelTable(data6)), skills=['改装 : G-2旋雷者']),
+    ]
 
     ratio_g = 1.0
 
@@ -1529,7 +1578,11 @@ class Skill41(PassiveSkill):
     # 改装延长持续时间增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 改装 : G-0战争领主
 # gunner_female/mechanic_female/d89f26862e348a801b30bb9fd7125db5
@@ -1742,9 +1795,14 @@ class Skill45(PassiveSkill):
     # G-4雷行者多段攻击间隔减少 : {value9}秒
     data9 = get_data(f'{prefix}/{uuid}', 9)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'type': '*cdReduce', 'exceptSkills': ['改装 : G-0战争领主', '终结者 : 博尔特MX', 'G-X星尘天穹']},
+    #     {'data': data2},
+    # ]
     associate = [
-        {'data': data0, 'type': '*cdReduce', 'exceptSkills': ['改装 : G-0战争领主', '终结者 : 博尔特MX', 'G-X星尘天穹']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['改装 : G-0战争领主', '终结者 : 博尔特MX', 'G-X星尘天穹']),
-        {'data': data2},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
     ]
 
 # G-超级猎鹰
@@ -1977,7 +2035,11 @@ class Skill49(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 每蓄满1个旋雷者Y轴范围增加率 : 12.5%
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # 每蓄满1个旋雷者Y轴范围增加率 : 12.5%
 
 # 超时空光耀加农炮

backend/core/character/GF/gunner_female/paramedic.py

@@ -1,6 +1,15 @@
 #944b9aab492c15a8474f96947ceeb9e4
 from core.basic.skill import PassiveBufferSkill,ActiveBufferSkill,ActiveSkill,PassiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_female/paramedic/cn/skillDetail"
 
 
@@ -439,7 +448,11 @@ class Skill14(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]  # 协战师技能关联
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]  # 协战师技能关联
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 系统 · 战场信息
 # gunner_female/paramedic/6235960237fdb1b77f2c82b33614dcf4
@@ -491,7 +504,11 @@ class Skill15(PassiveBufferSkill):
     # [军械强化 (进阶)]
     # [保护模件 (黄金复苏)]
     Spirit = data1
-    associate = [{"data":data1,"type":"$+Spirit","ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1,"type":"$+Spirit","ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data1)),
+    ]
     CarryRatio = [0]+ [((1 + i / 100) ** 3) * 100 - 100 for i in data1]# noqa: E501
     # [激光炮击目标技能]
     # [保护模件 (缓冲)]
@@ -728,7 +745,11 @@ class Skill22(ActiveBufferSkill):
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
     Spirit = data6
-    associate = [{"data": data6,"type": "$+Spirit","ratio":1}]  # type: ignore
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data6,"type": "$+Spirit","ratio":1}]  # type: ignore
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data6)),
+    ]
 
 # 军械强化
 # gunner_female/paramedic/e73e980e87591bc98940afb1ac0fe522
@@ -1120,7 +1141,11 @@ class Skill30(PassiveBufferSkill):
 
     STRINT = data0
     Spirit = data1
-    associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data1)),
+    ]
 
 # 强袭策略 : 区域肃清
 # gunner_female/paramedic/ca0cc360e00e5f13e33027bf5fc53d5d
@@ -1346,7 +1371,11 @@ class Skill35(PassiveBufferSkill):
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
     Spirit = data0
-    associate = [{"data": data0,"type": "$+Spirit","ratio":1}]  # type: ignore
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data0,"type": "$+Spirit","ratio":1}]  # type: ignore
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data0)),
+    ]
 
 # 战服 · 超限压制
 # gunner_female/paramedic/9559c99a9596b20d031de1ce2649b326
@@ -1547,7 +1576,11 @@ class Skill40(PassiveBufferSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
     Spirit = data1
-    associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data1,"type": "$+Spirit","ratio":1}]  # type: ignore
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data1)),
+    ]
 
 # 系统 · 孤军突破
 # gunner_female/paramedic/56ef36c1980e67dd2bb50b180a925b89

backend/core/character/GF/gunner_female/ranger_female.py

@@ -1,6 +1,17 @@
 #944b9aab492c15a8474f96947ceeb9e4
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    ExtraData,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_female/ranger_female/cn/skillDetail"
 
 
@@ -608,7 +619,11 @@ class Skill19(ActiveSkill):
     # [范围信息]
     # 子弹速度比率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"type":"+dataplus0","data":data0,"skills":["心灵反击","溃灭回射"],"ratio":1}]# noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"+dataplus0","data":data0,"skills":["心灵反击","溃灭回射"],"ratio":1}]# noqa: E501
+    associate = [
+        SkillEffect(attribute=ExtraData(0), operation=Operation.ADD, value=LevelTable(data0), skills=['心灵反击', '溃灭回射']),
+    ]
 
 # 刺踢
 # gunner_female/ranger_female/c9664191611af31142e052dfaef84530
@@ -720,7 +735,11 @@ class Skill22(PassiveSkill):
     # 填装速度增加 : {value7}%
     data7 = get_data(f'{prefix}/{uuid}', 7)
 
-    associate = [{"type":"$*PAtkP","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"$*PAtkP","data":data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 空中射击
 # gunner_female/ranger_female/bb34e8854a93fd250347a1c64119f7ab
@@ -860,7 +879,11 @@ class Skill26(PassiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
     # Y轴每秒移动距离 : {value6}px
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{"data":data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 暴击
 # gunner_female/ranger_female/fc1262c19f3d0477ee8eda47b8db8696
@@ -1382,7 +1405,11 @@ class Skill38(PassiveSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
     # 出血攻击力 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 绯红盛宴
 # gunner_female/ranger_female/374f53e8989ef04a8506c8ec99d9ecdc
@@ -1561,7 +1588,11 @@ class Skill42(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 出血持续时间增加 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 死亡锁链
 # gunner_female/ranger_female/8ec9da6f808889b63adf2680fbf1f331
@@ -1765,7 +1796,12 @@ class Skill46(PassiveSkill):
     # [花式枪术]
     # 可强制中断次数上限增加量 : {value3}
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"data":data0},{"data":data1,"type":"=power0","skills":["锁链截击"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0},{"data":data1,"type":"=power0","skills":["锁链截击"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=Power(0), operation=Operation.ASSIGN, value=LevelTable(data1), skills=['锁链截击']),
+    ]
 
 # 毁灭风暴
 # gunner_female/ranger_female/d59c9840f65381bde8487757f1753c71

backend/core/character/GF/gunner_female/spitfire_female.py

@@ -1,6 +1,15 @@
 # 944b9aab492c15a8474f96947ceeb9e4
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "gunner_female/spitfire_female/cn/skillDetail"
 
@@ -710,7 +719,12 @@ class Skill22(PassiveSkill):
     # 后跳使用时，消耗使用次数 : {value6}
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'data': data0, 'skills': ['交叉射击', '聚合弹', '凝固汽油弹', '超真空弹 : 切利']}, {'data': data1, 'skills': ['爆裂弹']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'skills': ['交叉射击', '聚合弹', '凝固汽油弹', '超真空弹 : 切利']}, {'data': data1, 'skills': ['爆裂弹']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['交叉射击', '聚合弹', '凝固汽油弹', '超真空弹 : 切利']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['爆裂弹']),
+    ]
 
 # 空中射击
 # gunner_female/spitfire_female/bb34e8854a93fd250347a1c64119f7ab
@@ -848,7 +862,12 @@ class Skill26(PassiveSkill):
     # 暴击率增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'data': data3, 'type': '*skillDamage'}, {'data': data4, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data3, 'type': '*skillDamage'}, {'data': data4, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4))),
+    ]
 
 # 手雷精通
 # gunner_female/spitfire_female/0113c8b1306ca76d208f83f2d093dd62
@@ -875,11 +894,15 @@ class Skill27(PassiveSkill):
 
     ratio = 1.0
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        self.associate = [
+    # def effect(self, old, new):
-        {'type': '*skillDamage', 'data': [i*self.ratio for i in self.data0], 'skills': ['G-14手雷', 'G-35L感电手雷', 'G-18C冰冻手雷']},
+    #     self.associate = [
-        ]
+    #     {'type': '*skillDamage', 'data': [i*self.ratio for i in self.data0], 'skills': ['G-14手雷', 'G-35L感电手雷', 'G-18C冰冻手雷']},
-        return super().effect(old, new)
+    #     ]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0) * Read(SkillAttribute.RATIO)), skills=['G-14手雷', 'G-35L感电手雷', 'G-18C冰冻手雷']),
+    ]
 
 
 # 暴击
@@ -939,7 +962,12 @@ class Skill29(PassiveSkill):
     # 填装速度增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'data': data0, 'type': '$*PAtkI'}, {'data': data2, 'type': '*cdReduce', 'exceptSkills': ['EMP磁暴', '决战之日', '终解·制空霸权']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '$*PAtkI'}, {'data': data2, 'type': '*cdReduce', 'exceptSkills': ['EMP磁暴', '决战之日', '终解·制空霸权']}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_I, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data2)), except_skills=['EMP磁暴', '决战之日', '终解·制空霸权']),
+    ]
 
 # M18阔剑地雷
 # gunner_female/spitfire_female/2ff50c35efcf0f287c4c418c8454da48
@@ -1487,7 +1515,11 @@ class Skill41(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 过电流持续时间 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # EMP磁暴
 # gunner_female/spitfire_female/2c9d9a36c8401bddff6cdb80fab8dc24
@@ -1678,7 +1710,11 @@ class Skill45(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 开火
 # gunner_female/spitfire_female/9ceb0c55f40f1fc0fe0fcc65c8fee3a0
@@ -1851,10 +1887,15 @@ class Skill49(PassiveSkill):
     # 强化手雷攻击力 : 手雷攻击力的{value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    #     {'type': '*ratio', 'data': data1, 'skills': ['手雷精通']},
+    #     ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {'type': '*ratio', 'data': data1, 'skills': ['手雷精通']},
+        SkillEffect(attribute=SkillAttribute.RATIO, value=1 + Percent(LevelTable(data1)), skills=['手雷精通']),
-        ]
+    ]
 
 # 空袭战略
 # gunner_female/spitfire_female/c591d1827cfbe224031c704e21d07932

backend/core/character/GF/gunner_male/assault.py

@@ -1,6 +1,15 @@
 #afdf3b989339de478e85b614d274d1ef
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_male/assault/cn/skillDetail"
 
 
@@ -108,7 +117,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['瞄准射击']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['瞄准射击']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['瞄准射击']),
+    ]
 
 # 受身蹲伏
 # gunner_male/assault/ce26c6b69d02a440a81b552bec94f03b
@@ -624,7 +637,11 @@ class Skill20(PassiveSkill):
     # 命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 瞄准射击
 # gunner_male/assault/b3ba5c678595305d31dcb11a8350971b
@@ -715,7 +732,11 @@ class Skill23(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 改装榴弹
 # gunner_male/assault/67f4b84ed61ee86f505a852b202762a0
@@ -907,7 +928,11 @@ class Skill29(PassiveSkill):
     # 攻击范围比率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'skills': ['烟尘弹']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'skills': ['烟尘弹']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['烟尘弹']),
+    ]
 
 # 三连霰弹
 # gunner_male/assault/e7e39aa9fcf182c8db543235c8af7dac
@@ -1270,7 +1295,11 @@ class Skill36(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data':data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data':data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 电弧能量释放
 # gunner_male/assault/fa7f1a3dc90600456cbe010e5714bef3
@@ -1501,7 +1530,11 @@ class Skill41(PassiveSkill):
     # 盾牌保护区域伤害减少效果增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data':data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data':data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # AT-SO步行者
 # gunner_male/assault/50a859dea1a48a2f60916afbfc91434f
@@ -1765,9 +1798,14 @@ class Skill46(PassiveSkill):
     # [超频 ： 压制]冷却时间减少 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    #     {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['超频 : 压制'], 'ratio': 1},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['超频 : 压制'], 'ratio': 1},
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [-1] * maxLv), skills=['超频 : 压制']),
     ]
 
 # 超频 : 音速瞬杀

backend/core/character/GF/gunner_male/launcher_male.py

@@ -1,6 +1,17 @@
 #afdf3b989339de478e85b614d274d1ef
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_male/launcher_male/cn/skillDetail"
 
 
@@ -615,10 +626,16 @@ class Skill20(PassiveSkill):
     # 技能冷却时间减少率 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"$*PAtkP","data":data2},
+    #     {"data":data3},
+    #     {"type":"*cdReduce","data":data4,"exceptSkills":['卫星射线', '毁灭射线', '裂核轨道炮']},
+    # ]
     associate = [
-        {"type":"$*PAtkP","data":data2},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data2))),
-        {"data":data3},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
-        {"type":"*cdReduce","data":data4,"exceptSkills":['卫星射线', '毁灭射线', '裂核轨道炮']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data4)), except_skills=['卫星射线', '毁灭射线', '裂核轨道炮']),
     ]
 
 # 空中射击
@@ -669,12 +686,23 @@ class Skill22(PassiveSkill):
     rangeLv = 1
     uuid = "e49e57b2e8fbeceb0a2c56a0c63fe6c5"
 
+    # 迁移前实现（保留对照）：
+    # def effect(self, old, new):
+    #     skills = []
+    #     for i in self.char.skills:
+    #         if i.type == "active" and i.learnLv not in [50,85,100] and i.damage and self.char.skill_effects.is_learned(i):
+    #             skills.append(i.name)
+    #     self.associate = [{"type":"+lv","data":[0] + [1]*self.maxLv,"ratio":1,"skills":skills}]
+    #     super().effect(old, new)
+    # 仅动态枚举目标名称，贡献值与 VP 条件交由类型化声明处理。
     def effect(self, old, new):
         skills = []
         for i in self.char.skills:
             if i.type == "active" and i.learnLv not in [50,85,100] and i.damage and self.char.skill_effects.is_learned(i):
                 skills.append(i.name)
-        self.associate = [{"type":"+lv","data":[0] + [1]*self.maxLv,"ratio":1,"skills":skills}]
+        self.associate = [
+            SkillEffect(attribute=SkillAttribute.LEVEL, operation=Operation.ADD, value=LevelTable([0] + [1] * self.maxLv), skills=skills),
+        ]
         super().effect(old, new)
 
 
@@ -885,7 +913,11 @@ class Skill29(PassiveSkill):
     # 攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data1,"skills":["激光炮"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1,"skills":["激光炮"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['激光炮']),
+    ]
 
 # 超动力补给包
 # gunner_male/launcher_male/04c7b4361ca81f041e868169ff044252
@@ -906,7 +938,11 @@ class Skill30(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 聚焦喷火器
 # gunner_male/launcher_male/04883563896fe1adac7505c6146b5f59
@@ -1235,7 +1271,11 @@ class Skill38(PassiveSkill):
     # 暴击伤害增加率 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{"data":data5}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data5}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data5))),
+    ]
 
 # 卫星射线
 # gunner_male/launcher_male/0232c151ef3731c2dede51931a374723
@@ -1391,10 +1431,14 @@ class Skill41(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"data":[0]+[-29]*self.maxLv,"skills":["FM-92刺弹炮"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"data":[0]+[-29]*self.maxLv,"skills":["FM-92刺弹炮"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-29] * maxLv)), skills=['FM-92刺弹炮'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 地脉震荡器
 # gunner_male/launcher_male/dac8d8207618150c162e4c6f9e168527
@@ -1493,7 +1537,11 @@ class Skill43(PassiveSkill):
     # 施放后僵直时间减少率 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 中子爆弹
 # gunner_male/launcher_male/ef9d26746effee9199b54541f01b8752
@@ -1598,7 +1646,11 @@ class Skill46(PassiveSkill):
     # 基本攻击和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # ML-95火炮发射器
 # gunner_male/launcher_male/854997c3bdfc3a2b498b4c4001f69e06

backend/core/character/GF/gunner_male/mechanic_male.py

@@ -1,6 +1,16 @@
 #afdf3b989339de478e85b614d274d1ef
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Hit,
+    LevelTable,
+    MissingTargetPolicy,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_male/mechanic_male/cn/skillDetail"
 
 
@@ -721,11 +731,17 @@ class Skill23(ActiveSkill):
     # 爆炸伤害变化率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":[i-100 if i > 100 else i for i in data1],"skills":["RX-78追击者","Ez-8自爆者","RX-60陷阱追击者","空投支援", "EZ-10反击者", "TX-45特攻队"]},
+    #     # 光能不享受引爆
+    #     {"type":"*power1","data":[i-100 if i > 100 else i for i in data1],"skills":["拦截机工厂"]},
+    #     {"type":"+power2","data":[i-100 if i > 100 else i for i in data1],"skills":["空战机械 : 风暴"]}
+    # ]
     associate = [
-        {"data":[i-100 if i > 100 else i for i in data1],"skills":["RX-78追击者","Ez-8自爆者","RX-60陷阱追击者","空投支援", "EZ-10反击者", "TX-45特攻队"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 100 else i for i in data1])), skills=['RX-78追击者', 'Ez-8自爆者', 'RX-60陷阱追击者', '空投支援', 'EZ-10反击者', 'TX-45特攻队'], missing_target=MissingTargetPolicy.SKIP),
-        # 光能不享受引爆
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable([i - 100 if i > 100 else i for i in data1])), skills=['拦截机工厂']),
-        {"type":"*power1","data":[i-100 if i > 100 else i for i in data1],"skills":["拦截机工厂"]},
+        SkillEffect(attribute=Power(2), operation=Operation.ADD, value=Percent(LevelTable([i - 100 if i > 100 else i for i in data1])), skills=['空战机械 : 风暴']),
-        {"type":"+power2","data":[i-100 if i > 100 else i for i in data1],"skills":["空战机械 : 风暴"]}
     ]
 
 # G-14手雷
@@ -784,7 +800,11 @@ class Skill25(PassiveSkill):
 
     # 基本攻击和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 嗜战追击者
 # gunner_male/mechanic_male/dc1ffbe7bfcc6dc2be737951960da9ad
@@ -812,7 +832,11 @@ class Skill26(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 被击时出现几率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0,"skills":["RX-78追击者"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"skills":["RX-78追击者"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['RX-78追击者']),
+    ]
 
 # G-1科罗纳
 # gunner_male/mechanic_male/1b1cfab062e0768bcc889e33e1f30dbf
@@ -859,7 +883,11 @@ class Skill27(ActiveSkill):
     # 炸弹爆炸大小比率 : {value8}%
     data8 = get_data(f'{prefix}/{uuid}', 8)
 
-    associate = [{"data":data7,"type":"+power0","skills":["改装 : G-2旋雷者","改装 : G-3捕食者"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data7,"type":"+power0","skills":["改装 : G-2旋雷者","改装 : G-3捕食者"]}]
+    associate = [
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=Percent(LevelTable(data7)), skills=['改装 : G-2旋雷者', '改装 : G-3捕食者']),
+    ]
 
     def getSkillCD(self,mode=None):
         return 1.0
@@ -995,7 +1023,11 @@ class Skill31(ActiveSkill):
     def getSkillCD(self,mode=None):
         return 1.0
 
-    associate = [{"data":data4,"type":"+power0","skills":["G-1科罗纳","改装 : G-3捕食者"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data4,"type":"+power0","skills":["G-1科罗纳","改装 : G-3捕食者"]}]
+    associate = [
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=Percent(LevelTable(data4)), skills=['G-1科罗纳', '改装 : G-3捕食者']),
+    ]
 
 # 方舟反应堆
 # gunner_male/mechanic_male/b1ccbd90d0b40f543ece3b18fcef827f
@@ -1020,7 +1052,11 @@ class Skill32(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 魔法暴击率增加量 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 伪装
 # gunner_male/mechanic_male/4b2c90ec226fd40e967875aa5eabefb2
@@ -1102,7 +1138,11 @@ class Skill34(ActiveSkill):
     # 捕食者可移动范围 : {value7}px
     data7 = get_data(f'{prefix}/{uuid}', 7)
 
-    associate = [{"data":data5,"type":"+power0","skills":["G-1科罗纳","改装 : G-2旋雷者"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data5,"type":"+power0","skills":["G-1科罗纳","改装 : G-2旋雷者"]}]
+    associate = [
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=Percent(LevelTable(data5)), skills=['G-1科罗纳', '改装 : G-2旋雷者']),
+    ]
 
     def getSkillCD(self,mode=None):
         return 1.0
@@ -1432,7 +1472,12 @@ class Skill41(PassiveSkill):
     hasUP = False
     custom = get_data(f'{prefix}/{uuid}', "custom") # noqa: E501
 
-    associate = [{"type":"+hit1","data":[0,-8],"ratio":1,"skills":["拦截机工厂"]},{"type":"+hit5","data":[0,1],"ratio":1,"skills":["拦截机工厂"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"+hit1","data":[0,-8],"ratio":1,"skills":["拦截机工厂"]},{"type":"+hit5","data":[0,1],"ratio":1,"skills":["拦截机工厂"]}]
+    associate = [
+        SkillEffect(attribute=Hit(1), operation=Operation.ADD, value=LevelTable([0, -8]), skills=['拦截机工厂']),
+        SkillEffect(attribute=Hit(5), operation=Operation.ADD, value=LevelTable([0, 1]), skills=['拦截机工厂']),
+    ]
 
 
 # 斗志之歌
@@ -1458,7 +1503,11 @@ class Skill42(PassiveSkill):
 
     # 基本攻击和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 盖波加之拳
 # gunner_male/mechanic_male/51a08fd0c90f0a5276cd552047fac93d
@@ -1648,7 +1697,12 @@ class Skill46(PassiveSkill):
     # 爆炸范围增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{"type":"*cdReduce","data": data1,"exceptSkills":['盖波加之拳', '超时空行军', 'GW-16 瓦尔·德斯坦']}, {"data": data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*cdReduce","data": data1,"exceptSkills":['盖波加之拳', '超时空行军', 'GW-16 瓦尔·德斯坦']}, {"data": data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=['盖波加之拳', '超时空行军', 'GW-16 瓦尔·德斯坦']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # TN-80终结者
 # gunner_male/mechanic_male/002cbdd9bfd0f0b970451ae8d48d029e
@@ -1887,7 +1941,11 @@ class Skill51(PassiveSkill):
 
     # 基本攻击和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # GW-16瓦尔德斯坦
 # gunner_male/mechanic_male/515b442ffbf61a82371abb645c149a31

backend/core/character/GF/gunner_male/ranger_male.py

@@ -1,6 +1,14 @@
 # afdf3b989339de478e85b614d274d1ef
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_male/ranger_male/cn/skillDetail"
 
 
@@ -648,7 +656,11 @@ class Skill21(PassiveSkill):
     # 填装速度增加 : {value7}%
     data7 = get_data(f'{prefix}/{uuid}', 7)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 空中射击
 # gunner_male/ranger_male/bb34e8854a93fd250347a1c64119f7ab
@@ -791,7 +803,11 @@ class Skill25(PassiveSkill):
     # [回旋踢]Y轴每秒移动距离 : {value6}px
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'data': data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
     # [学习卓尔不群后]
     # 可强制中断次数上限增加 : 1次
 
@@ -1276,7 +1292,11 @@ class Skill37(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 效果持续时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 疯狂射击
 # gunner_male/ranger_male/ca75c965f20a150f99f54155a37400df
@@ -1508,7 +1528,13 @@ class Skill42(PassiveSkill):
     # [溃灭回射]冷却时间减少率 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{'data': data0, 'exceptSkills': ['溃灭射击']}, {'data': data1, 'skills': ['溃灭射击']}, {'data': data4, 'type': '*cdReduce', 'skills': ['溃灭回射']}]  # noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'exceptSkills': ['溃灭射击']}, {'data': data1, 'skills': ['溃灭射击']}, {'data': data4, 'type': '*cdReduce', 'skills': ['溃灭回射']}]  # noqa: E501
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), except_skills=['溃灭射击']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['溃灭射击']),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data4)), skills=['溃灭回射']),
+    ]
 
 # 抹杀
 # gunner_male/ranger_male/aa6dd52e1c925d87cdc0ca340056c543
@@ -1612,7 +1638,11 @@ class Skill45(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0}]  # noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]  # noqa: E501
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 爆燃突击
 # gunner_male/ranger_male/7a3fc9d473e8ffe21dd900ddf228a437

backend/core/character/GF/gunner_male/spitfire_male.py

@@ -1,6 +1,14 @@
 #afdf3b989339de478e85b614d274d1ef
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "gunner_male/spitfire_male/cn/skillDetail"
 
 
@@ -765,9 +773,14 @@ class Skill24(PassiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'skills': ['交叉射击', '聚合弹', '凝固汽油弹', '电磁弹 : 麦克斯韦']},
+    #     {'data': data1, 'skills': ['爆裂弹', '贯穿弹', '狙击手增援']}
+    # ]
     associate = [
-        {'data': data0, 'skills': ['交叉射击', '聚合弹', '凝固汽油弹', '电磁弹 : 麦克斯韦']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['交叉射击', '聚合弹', '凝固汽油弹', '电磁弹 : 麦克斯韦']),
-        {'data': data1, 'skills': ['爆裂弹', '贯穿弹', '狙击手增援']}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['爆裂弹', '贯穿弹', '狙击手增援']),
     ]
 
 # 超负荷装填
@@ -823,7 +836,12 @@ class Skill26(PassiveSkill):
     # 暴击率增加 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'data': data3},{'data': data4}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data3},{'data': data4}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4))),
+    ]
 
 # 手雷精通
 # gunner_male/spitfire_male/0113c8b1306ca76d208f83f2d093dd62
@@ -843,8 +861,12 @@ class Skill27(PassiveSkill):
 
     # 攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0, 'skills': ['G-14手雷','G-35L感电手雷','G-18C冰冻手雷']},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0, 'skills': ['G-14手雷','G-35L感电手雷','G-18C冰冻手雷']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['G-14手雷', 'G-35L感电手雷', 'G-18C冰冻手雷']),
     ]
 
 # 暴击
@@ -898,10 +920,16 @@ class Skill29(PassiveSkill):
     # 填装速度增加 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'type': '$*PAtkP'},
+    #     {'data': data0, 'type': '$*PAtkM'},
+    #     {'data': data1, 'type': '*cdReduce', 'exceptSkills': ['EMP磁暴','决战之日','终解·制空霸权']}
+    # ]
     associate = [
-        {'data': data0, 'type': '$*PAtkP'},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
-        {'data': data0, 'type': '$*PAtkM'},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
-        {'data': data1, 'type': '*cdReduce', 'exceptSkills': ['EMP磁暴','决战之日','终解·制空霸权']}
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=['EMP磁暴', '决战之日', '终解·制空霸权']),
     ]
 
 # M18阔剑地雷
@@ -1411,8 +1439,13 @@ class Skill41(PassiveSkill):
     # 同时发射时第二发子弹攻击力比率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0},{'data': data1,'skills':["爆裂弹","贯穿弹"]},
+    # ]
     associate = [
-        {'data': data0},{'data': data1,'skills':["爆裂弹","贯穿弹"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['爆裂弹', '贯穿弹']),
     ]
 
 # 黑玫瑰特种战队
@@ -1642,7 +1675,11 @@ class Skill46(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # G-38智能手雷
 # gunner_male/spitfire_male/0c3a468aee1f7ce06bf91eb3319518c1
@@ -1764,8 +1801,13 @@ class Skill49(PassiveSkill):
     # [交叉射击]技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data": data0},{'data': data1,'skills':["交叉射击"]},
+    # ]
     associate = [
-        {"data": data0},{'data': data1,'skills':["交叉射击"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['交叉射击']),
     ]
     # [交叉射击]冷却时间 : 10秒
     # [M18阔剑地雷]特殊地雷设置范围 : 前方350px

backend/core/character/GF/imperialknight/breaker.py

@@ -1,6 +1,14 @@
 #8d4d2001cdb357e41633c234eb7501b5
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "imperialknight/breaker/cn/skillDetail"
 
 
@@ -54,7 +62,11 @@ class Skill1(PassiveSkill):
     # 技能魔法值消耗量减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [ {"type":"*cdReduce","data":data0,"exceptSkills":['鸣镝破阵']}, ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*cdReduce","data":data0,"exceptSkills":['鸣镝破阵']}, ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['鸣镝破阵']),
+    ]
 
 # 狂野横扫
 # imperialknight/breaker/eb71e1d82d92c7e1d40500a0dcd77aa6
@@ -131,7 +143,11 @@ class Skill4(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['钩爪突袭']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['钩爪突袭']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['钩爪突袭']),
+    ]
 
 # 受身蹲伏
 # imperialknight/breaker/ce26c6b69d02a440a81b552bec94f03b
@@ -412,7 +428,11 @@ class Skill14(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 枪锚踢击
 # imperialknight/breaker/cfacda0647b9a0f595df2c2aad30c18d
@@ -616,7 +636,11 @@ class Skill21(PassiveSkill):
     # 命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 激流勇进
 # imperialknight/breaker/9cb6f9ed646fa87f9b7680a42ce83d1a
@@ -803,10 +827,14 @@ class Skill25(ActiveSkill):
         # self.cd = 7
         # self.skillRation *= 1 - 0.5
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-17.6] * self.maxLv, 'skills': ['钩爪突袭']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-17.6] * self.maxLv, 'skills': ['钩爪突袭']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-17.6] * maxLv)), skills=['钩爪突袭'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 逆浪断空
 # imperialknight/breaker/d085127b0edd719782bd618d5688f4a1
@@ -939,7 +967,11 @@ class Skill28(PassiveSkill):
     # 部分技能所受伤害额外减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [ {"data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 鸣镝破阵
 # imperialknight/breaker/ade01c1d6afc8a05055225045e89fe49
@@ -1108,7 +1140,11 @@ class Skill32(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [ {"data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 战栗轰击
 # imperialknight/breaker/a5fa08f5d509e6ff2ebc68856a470b5a
@@ -1294,7 +1330,11 @@ class Skill36(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [激流勇进]所受伤害减少率 : 30%
 
-    associate = [ {"data":data0} ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"data":data0} ]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # [激流勇进]所受伤害减少率 : 30%
 
 # 狂澜风暴舞

backend/core/character/GF/knight/chaos.py

@@ -1,6 +1,14 @@
 # 0ee8fa5dc525c1a1f23fc6911e921e4a
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "knight/chaos/cn/skillDetail"
 
@@ -864,7 +872,11 @@ class Skill26(PassiveSkill):
     # 命中率增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 魔灵随行
 # knight/chaos/dbf8b30c7057032af0d68fcfa289fdae
@@ -915,7 +927,11 @@ class Skill28(PassiveSkill):
     # 特定技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage', 'skills': ['军团列队', '魔幻旋风', '毁灭突进', '翔空剑', '聚灵升空剑', '魔神百裂拳', '黑暗冲击', '午夜嘉年华', '绚丽耀光', '魔灵乱舞', '黑曜之眸 : 亚丁降临', '绽放·终章', '盛宴·恶之祭典']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage', 'skills': ['军团列队', '魔幻旋风', '毁灭突进', '翔空剑', '聚灵升空剑', '魔神百裂拳', '黑暗冲击', '午夜嘉年华', '绚丽耀光', '魔灵乱舞', '黑曜之眸 : 亚丁降临', '绽放·终章', '盛宴·恶之祭典']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['军团列队', '魔幻旋风', '毁灭突进', '翔空剑', '聚灵升空剑', '魔神百裂拳', '黑暗冲击', '午夜嘉年华', '绚丽耀光', '魔灵乱舞', '黑曜之眸 : 亚丁降临', '绽放·终章', '盛宴·恶之祭典']),
+    ]
 
 # 魔灵召唤 : 狂暴布洛克
 # knight/chaos/6e33d47e6622ce03b6defdd912140270
@@ -1079,7 +1095,11 @@ class Skill31(ActiveSkill):
         self.cd = self.cdList[self.lv]
         return super().getSkillCD(mode)
 
-    associate = [{'type': '*skillDamage', 'data': data7, 'skills': ['魔灵召唤 : 波拉斯', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 迪克老爹']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data7, 'skills': ['魔灵召唤 : 波拉斯', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 迪克老爹']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data7)), skills=['魔灵召唤 : 波拉斯', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 迪克老爹']),
+    ]
 
 # 暴击
 # knight/chaos/fc1262c19f3d0477ee8eda47b8db8696
@@ -1209,17 +1229,30 @@ class Skill35(ActiveSkill):
     # [魔灵炸弹]、 [毁灭突进]、 [碎灵之击]魔灵攻击力增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data1, 'skills': ['魔灵召唤 : 波拉斯', '魔灵召唤 : 瓦尔琪', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 大画家芭芘', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 小吸血鬼夏伊', '魔灵召唤 : 大富翁鲁邦', '魔灵召唤 : 迪克老爹', '魔灵召唤 : 红心女皇艾莉莎']},
+    #     {'type': '+power2', 'data': data2, 'skills': ['魔灵炸弹']},
+    #     {'type': '+power3', 'data': data2, 'skills': ['魔灵炸弹']},
+    #     {'type': '+power5', 'data': data2, 'skills': ['魔灵炸弹']},
+    #     {'type': '+power7', 'data': data2, 'skills': ['魔灵炸弹']},
+    #     {'type': '+power12', 'data': data2, 'skills': ['魔灵炸弹']},
+    #     {'type': '+power13', 'data': data2, 'skills': ['魔灵炸弹']},
+    #     {'type': '+power2', 'data': data2, 'skills': ['毁灭突进']},
+    #     {'type': '+power3', 'data': data2, 'skills': ['毁灭突进']},
+    #     {'type': '*ratio', 'data': data2, 'skills': ['碎灵之击']},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data1, 'skills': ['魔灵召唤 : 波拉斯', '魔灵召唤 : 瓦尔琪', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 大画家芭芘', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 小吸血鬼夏伊', '魔灵召唤 : 大富翁鲁邦', '魔灵召唤 : 迪克老爹', '魔灵召唤 : 红心女皇艾莉莎']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['魔灵召唤 : 波拉斯', '魔灵召唤 : 瓦尔琪', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 大画家芭芘', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 小吸血鬼夏伊', '魔灵召唤 : 大富翁鲁邦', '魔灵召唤 : 迪克老爹', '魔灵召唤 : 红心女皇艾莉莎']),
-        {'type': '+power2', 'data': data2, 'skills': ['魔灵炸弹']},
+        SkillEffect(attribute=Power(2), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔灵炸弹']),
-        {'type': '+power3', 'data': data2, 'skills': ['魔灵炸弹']},
+        SkillEffect(attribute=Power(3), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔灵炸弹']),
-        {'type': '+power5', 'data': data2, 'skills': ['魔灵炸弹']},
+        SkillEffect(attribute=Power(5), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔灵炸弹']),
-        {'type': '+power7', 'data': data2, 'skills': ['魔灵炸弹']},
+        SkillEffect(attribute=Power(7), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔灵炸弹']),
-        {'type': '+power12', 'data': data2, 'skills': ['魔灵炸弹']},
+        SkillEffect(attribute=Power(12), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔灵炸弹']),
-        {'type': '+power13', 'data': data2, 'skills': ['魔灵炸弹']},
+        SkillEffect(attribute=Power(13), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔灵炸弹']),
-        {'type': '+power2', 'data': data2, 'skills': ['毁灭突进']},
+        SkillEffect(attribute=Power(2), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['毁灭突进']),
-        {'type': '+power3', 'data': data2, 'skills': ['毁灭突进']},
+        SkillEffect(attribute=Power(3), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['毁灭突进']),
-        {'type': '*ratio', 'data': data2, 'skills': ['碎灵之击']},
+        SkillEffect(attribute=SkillAttribute.RATIO, value=1 + Percent(LevelTable(data2)), skills=['碎灵之击']),
     ]
 
 # 魔幻旋风
@@ -1890,7 +1923,11 @@ class Skill48(PassiveSkill):
     # 魔灵召唤解除后效果持续时间 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 魔神百裂拳
 # knight/chaos/6a1d1f08a6572be420bb3a256c44c015
@@ -2087,9 +2124,14 @@ class Skill52(PassiveSkill):
     # 魔法暴击几率增加 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'type': '*skillDamage', 'skills': ['魔幻旋风', '毁灭突进', '翔空剑', '聚灵升空剑', '魔神百裂拳', '黑暗冲击', '午夜嘉年华', '绚丽耀光', '魔灵乱舞', '黑曜之眸 : 亚丁降临', '绽放·终章', '盛宴·恶之祭典']},
+    #     {'data': data1, 'type': '*skillDamage', 'skills': ['魔灵召唤 : 波拉斯', '魔灵召唤 : 瓦尔琪', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 大画家芭芘', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 小吸血鬼夏伊', '魔灵召唤 : 大富翁鲁邦', '魔灵召唤 : 迪克老爹', '魔灵召唤 : 红心女皇艾莉莎']},
+    # ]
     associate = [
-        {'data': data0, 'type': '*skillDamage', 'skills': ['魔幻旋风', '毁灭突进', '翔空剑', '聚灵升空剑', '魔神百裂拳', '黑暗冲击', '午夜嘉年华', '绚丽耀光', '魔灵乱舞', '黑曜之眸 : 亚丁降临', '绽放·终章', '盛宴·恶之祭典']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['魔幻旋风', '毁灭突进', '翔空剑', '聚灵升空剑', '魔神百裂拳', '黑暗冲击', '午夜嘉年华', '绚丽耀光', '魔灵乱舞', '黑曜之眸 : 亚丁降临', '绽放·终章', '盛宴·恶之祭典']),
-        {'data': data1, 'type': '*skillDamage', 'skills': ['魔灵召唤 : 波拉斯', '魔灵召唤 : 瓦尔琪', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 大画家芭芘', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 小吸血鬼夏伊', '魔灵召唤 : 大富翁鲁邦', '魔灵召唤 : 迪克老爹', '魔灵召唤 : 红心女皇艾莉莎']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['魔灵召唤 : 波拉斯', '魔灵召唤 : 瓦尔琪', '魔灵召唤 : 狂暴布洛克', '魔灵召唤 : 假面杰森', '魔灵召唤 : 大画家芭芘', '魔灵召唤 : 旋转小冯', '魔灵召唤 : 小吸血鬼夏伊', '魔灵召唤 : 大富翁鲁邦', '魔灵召唤 : 迪克老爹', '魔灵召唤 : 红心女皇艾莉莎']),
     ]
 
 # 绚丽耀光
@@ -2270,7 +2312,11 @@ class Skill56(PassiveSkill):
     # [魔幻旋风]盾牌挥击攻击力 : [魔幻旋风]攻击力总和的{value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 绽放·终章
 # knight/chaos/ca2536eb56df0e812c88c59cabd38be0

backend/core/character/GF/knight/dragon_knight.py

@@ -1,6 +1,15 @@
 # 0ee8fa5dc525c1a1f23fc6911e921e4a
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "knight/dragon_knight/cn/skillDetail"
 
 
@@ -119,7 +128,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['龙人剑术']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['龙人剑术']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['龙人剑术']),
+    ]
 
 # 受身蹲伏
 # knight/dragon_knight/ce26c6b69d02a440a81b552bec94f03b
@@ -708,7 +721,11 @@ class Skill22(ActiveSkill):
     # 冲击波大小比率 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'type': '$*PAtkI', 'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkI', 'data': data1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_I, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 暴击
 # knight/dragon_knight/fc1262c19f3d0477ee8eda47b8db8696
@@ -1101,7 +1118,11 @@ class Skill32(PassiveSkill):
     # 暴击伤害增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 龙刃无双
 # knight/dragon_knight/5c45f69c9ebc7a784e994369d2cc3c66
@@ -1292,7 +1313,11 @@ class Skill35(ActiveSkill):
     # 空中施放技能所需最低高度的减少 : {value3}px
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
     def getSkillCD(self, mode=None):
         return 3.0
@@ -1548,9 +1573,14 @@ class Skill39(PassiveSkill):
     # [超级跳跃]后霸体持续时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data1},
+    #     {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['龙翼', '龙翼突袭'], 'ratio': 1},
+    # ]
     associate = [
-        {'data': data1},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
-        {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['龙翼', '龙翼突袭'], 'ratio': 1},
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [-1] * maxLv), skills=['龙翼', '龙翼突袭']),
     ]
 
 # 魔龙星落
@@ -1781,7 +1811,11 @@ class Skill43(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 龙哮雷鸣
 # knight/dragon_knight/573723c8c0614f5b1218ca9ff992115b

backend/core/character/GF/knight/elven_knight.py

@@ -1,6 +1,25 @@
 # 0ee8fa5dc525c1a1f23fc6911e921e4a
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class ElvenKnightAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    CHAIN_POWER = 'chain_power'
+    """精灵骑士：每层剑盾猛攻对应的伤害加成。"""
+
 
 prefix = "knight/elven_knight/cn/skillDetail"
 
@@ -187,7 +206,11 @@ class Skill4(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['骑乘召唤']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['骑乘召唤']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['骑乘召唤']),
+    ]
 
 # 受身蹲伏
 # knight/elven_knight/ce26c6b69d02a440a81b552bec94f03b
@@ -1024,7 +1047,12 @@ class Skill24(PassiveSkill):
     # 装备巨剑时魔法值消耗量减少 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data0, 'type': '*cdReduce', 'exceptSkills': ['天马流星落', '暮光之灵 : 黄昏独角兽', '生命之律·神木擎天']}, {'data': data1, 'type': '$*PAtkP'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*cdReduce', 'exceptSkills': ['天马流星落', '暮光之灵 : 黄昏独角兽', '生命之律·神木擎天']}, {'data': data1, 'type': '$*PAtkP'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['天马流星落', '暮光之灵 : 黄昏独角兽', '生命之律·神木擎天']),
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 伟大的意志
 # knight/elven_knight/506e7ed77d517419a6e1c437a2cedb17
@@ -1273,7 +1301,11 @@ class Skill31(ActiveSkill):
 
     mode = ['挥盾', '推进']
 
-    associate = [{'type': '+chain_power', 'data': data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+chain_power', 'data': data3}]
+    associate = [
+        SkillEffect(attribute=ElvenKnightAttribute.CHAIN_POWER, operation=Operation.ADD, value=Percent(LevelTable(data3))),
+    ]
 
     def setMode(self, mode):
         if mode == '挥盾':
@@ -1673,10 +1705,14 @@ class Skill38(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"type":"*skillRation","data":[0] + [40]*self.maxLv,"skills":["生命审判"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"type":"*skillRation","data":[0] + [40]*self.maxLv,"skills":["生命审判"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [40] * maxLv)), skills=['生命审判'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 自然恩泽
 # knight/elven_knight/4b2c90ec226fd40e967875aa5eabefb2
@@ -1715,7 +1751,14 @@ class Skill39(PassiveSkill):
     # [生命之律·神木擎天]攻击力增加率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}, {'data': data4, 'type': '*skillDamage', 'skills': ['天马流星落']}, {'data': data5, 'type': '*skillDamage', 'skills': ['暮光之灵 : 黄昏独角兽']}, {'data': data6, 'type': '*skillDamage', 'skills': ['生命之律·神木擎天']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}, {'data': data4, 'type': '*skillDamage', 'skills': ['天马流星落']}, {'data': data5, 'type': '*skillDamage', 'skills': ['暮光之灵 : 黄昏独角兽']}, {'data': data6, 'type': '*skillDamage', 'skills': ['生命之律·神木擎天']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), skills=['天马流星落']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data5)), skills=['暮光之灵 : 黄昏独角兽']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data6)), skills=['生命之律·神木擎天']),
+    ]
 
 # 天马流星落
 # knight/elven_knight/1fadde0eece18649caddbca7bd58cc2f
@@ -1886,10 +1929,14 @@ class Skill42(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-14.3] * self.maxLv, 'skills': ['愤怒冲撞']}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-14.3] * self.maxLv, 'skills': ['愤怒冲撞']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-14.3] * maxLv)), skills=['愤怒冲撞'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
 # 信仰鼓舞
 # knight/elven_knight/2c9d9a36c8401bddff6cdb80fab8dc24
@@ -1919,7 +1966,11 @@ class Skill43(PassiveSkill):
     # 连锁数上限增加 : {value2}
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data1, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 剑盾强袭
 # knight/elven_knight/b89c9ab317bc0a443f6497b7cca2f6a8
@@ -2122,7 +2173,11 @@ class Skill47(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [剑盾猛攻]能量持续时间 : +5秒
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # [剑盾猛攻]能量持续时间 : +5秒
 
 # 荆棘之城

backend/core/character/GF/knight/paladin.py

@@ -1,6 +1,23 @@
 #0ee8fa5dc525c1a1f23fc6911e921e4a
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class PaladinAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    LITTLE_POWER = 'powerLittle'
+    """帕拉丁：神光喷涌特殊形态倍率。"""
+
 prefix = "knight/paladin/cn/skillDetail"
 
 
@@ -519,7 +536,11 @@ class Skill16(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 霸体持续时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{"data":data1,"type":"$*PAtkP"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1,"type":"$*PAtkP"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 天使光翼
 # knight/paladin/9dc8438e4572d39243c97da31c113acc
@@ -632,7 +653,12 @@ class Skill17(PassiveSkill):
     # 拥有7个天使光翼时 : 5%
     # 拥有8个天使光翼时 : 10%
 
-    associate = [{"data":data0,"type":"$*PAtkP"},{"data":data1,"type":"*cdReduce"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"type":"$*PAtkP"},{"data":data1,"type":"*cdReduce"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1))),
+    ]
 
 # 神光冲击
 # knight/paladin/3fb8395ae3b81bd608e0c4223a8eb534
@@ -1166,7 +1192,11 @@ class Skill31(PassiveSkill):
     # 物理攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 天使光翼获得量 : 2个
-    associate = [{"data":data0,"type":"$*PAtkP"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"type":"$*PAtkP"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
     # 天使光翼获得量 : 2个
 
 # 信仰聚合 : 神光惩戒
@@ -1386,7 +1416,11 @@ class Skill36(PassiveSkill):
     # 天使光翼获得量 : {value1}个
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 神光回旋斩
 # knight/paladin/0e3da11226dd30c2aaef52e36eff7f3f
@@ -1554,7 +1588,12 @@ class Skill40(PassiveSkill):
     # 天使光翼获得量 : {value4}个
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{"data":data0},{"data":data1,"type":"+powerLittle","skills":["神光喷涌"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0},{"data":data1,"type":"+powerLittle","skills":["神光喷涌"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=PaladinAttribute.LITTLE_POWER, operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['神光喷涌']),
+    ]
 
 # 神光耀世
 # knight/paladin/481348575c1e141925c836b59c5db3ca

backend/core/character/GF/mage_female/battle_mage.py

@@ -3,6 +3,23 @@ from core.basic.roleinfo import CharacterEquipInfo
 from core.basic.formula import 武器强化计算
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class BattleMageAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    USE_CHANGE = 'useChange'
+    """战斗法师：是否启用煌龙偃月的替代形态。"""
+
 prefix = "mage_female/battle_mage/cn/skillDetail"
 
 
@@ -111,7 +128,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['炫纹']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['炫纹']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['炫纹']),
+    ]
 
 # 受身蹲伏
 # mage_female/battle_mage/ce26c6b69d02a440a81b552bec94f03b
@@ -435,8 +456,12 @@ class Skill14(PassiveSkill):
     # 物理、 魔法暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 落花掌
@@ -617,7 +642,11 @@ class Skill19(ActiveSkill):
     # 暴击率增加 : {value9}%
     data9 = get_data(f'{prefix}/{uuid}', 9)
 
-    associate = [{'type': '*skillDamage', 'data': data6}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data6}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data6))),
+    ]
 
 # 实战型替身草人
 # mage_female/battle_mage/fc30c667a58e1dd54b5d214e04f4f23c
@@ -645,7 +674,11 @@ class Skill20(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 替身草人冷却时间减少 : {value3}秒
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'type': '+cdCut', 'skills': ['替身草人'], 'data': data3, 'ratio': 1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+cdCut', 'skills': ['替身草人'], 'data': data3, 'ratio': 1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_CUT, operation=Operation.ADD, value=LevelTable(data3), skills=['替身草人']),
+    ]
 
 # 战斗法师武器精通
 # mage_female/battle_mage/27bade584bb42fef68148d3a0b72bace
@@ -685,10 +718,16 @@ class Skill21(PassiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
     # 装备矛时，技能攻击范围增加率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0},
+    #     {'type': '$*PAtkM', 'data': data0},
+    #     {'type': '*cdReduce', 'data': data2, 'exceptSkills': ['星纹陨爆', '一骑当千碎霸', '太古星河·殒灭']},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
-        {'type': '$*PAtkM', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
-        {'type': '*cdReduce', 'data': data2, 'exceptSkills': ['星纹陨爆', '一骑当千碎霸', '太古星河·殒灭']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data2)), except_skills=['星纹陨爆', '一骑当千碎霸', '太古星河·殒灭']),
     ]
 
 # 双重锤击
@@ -1153,7 +1192,11 @@ class Skill32(PassiveSkill):
     rangeLv = 2
     uuid = '573723c8c0614f5b1218ca9ff992115b'
 
-    associate = [{'type': '+useChange', 'data': [0, 100], 'skills': ['煌龙偃月']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+useChange', 'data': [0, 100], 'skills': ['煌龙偃月']}]
+    associate = [
+        SkillEffect(attribute=BattleMageAttribute.USE_CHANGE, operation=Operation.ADD, value=Percent(LevelTable([0, 100])), skills=['煌龙偃月']),
+    ]
 
 
 # 斗神意志
@@ -1203,8 +1246,12 @@ class Skill33(PassiveSkill):
     # 回避率增加 : {value12}%
     data12 = get_data(f'{prefix}/{uuid}', 12)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 星纹陨爆
@@ -1363,8 +1410,12 @@ class Skill37(PassiveSkill):
     # 物理暴击率和魔法暴击率补正比率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 炫纹簇
@@ -1632,8 +1683,12 @@ class Skill44(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 炫纹之源 : 太古神光

backend/core/character/GF/mage_female/elementalist.py

@@ -1,6 +1,16 @@
 #3909d0b188e9c95311399f776e331da5
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "mage_female/elementalist/cn/skillDetail"
 
 
@@ -914,11 +924,16 @@ class Skill25(ActiveSkill):
 
     ratio = 1.0
 
-    associate = [{"type":"*cdRatio","data":data1,"skills":['冰墙', '元素之门', '元素之幕', '元素震荡', '圣灵水晶', '烈焰冲击','天雷', '雷旋', '杰克降临', '湮灭黑洞', '极冰盛宴', '虚无之球', '光与暗的交响']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*cdRatio","data":data1,"skills":['冰墙', '元素之门', '元素之幕', '元素震荡', '圣灵水晶', '烈焰冲击','天雷', '雷旋', '杰克降临', '湮灭黑洞', '极冰盛宴', '虚无之球', '光与暗的交响']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_RATIO, value=1 - (Percent(LevelTable(data1)) * Read(SkillAttribute.RATIO)), skills=['冰墙', '元素之门', '元素之幕', '元素震荡', '圣灵水晶', '烈焰冲击', '天雷', '雷旋', '杰克降临', '湮灭黑洞', '极冰盛宴', '虚无之球', '光与暗的交响']),
+    ]
 
     # 技能等级变化的时候，系数对应的数值变化
-    def update_skill_attribute(self, skill, type, old, new, data, ratio=100, weapon=(), weapon_type=None, weapon_options=()):
+    # 迁移前实现（保留对照）：
-        super().update_skill_attribute(skill, type, old, new, data, ratio / self.ratio, weapon, weapon_type, weapon_options)
+    # def update_skill_attribute(self, skill, type, old, new, data, ratio=100, weapon=(), weapon_type=None, weapon_options=()):
+    #     super().update_skill_attribute(skill, type, old, new, data, ratio / self.ratio, weapon, weapon_type, weapon_options)
 
 # 虚无之球
 # mage_female/elementalist/5dc7008b12a459325b548b0715c6b73c
@@ -1126,11 +1141,16 @@ class Skill31(PassiveSkill):
 
     ratio = 1.0
 
-    associate = [{"type":"*skillDamage","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*skillDamage","data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + (Percent(LevelTable(data0)) * Read(SkillAttribute.RATIO))),
+    ]
 
     # 技能等级变化的时候，系数对应的数值变化
-    def update_skill_attribute(self, skill, type, old, new, data, ratio=100, weapon=(), weapon_type=None, weapon_options=()):
+    # 迁移前实现（保留对照）：
-        super().update_skill_attribute(skill, type, old, new, data, ratio / self.ratio, weapon, weapon_type, weapon_options)
+    # def update_skill_attribute(self, skill, type, old, new, data, ratio=100, weapon=(), weapon_type=None, weapon_options=()):
+    #     super().update_skill_attribute(skill, type, old, new, data, ratio / self.ratio, weapon, weapon_type, weapon_options)
 
 # 天雷
 # mage_female/elementalist/d2c6df5105577fb59fb92529a36165a0
@@ -1228,9 +1248,14 @@ class Skill33(PassiveSkill):
     # [天雷]攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [天雷]发射间隔减少率 : 50%
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"+cd","data":[0,5],"skills":["天雷"],"ratio":1},
+    #     {"type":"*skillDamage","data":data0,"skills":["天雷"]}
+    # ]
     associate = [
-        {"type":"+cd","data":[0,5],"skills":["天雷"],"ratio":1},
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0, 5]), skills=['天雷']),
-        {"type":"*skillDamage","data":data0,"skills":["天雷"]}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['天雷']),
     ]
     # [天雷]发射间隔减少率 : 50%
 
@@ -1465,7 +1490,11 @@ class Skill37(PassiveSkill):
     # 魔法暴击率增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"type":"$*PAtkM","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"$*PAtkM","data":data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 陨星幻灭
 # mage_female/elementalist/b3659936a9a74c4ed6f7faf07cca1f9e
@@ -1672,7 +1701,11 @@ class Skill41(PassiveSkill):
     # [杰克降临]大小增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{"type":"*skillDamage","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*skillDamage","data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 圣灵符文
 # mage_female/elementalist/bb34e8854a93fd250347a1c64119f7ab
@@ -1709,9 +1742,14 @@ class Skill42(ActiveSkill):
     # 魔法暴击率增加量 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"+ratio","data":data0,"skills":["魔法秀"]},
+    #     {"type":"+ratio","data":data2,"skills":["属性精通"]}
+    # ]
     associate = [
-        {"type":"+ratio","data":data0,"skills":["魔法秀"]},
+        SkillEffect(attribute=SkillAttribute.RATIO, operation=Operation.ADD, value=Percent(LevelTable(data0)), skills=['魔法秀']),
-        {"type":"+ratio","data":data2,"skills":["属性精通"]}
+        SkillEffect(attribute=SkillAttribute.RATIO, operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['属性精通']),
     ]
 
 # 圣灵水晶
@@ -1907,7 +1945,11 @@ class Skill46(PassiveSkill):
     # 融合虚无之球多段攻击力 : 虚无之球多段攻击力的40%
     # 融合虚无之球爆炸攻击力 : 虚无之球多段攻击力的240%
 
-    associate = [{"type":"*skillDamage","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*skillDamage","data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # 融合虚无之球多段攻击力 : 虚无之球多段攻击力的40%
     # 融合虚无之球爆炸攻击力 : 虚无之球多段攻击力的240%
 

backend/core/character/GF/mage_female/enchantress.py

@@ -1,6 +1,12 @@
 #3909d0b188e9c95311399f776e331da5
 from core.basic.skill import PassiveBufferSkill,ActiveBufferSkill,ActiveSkill,PassiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+)
 prefix = "mage_female/enchantress/cn/skillDetail"
 
 
@@ -891,7 +897,11 @@ class Skill25(PassiveBufferSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
     INT = data0
-    associate = [{"data":INT,"type":"$+INT","ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":INT,"type":"$+INT","ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(INT)),
+    ]
 
 # 疯狂乱抓
 # mage_female/enchantress/6bbf76bcd2ed3ca25f21b760db4342ad
@@ -1662,7 +1672,11 @@ class Skill43(PassiveBufferSkill):
     INT = data3
     STRINT = data3
 
-    associate = [{"data":INT,"type":"$+INT","ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":INT,"type":"$+INT","ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(INT)),
+    ]
 
 # 开幕！ 人偶剧场
 # mage_female/enchantress/56fca6cff74d828e92301a40cd2148b9
@@ -1968,7 +1982,11 @@ class Skill49(PassiveBufferSkill):
     data7 = get_data(f'{prefix}/{uuid}', 7)
 
     INT = data0
-    associate = [{"data":INT ,"type":"$+INT","ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":INT ,"type":"$+INT","ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(INT)),
+    ]
     CarryRatio = [0]+ [(1.05 ** 3) * 100 - 100]*maxLv# noqa: E501
 
 # 苦痛庭院
@@ -2157,7 +2175,11 @@ class Skill53(PassiveBufferSkill):
     # [疯熊守护]防御冷却时间 : 30秒
 
     INT = data1
-    associate = [{"data": data1,"type": "$+INT","ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data1,"type": "$+INT","ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(data1)),
+    ]
     # [疯熊守护]防御冷却时间 : 30秒
 
 # 挚爱囚笼

backend/core/character/GF/mage_female/summoner.py

@@ -2,9 +2,17 @@
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data, _get_skill_damage_suffixes
 from core.basic.character import Character
 
-prefix = "mage_female/summoner/cn/skillDetail"
 
 from enum import Enum
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Operation,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
+
+prefix = "mage_female/summoner/cn/skillDetail"
 
 class EnumDataType(Enum):
     A = '附灵'
@@ -1056,35 +1064,39 @@ class Skill27(PassiveSkill):
     # 物防和魔防的增加 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {
+    #         'data': data3,
+    #         'type': '*skillDamage',
+    #         'skills': [
+    #             '契约召唤 : 赫德尔',
+    #             '精灵召唤 : 亚德炎',
+    #             '精灵召唤 : 冰奈斯',
+    #             '精灵召唤 : 瑟冥特克',
+    #             '精灵召唤 : 雷沃斯',
+    #             '契约召唤 : 弗利特',
+    #             '契约召唤 : 桑德尔',
+    #             '精灵召唤 : 亡魂默克尔',
+    #             '精灵召唤 : 极光格雷林',
+    #             '精灵召唤 : 冰影阿奎利斯',
+    #             '精灵召唤 : 火焰赫瑞克',
+    #             '契约召唤 : 路易丝',
+    #             '精灵召唤 : 伊伽贝拉',
+    #             '契约召唤 : 牛头王库鲁塔',
+    #             '契约召唤 : 征服者卡西利亚斯',
+    #             '必杀剑·千鬼杀',
+    #             '狂化黑月',
+    #             '传说召唤 : 月蚀之影',
+    #             '传说召唤 : 逆月者拉莫斯',
+    #             '咒令 : 逆月之蚀',
+    #             '至高精灵王',
+    #             '魔月·德拉里昂',
+    #         ],
+    #     }
+    # ]
     associate = [
-        {
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), skills=['契约召唤 : 赫德尔', '精灵召唤 : 亚德炎', '精灵召唤 : 冰奈斯', '精灵召唤 : 瑟冥特克', '精灵召唤 : 雷沃斯', '契约召唤 : 弗利特', '契约召唤 : 桑德尔', '精灵召唤 : 亡魂默克尔', '精灵召唤 : 极光格雷林', '精灵召唤 : 冰影阿奎利斯', '精灵召唤 : 火焰赫瑞克', '契约召唤 : 路易丝', '精灵召唤 : 伊伽贝拉', '契约召唤 : 牛头王库鲁塔', '契约召唤 : 征服者卡西利亚斯', '必杀剑·千鬼杀', '狂化黑月', '传说召唤 : 月蚀之影', '传说召唤 : 逆月者拉莫斯', '咒令 : 逆月之蚀', '至高精灵王', '魔月·德拉里昂']),
-            'data': data3,
-            'type': '*skillDamage',
-            'skills': [
-                '契约召唤 : 赫德尔',
-                '精灵召唤 : 亚德炎',
-                '精灵召唤 : 冰奈斯',
-                '精灵召唤 : 瑟冥特克',
-                '精灵召唤 : 雷沃斯',
-                '契约召唤 : 弗利特',
-                '契约召唤 : 桑德尔',
-                '精灵召唤 : 亡魂默克尔',
-                '精灵召唤 : 极光格雷林',
-                '精灵召唤 : 冰影阿奎利斯',
-                '精灵召唤 : 火焰赫瑞克',
-                '契约召唤 : 路易丝',
-                '精灵召唤 : 伊伽贝拉',
-                '契约召唤 : 牛头王库鲁塔',
-                '契约召唤 : 征服者卡西利亚斯',
-                '必杀剑·千鬼杀',
-                '狂化黑月',
-                '传说召唤 : 月蚀之影',
-                '传说召唤 : 逆月者拉莫斯',
-                '咒令 : 逆月之蚀',
-                '至高精灵王',
-                '魔月·德拉里昂',
-            ],
-        }
     ]
 
 # 伺机而动
@@ -1140,7 +1152,11 @@ class Skill29(PassiveSkill):
     # 基本攻击和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 召唤下级精灵
 # mage_female/summoner/f8226512ea3dbcb1fe1374baa0c6bbee
@@ -1199,7 +1215,11 @@ class Skill31(ActiveSkill):
     # 蓄气时间上限减少率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'type': '*cdRatio', 'data': data1, 'skills': ['精灵献祭', '咒令 : 愤怒咆哮']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*cdRatio', 'data': data1, 'skills': ['精灵献祭', '咒令 : 愤怒咆哮']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_RATIO, value=1 - Percent(LevelTable(data1)), skills=['精灵献祭', '咒令 : 愤怒咆哮']),
+    ]
 
 # 精灵献祭
 # mage_female/summoner/c27418ae613c647527200a7ca17d97fd
@@ -1518,7 +1538,11 @@ class Skill38(PassiveSkill):
     # [鞭挞]增益效果持续时间增加 : {value0}秒
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': [0] + [2] * maxLv, 'type': '+cd', 'skills': ['鞭挞'], 'ratio': 1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': [0] + [2] * maxLv, 'type': '+cd', 'skills': ['鞭挞'], 'ratio': 1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [2] * maxLv), skills=['鞭挞']),
+    ]
 
 # 契约召唤 : 袄索
 # mage_female/summoner/e4c354a89c337310aeb7041d5e742828
@@ -2131,7 +2155,11 @@ class Skill46(SummonSkill):
     # 自身强化
     skillDamage = 1.3
 
-    associate = [{'type': '*skillDamage', 'data': data13, 'skills': ['精灵召唤 : 亡魂默克尔', '精灵召唤 : 极光格雷林', '精灵召唤 : 冰影阿奎利斯', '精灵召唤 : 火焰赫瑞克']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data13, 'skills': ['精灵召唤 : 亡魂默克尔', '精灵召唤 : 极光格雷林', '精灵召唤 : 冰影阿奎利斯', '精灵召唤 : 火焰赫瑞克']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data13)), skills=['精灵召唤 : 亡魂默克尔', '精灵召唤 : 极光格雷林', '精灵召唤 : 冰影阿奎利斯', '精灵召唤 : 火焰赫瑞克']),
+    ]
 
     def vp_1(self):
         """
@@ -2359,7 +2387,11 @@ class Skill50(PassiveSkill):
     # 施放速度增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 契约召唤 : 征服者卡西利亚斯
 # mage_female/summoner/0b8db1e10b3abbd24d38564e708675d5
@@ -2530,7 +2562,11 @@ class Skill54(ActiveSkill):
     # 速度增加光环范围 : {value6}px
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'data': data2, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
     def vp_1(self):
         """
@@ -2647,7 +2683,11 @@ class Skill56(PassiveSkill):
     # 召唤技能冷却时间减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 狂化黑月
 # mage_female/summoner/8572675ec6a1f50b6eff6a867376c2de
@@ -2961,7 +3001,11 @@ class Skill61(PassiveSkill):
     # [鞭挞]召唤兽攻击、 移动速度额外增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 至高精灵王
 # mage_female/summoner/13e8c4ad93473b5fcea11e81ce9456f5

backend/core/character/GF/mage_female/witch.py

@@ -1,6 +1,26 @@
 # 3909d0b188e9c95311399f776e331da5
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    LevelTable,
+    MissingTargetPolicy,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class WitchAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    FAIL_POWER = 'powerFail'
+    """魔道学者：失败形态伤害倍率。"""
+    SUCCESS_POWER = 'powerSuccess'
+    """魔道学者：成功形态伤害倍率。"""
+
 
 prefix = "mage_female/witch/cn/skillDetail"
 
@@ -897,7 +917,11 @@ class Skill24(PassiveSkill):
     # [改良魔法星弹]探索范围增加率 : {value10}%
     data10 = get_data(f'{prefix}/{uuid}', 10)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 扫把掌握
 # mage_female/witch/5152480fdde81362575a488d4cec4af9
@@ -1080,7 +1104,11 @@ class Skill28(ActiveSkill):
     # 蓄气时间上限减少率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'type': '*cdRatio', 'data': data1, 'skills': ['改良魔法星弹', '改良舒露露', '熔岩药瓶', '魔道酸雨云', '旋转扫把', '电鳗碰撞机', '暴炎加热炉', '冰霜钻孔车', '反重力装置', '光电兔', '雪人刨冰', '糖果大作战 : 捣蛋杰克']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*cdRatio', 'data': data1, 'skills': ['改良魔法星弹', '改良舒露露', '熔岩药瓶', '魔道酸雨云', '旋转扫把', '电鳗碰撞机', '暴炎加热炉', '冰霜钻孔车', '反重力装置', '光电兔', '雪人刨冰', '糖果大作战 : 捣蛋杰克']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_RATIO, value=1 - Percent(LevelTable(data1)), skills=['改良魔法星弹', '改良舒露露', '熔岩药瓶', '魔道酸雨云', '旋转扫把', '电鳗碰撞机', '暴炎加热炉', '冰霜钻孔车', '反重力装置', '光电兔', '雪人刨冰', '糖果大作战 : 捣蛋杰克']),
+    ]
 
 # 魔幻粉末
 # mage_female/witch/7e904ea3d2a9faa054604e55120a9268
@@ -1268,7 +1296,11 @@ class Skill33(PassiveSkill):
     # 基本攻击力、 技能攻击力增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 魔道酸雨云
 # mage_female/witch/b89c9ab317bc0a443f6497b7cca2f6a8
@@ -1489,10 +1521,16 @@ class Skill37(PassiveSkill):
     # [冰霜钻孔车]失败攻击力增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data1, 'type': '+powerFail', 'skills': ['熔岩药瓶']},
+    #     {'data': data2, 'type': '+powerFail', 'skills': ['暴炎加热炉']},
+    #     {'data': data3, 'type': '+powerFail', 'skills': ['冰霜钻孔车']},
+    # ]
     associate = [
-        {'data': data1, 'type': '+powerFail', 'skills': ['熔岩药瓶']},
+        SkillEffect(attribute=WitchAttribute.FAIL_POWER, operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['熔岩药瓶']),
-        {'data': data2, 'type': '+powerFail', 'skills': ['暴炎加热炉']},
+        SkillEffect(attribute=WitchAttribute.FAIL_POWER, operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['暴炎加热炉']),
-        {'data': data3, 'type': '+powerFail', 'skills': ['冰霜钻孔车']},
+        SkillEffect(attribute=WitchAttribute.FAIL_POWER, operation=Operation.ADD, value=Percent(LevelTable(data3)), skills=['冰霜钻孔车']),
     ]
 
 # 旋转扫把
@@ -2101,7 +2139,11 @@ class Skill44(PassiveSkill):
     # 魔法暴击率增加量 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'data': data4}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data4}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4))),
+    ]
 
 # 技艺融合
 # mage_female/witch/3fb8395ae3b81bd608e0c4223a8eb534
@@ -2185,10 +2227,14 @@ class Skill46(ActiveSkill):
     # 苍蝇拍大小比率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{'data': [0] + [-17.6] * self.maxLv, 'skills': ['变异苍蝇拍']}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{'data': [0] + [-17.6] * self.maxLv, 'skills': ['变异苍蝇拍']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-17.6] * maxLv)), skills=['变异苍蝇拍'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
     def vp_1(self):
         """
@@ -2503,7 +2549,12 @@ class Skill49(ActiveSkill):
     # 重力加速装置束缚时间 : {value28}秒
     data28 = get_data(f'{prefix}/{uuid}', 28)
 
-    associate = [{'data': data3, 'skills': ['变异苍蝇拍', '超级苍蝇拍', '改良舒露露', '改良魔法星弹', '暗影斗篷', '技艺融合', '超级棒棒糖', '光电兔', '雪人刨冰', '乌洛波洛斯之环', '糖果大作战精怪乐园', '糖果大作战捣蛋杰克']}, {'data': data4, 'type': '+powerFail', 'skills': ['熔岩药瓶', '暴炎加热炉', '冰霜钻孔车']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data3, 'skills': ['变异苍蝇拍', '超级苍蝇拍', '改良舒露露', '改良魔法星弹', '暗影斗篷', '技艺融合', '超级棒棒糖', '光电兔', '雪人刨冰', '乌洛波洛斯之环', '糖果大作战精怪乐园', '糖果大作战捣蛋杰克']}, {'data': data4, 'type': '+powerFail', 'skills': ['熔岩药瓶', '暴炎加热炉', '冰霜钻孔车']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), skills=['变异苍蝇拍', '超级苍蝇拍', '改良舒露露', '改良魔法星弹', '暗影斗篷', '技艺融合', '超级棒棒糖', '光电兔', '雪人刨冰', '乌洛波洛斯之环', '糖果大作战精怪乐园', '糖果大作战捣蛋杰克'], missing_target=MissingTargetPolicy.SKIP),
+        SkillEffect(attribute=WitchAttribute.FAIL_POWER, operation=Operation.ADD, value=Percent(LevelTable(data4)), skills=['熔岩药瓶', '暴炎加热炉', '冰霜钻孔车']),
+    ]
 
     level_source = '贤者之石'
 
@@ -2582,7 +2633,12 @@ class Skill50(PassiveSkill):
     # [冰霜钻孔车]攻击力增加率 : {value8}%
     data8 = get_data(f'{prefix}/{uuid}', 8)
 
-    associate = [{'data': data0, 'type': '+powerSuccess', 'skills': ['改良舒露露', '改良魔法星弹', '魔道酸雨云', '电鳗碰撞机', '反重力装置', '熔岩药瓶', '暴炎加热炉']}, {'data': data8, 'skills': ['冰霜钻孔车']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '+powerSuccess', 'skills': ['改良舒露露', '改良魔法星弹', '魔道酸雨云', '电鳗碰撞机', '反重力装置', '熔岩药瓶', '暴炎加热炉']}, {'data': data8, 'skills': ['冰霜钻孔车']}]
+    associate = [
+        SkillEffect(attribute=WitchAttribute.SUCCESS_POWER, operation=Operation.ADD, value=Percent(LevelTable(data0)), skills=['改良舒露露', '改良魔法星弹', '魔道酸雨云', '电鳗碰撞机', '反重力装置', '熔岩药瓶', '暴炎加热炉']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data8)), skills=['冰霜钻孔车']),
+    ]
 
 # 超级棒棒糖
 # mage_female/witch/9bc30e0f6e22b0333762d04acae7d252
@@ -2750,7 +2806,11 @@ class Skill53(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 冰霜云冰冻持续时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 糖果大作战 : 捣蛋杰克
 # mage_female/witch/fa7f1a3dc90600456cbe010e5714bef3

backend/core/character/GF/mage_male/blood_mage.py

@@ -1,6 +1,14 @@
 # a5ccbaf5538981c6ef99b236c0a60b73
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "mage_male/blood_mage/cn/skillDetail"
 
@@ -584,7 +592,12 @@ class Skill18(PassiveSkill):
     # [猩红气息不足时]
     # 消耗生命值比率 : 猩红气息消耗量的{value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{'data': data2, 'type': '$*PAtkP'}, {'data': data3, 'type': '*cdReduce', 'skills': ['血翼突击', '鲜血长枪', '猩红狩猎', '狱血之牙', '绯红之狱', '隐行之噬', '血翼绽放', '死亡之握', '血翼蔽空']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2, 'type': '$*PAtkP'}, {'data': data3, 'type': '*cdReduce', 'skills': ['血翼突击', '鲜血长枪', '猩红狩猎', '狱血之牙', '绯红之狱', '隐行之噬', '血翼绽放', '死亡之握', '血翼蔽空']}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data2))),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data3)), skills=['血翼突击', '鲜血长枪', '猩红狩猎', '狱血之牙', '绯红之狱', '隐行之噬', '血翼绽放', '死亡之握', '血翼蔽空']),
+    ]
 
 # 鲜血之誓
 # mage_male/blood_mage/8b08f9504167a9c0f3a1d29d71b7943e
@@ -738,7 +751,11 @@ class Skill23(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 血蝠之舞
 # mage_male/blood_mage/c91a62dc0a18360acf5031ac0ebf09f5
@@ -1128,7 +1145,11 @@ class Skill32(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 伯爵之歌
 # mage_male/blood_mage/0e409ac3e1c1f3976b3ef2bfe4c13069
@@ -1376,7 +1397,11 @@ class Skill37(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 猩红气息吸收量与生命值恢复量比率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 死亡之握
 # mage_male/blood_mage/dd32a9825ec1af42a91f2223be6658e5
@@ -1506,7 +1531,11 @@ class Skill40(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # [狱血之牙]探索范围 : {value3}px
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 血翼蔽空
 # mage_male/blood_mage/6d7c9a15c08cc41d70125083e869e1a1

backend/core/character/GF/mage_male/dimension_walker.py

@@ -1,6 +1,16 @@
 # a5ccbaf5538981c6ef99b236c0a60b73
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "mage_male/dimension_walker/cn/skillDetail"
 
@@ -266,7 +276,11 @@ class Skill8(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['乖离 : 禁忌之奈雅丽']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['乖离 : 禁忌之奈雅丽']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['乖离 : 禁忌之奈雅丽']),
+    ]
 
 # 受身蹲伏
 # mage_male/dimension_walker/ce26c6b69d02a440a81b552bec94f03b
@@ -682,8 +696,12 @@ class Skill21(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 迷雾附着敌人时，基本攻击和次元系列技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data1, 'skills': ['次元 : 坠落', '次元 : 虚影', '次元 : 跃迁', '次元 : 离子束', '次元 : 万花镜', '次元 : 粒子风暴', '次元 : 时空磁场', '次元 : 粒子波', '次元 : 思维聚爆', '次元 : 奇点', '禁断之盛宴', '未明·次元崩坏', '乖离 : 禁忌之奈雅丽']},
+    # ]
     associate = [
-        {'data': data1, 'skills': ['次元 : 坠落', '次元 : 虚影', '次元 : 跃迁', '次元 : 离子束', '次元 : 万花镜', '次元 : 粒子风暴', '次元 : 时空磁场', '次元 : 粒子波', '次元 : 思维聚爆', '次元 : 奇点', '禁断之盛宴', '未明·次元崩坏', '乖离 : 禁忌之奈雅丽']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['次元 : 坠落', '次元 : 虚影', '次元 : 跃迁', '次元 : 离子束', '次元 : 万花镜', '次元 : 粒子风暴', '次元 : 时空磁场', '次元 : 粒子波', '次元 : 思维聚爆', '次元 : 奇点', '禁断之盛宴', '未明·次元崩坏', '乖离 : 禁忌之奈雅丽']),
     ]
 
 # 次元扭曲装置
@@ -716,7 +734,11 @@ class Skill22(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 施放速度增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 次元 : 虚影
 # mage_male/dimension_walker/1812a1ece67bb37b6b44b54766450064
@@ -852,7 +874,11 @@ class Skill25(ActiveSkill):
     # 重叠次数上限 : {value8}次
     data8 = get_data(f'{prefix}/{uuid}', 8)
 
-    associate = [{'data': data4, 'type': '$*PAtkI'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data4, 'type': '$*PAtkI'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_I, value=1 + Percent(LevelTable(data4))),
+    ]
 
     def getSkillCD(self, mode=None):
         return 0.75
@@ -1489,7 +1515,11 @@ class Skill38(PassiveSkill):
     # 暴击伤害增加率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{'data': data6}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data6}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data6))),
+    ]
 
 # 乖离 : 扭曲之恐惧
 # mage_male/dimension_walker/9dc8438e4572d39243c97da31c113acc
@@ -1642,10 +1672,14 @@ class Skill41(ActiveSkill):
     # 刺击距离比率 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillDamage', 'data': [0] + [-14] * self.maxLv, 'skills': ['乖离 : 魅魔之舞']}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillDamage', 'data': [0] + [-14] * self.maxLv, 'skills': ['乖离 : 魅魔之舞']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-14] * maxLv)), skills=['乖离 : 魅魔之舞'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
     def vp_1(self):
         """
@@ -1713,7 +1747,11 @@ class Skill42(PassiveSkill):
     data4 = get_data(f'{prefix}/{uuid}', 4)
     # 转职技能命中敌人时，奈雅丽攻击速度增加量 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
-    associate = [{'data': data4}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data4}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4))),
+    ]
 
 # 次元 : 奇点
 # mage_male/dimension_walker/4402c6977bf5c9b0d2febe14dc81de6c
@@ -1993,7 +2031,11 @@ class Skill46(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 首次施放[时空壁障]时，波动数增加量 : {value1}
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 乖离 : 边缘之兽
 # mage_male/dimension_walker/626cfc24770b72b5d7a24c24cda3768b

backend/core/character/GF/mage_male/elemental_bomber.py

@@ -1,6 +1,14 @@
 # a5ccbaf5538981c6ef99b236c0a60b73
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "mage_male/elemental_bomber/cn/skillDetail"
 
@@ -509,9 +517,14 @@ class Skill16(ActiveSkill):
     # 光属性攻击力 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data1, 'type': '+power1', 'skills': ['魔球连射']},
+    #     {'data': data1, 'type': '+power0', 'skills': ['元素炮']},
+    # ]
     associate = [
-        {'data': data1, 'type': '+power1', 'skills': ['魔球连射']},
+        SkillEffect(attribute=Power(1), operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['魔球连射']),
-        {'data': data1, 'type': '+power0', 'skills': ['元素炮']},
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['元素炮']),
     ]
 
 # 冰魄剑
@@ -608,7 +621,11 @@ class Skill19(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 属性攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 冰晶坠
 # mage_male/elemental_bomber/0969cd4054d93da07708108c0cc1c4b5
@@ -673,8 +690,12 @@ class Skill21(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 每个[元素之力]增加的[元素炮]大小增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': [i * 5 for i in data1], 'skills': ['元素炮']},
+    # ]
     associate = [
-        {'data': [i * 5 for i in data1], 'skills': ['元素炮']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * 5 for i in data1])), skills=['元素炮']),
     ]
 
 # 暴击
@@ -762,7 +783,11 @@ class Skill24(ActiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 属性攻击力增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data3}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
+    ]
 
 # 魔力燃烧
 # mage_male/elemental_bomber/9bff7f2559e003766fee2853dca00631
@@ -820,7 +845,11 @@ class Skill26(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 转职技能冷却时间减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data1, 'type': '*cdReduce', 'exceptSkills': ['幻魔四重奏', '末日湮灭', '启源·微观宇宙']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'type': '*cdReduce', 'exceptSkills': ['幻魔四重奏', '末日湮灭', '启源·微观宇宙']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=['幻魔四重奏', '末日湮灭', '启源·微观宇宙']),
+    ]
     # [可强制中断的技能列表]
     # 掌握技能等级1时 : [元素炮]、 [冰晶坠]、 [地炎]
     # 掌握技能等级2时 : [暗域扩张]、 [雷光链]
@@ -919,7 +948,11 @@ class Skill29(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 命中率增加量 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 旋炎破
 # mage_male/elemental_bomber/45442bbbe33540b4deeec29437dae70c
@@ -1246,7 +1279,11 @@ class Skill35(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 魔法暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 幻魔四重奏
 # mage_male/elemental_bomber/c27418ae613c647527200a7ca17d97fd
@@ -1436,7 +1473,11 @@ class Skill39(PassiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
     # [旋炎破]范围增加 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 元素禁域
 # mage_male/elemental_bomber/f0cc2c950f3bdf4103c75fa496bcac34
@@ -1630,7 +1671,11 @@ class Skill43(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [雷光链]雷光球爆炸攻击力 : 总攻击力的{value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 聚魔轰击
 # mage_male/elemental_bomber/9767a375672d9519f6c1c5dff19b7c15

backend/core/character/GF/mage_male/glacial_master.py

@@ -1,6 +1,17 @@
 # a5ccbaf5538981c6ef99b236c0a60b73
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Hit,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "mage_male/glacial_master/cn/skillDetail"
 
@@ -553,7 +564,11 @@ class Skill18(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 寒冰连枪
 # mage_male/glacial_master/ade01c1d6afc8a05055225045e89fe49
@@ -663,7 +678,11 @@ class Skill21(ActiveSkill):
     data6 = get_data(f'{prefix}/{uuid}', 6)
     # 减速移动速度减少 : {value7}%
     data7 = get_data(f'{prefix}/{uuid}', 7)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 冰之领悟
 # mage_male/glacial_master/ff171dc487807bb9aa28900ca9a46b41
@@ -694,7 +713,11 @@ class Skill22(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 命中率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'type': '$*PAtkM', 'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkM', 'data': data1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 冰魄旋枪
 # mage_male/glacial_master/547ab2b2bd860d3e37355a9cfbc1077c
@@ -872,9 +895,14 @@ class Skill27(PassiveSkill):
     # [冰魄剑]第1和第2击攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0, 'skills': ['冰魄剑']},
+    #     {'type': '+hit1', 'data': [0] + [-1] * maxLv, 'skills': ['冰魄剑'], 'ratio': 1},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0, 'skills': ['冰魄剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['冰魄剑']),
-        {'type': '+hit1', 'data': [0] + [-1] * maxLv, 'skills': ['冰魄剑'], 'ratio': 1},
+        SkillEffect(attribute=Hit(1), operation=Operation.ADD, value=LevelTable([0] + [-1] * maxLv), skills=['冰魄剑']),
     ]
 
 # 冰魄锤击
@@ -1174,11 +1202,18 @@ class Skill32(PassiveSkill):
     # 冲击波攻击力 : [极冰绽放]倒下的冰柱攻击力的{value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*power1', 'data': [i - 100 if i > 0 else i for i in data0], 'skills': ['极冰绽放']},
+    #     {'type': '+hit1', 'data': [0, -1], 'skills': ['极冰绽放'], 'ratio': 1},
+    #     {'type': '*power3', 'data': [i - 100 if i > 0 else i for i in data1], 'skills': ['极冰绽放']},
+    #     {'type': '+hit4', 'data': [0, -1], 'skills': ['极冰绽放'], 'ratio': 1},
+    # ]
     associate = [
-        {'type': '*power1', 'data': [i - 100 if i > 0 else i for i in data0], 'skills': ['极冰绽放']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable([i - 100 if i > 0 else i for i in data0])), skills=['极冰绽放']),
-        {'type': '+hit1', 'data': [0, -1], 'skills': ['极冰绽放'], 'ratio': 1},
+        SkillEffect(attribute=Hit(1), operation=Operation.ADD, value=LevelTable([0, -1]), skills=['极冰绽放']),
-        {'type': '*power3', 'data': [i - 100 if i > 0 else i for i in data1], 'skills': ['极冰绽放']},
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable([i - 100 if i > 0 else i for i in data1])), skills=['极冰绽放']),
-        {'type': '+hit4', 'data': [0, -1], 'skills': ['极冰绽放'], 'ratio': 1},
+        SkillEffect(attribute=Hit(4), operation=Operation.ADD, value=LevelTable([0, -1]), skills=['极冰绽放']),
     ]
 
 # 冰封奥义
@@ -1214,7 +1249,11 @@ class Skill33(PassiveSkill):
     # [范围信息]
     # 冰冻效果范围 : {value4}px
     data4 = get_data(f'{prefix}/{uuid}', 4)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 千旋冰轮破
 # mage_male/glacial_master/78be08a3f8c834d3b06fa20c6a08c5a5
@@ -1412,7 +1451,12 @@ class Skill37(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 冰枪爆炸攻击力占原技能攻击力百分比 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': data0}, {'type': '*skillDamage', 'data': data1, 'skills': ['冰魄剑', '寒冰连枪', '冰魄旋枪', '旋冰穿刺', '冰魄锤击', '极冰绽放', '碎冰破', '极冰猎魔斩']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}, {'type': '*skillDamage', 'data': data1, 'skills': ['冰魄剑', '寒冰连枪', '冰魄旋枪', '旋冰穿刺', '冰魄锤击', '极冰绽放', '碎冰破', '极冰猎魔斩']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['冰魄剑', '寒冰连枪', '冰魄旋枪', '旋冰穿刺', '冰魄锤击', '极冰绽放', '碎冰破', '极冰猎魔斩']),
+    ]
 
 # 碎冰破
 # mage_male/glacial_master/de3fea2d65c597f4d55c70a02b97fc79
@@ -1605,7 +1649,11 @@ class Skill41(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [冰魄之弓]对弓箭未命中敌人的最后一击伤害增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 极冰猎魔斩
 # mage_male/glacial_master/9f57da5cb3651d81ca7dc9f78be33d01

backend/core/character/GF/mage_male/swift_master.py

@@ -1,6 +1,14 @@
 # a5ccbaf5538981c6ef99b236c0a60b73
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "mage_male/swift_master/cn/skillDetail"
 
@@ -636,9 +644,14 @@ class Skill20(PassiveSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
     # 攻击速度增加 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0, 'type': '$*PAtkP'},
+    #     {'data': data3, 'type': '*cdReduce', 'exceptSkills': ['万象风龙阵', '无限风域', '风之极·永坠']},
+    # ]
     associate = [
-        {'data': data0, 'type': '$*PAtkP'},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
-        {'data': data3, 'type': '*cdReduce', 'exceptSkills': ['万象风龙阵', '无限风域', '风之极·永坠']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data3)), except_skills=['万象风龙阵', '无限风域', '风之极·永坠']),
     ]
 
 # 流风诀
@@ -852,7 +865,11 @@ class Skill27(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 刃风
 # mage_male/swift_master/128b9ddef2262f40723deae4407bdb42
@@ -1113,7 +1130,11 @@ class Skill32(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 移动速度增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 万象风龙阵
 # mage_male/swift_master/0b8db1e10b3abbd24d38564e708675d5
@@ -1277,7 +1298,11 @@ class Skill36(PassiveSkill):
 
     # 追加伤害比率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 游龙惊风破
 # mage_male/swift_master/d110449993fb973f1a62c62c695003db
@@ -1455,7 +1480,11 @@ class Skill40(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 怒风狂涌
 # mage_male/swift_master/29c0b8b3eed7252b3bdcddc2b4e9e3a0

backend/core/character/GF/priest_female/crusader_female.py

@@ -1,6 +1,12 @@
 #0c1b401bb09241570d364420b3ba3fd7
 from core.basic.skill import PassiveBufferSkill,ActiveBufferSkill,ActiveSkill,PassiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+)
 prefix = "priest_female/crusader_female/cn/skillDetail"
 
 
@@ -636,7 +642,11 @@ class Skill21(PassiveBufferSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
     INT = data0
-    associate = [{"data":data0,"type":"$+INT","ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"type":"$+INT","ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(data0)),
+    ]
 
 # 光杖精通
 # priest_female/crusader_female/9cb6f9ed646fa87f9b7680a42ce83d1a
@@ -664,7 +674,11 @@ class Skill22(PassiveSkill):
     # [装备光杖时]
     # 施放速度增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{"data": data0, "type": "$*PATKI"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data0, "type": "$*PATKI"}]
+    associate = [
+        # 原角色字段 PATKI 未被旧引擎支持，原先不生效；本次迁移保留此行为。
+    ]
 
 # 胜利之矛
 # priest_female/crusader_female/3d8f3d438405d79f8d3ed68072674d1e
@@ -1422,8 +1436,12 @@ class Skill38(PassiveBufferSkill):
     STRINT = data0
     INT = data0
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":INT,"type":"$+INT","ratio":1}
+    # ]
     associate = [
-        {"data":INT,"type":"$+INT","ratio":1}
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(INT)),
     ]
 
 # 圣光天启
@@ -1679,8 +1697,12 @@ class Skill43(PassiveBufferSkill):
 
     INT = data0
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0 ,"type":"$+INT","ratio":1}
+    # ]
     associate = [
-        {"data":data0 ,"type":"$+INT","ratio":1}
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(data0)),
     ]
 
 # 圣佑之阵
@@ -1883,8 +1905,12 @@ class Skill47(PassiveBufferSkill):
 
     INT = data1
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data1,"type":"$+INT","ratio":1}
+    # ]
     associate = [
-        {"data":data1,"type":"$+INT","ratio":1}
+        CharacterEffect(attribute=CharacterAttribute.INT, operation=Operation.ADD, value=LevelTable(data1)),
     ]
 
 # 圣言十字

backend/core/character/GF/priest_female/infighter_female.py

@@ -1,6 +1,17 @@
 #0c1b401bb09241570d364420b3ba3fd7
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "priest_female/infighter_female/cn/skillDetail"
 
 
@@ -54,7 +65,11 @@ class Skill1(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['上勾拳','圣拳连击']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['上勾拳','圣拳连击']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['上勾拳', '圣拳连击']),
+    ]
 
 # 受身蹲伏
 # priest_female/infighter_female/ce26c6b69d02a440a81b552bec94f03b
@@ -457,7 +472,11 @@ class Skill15(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 圣拳连击
 # priest_female/infighter_female/87a918bb22cfc959a16e0bf939bb6c24
@@ -658,7 +677,11 @@ class Skill21(PassiveSkill):
     # 战意释放结束缓冲时间 : {value5}秒
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [ {"type":"*cdReduce","data":data0,"exceptSkills":['圣拳锤击','蓄劲轰拳','巨力炮拳','泯灭之怒','拳震八方','怒气贯地击','致命冲拳','炽拳 : 以暴制暴','意志之拳 : 与神同行']}]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"*cdReduce","data":data0,"exceptSkills":['圣拳锤击','蓄劲轰拳','巨力炮拳','泯灭之怒','拳震八方','怒气贯地击','致命冲拳','炽拳 : 以暴制暴','意志之拳 : 与神同行']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['圣拳锤击', '蓄劲轰拳', '巨力炮拳', '泯灭之怒', '拳震八方', '怒气贯地击', '致命冲拳', '炽拳 : 以暴制暴', '意志之拳 : 与神同行']),
+    ]
 
 # 圣拳锤击
 # priest_female/infighter_female/ca2536eb56df0e812c88c59cabd38be0
@@ -756,7 +779,11 @@ class Skill24(PassiveSkill):
     # 回避率增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [ {'type': '$*PAtkP', 'data': data0}, ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {'type': '$*PAtkP', 'data': data0}, ]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 神体合一
 # priest_female/infighter_female/c1dd8b776fb1dd24c6373c678ef1dd2e
@@ -1042,10 +1069,14 @@ class Skill30(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-16.7] * self.maxLv, 'skills': ['腹部重击']}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-16.7] * self.maxLv, 'skills': ['腹部重击']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-16.7] * maxLv)), skills=['腹部重击'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 巨力炮拳
 # priest_female/infighter_female/b860cbf5979b4bcc6beea725636b915e
@@ -1102,13 +1133,18 @@ class Skill31(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [
+    #     if self.vp == 2:
-                {'data': [0] + [100] * self.maxLv, 'skills': ['蓄劲轰拳']},
+    #         self.associate = [
-                {'type': '=cd','data': [25] + [50] * self.maxLv,'ratio': 1, 'skills': ['蓄劲轰拳']}
+    #             {'data': [0] + [100] * self.maxLv, 'skills': ['蓄劲轰拳']},
-            ]
+    #             {'type': '=cd','data': [25] + [50] * self.maxLv,'ratio': 1, 'skills': ['蓄劲轰拳']}
-        return super().effect(old, new)
+    #         ]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [100] * maxLv)), skills=['蓄劲轰拳'], when=Equals(Read(SkillAttribute.VP), 2)),
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ASSIGN, value=LevelTable([25] + [50] * maxLv), skills=['蓄劲轰拳'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 潜藏暴戾
 # priest_female/infighter_female/37cf7b7a269058dc02bef5b5bc9de282
@@ -1135,7 +1171,11 @@ class Skill32(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 泯灭之怒
 # priest_female/infighter_female/97972dba4694d6c0fcd2f7e8efb3a499
@@ -1302,10 +1342,14 @@ class Skill35(ActiveSkill):
         self.cd = 20
         self.skillRation *= 0.5
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillRation', 'data': [0] + [-28.6] * self.maxLv, 'skills': ['圣拳锤击']}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillRation', 'data': [0] + [-28.6] * self.maxLv, 'skills': ['圣拳锤击']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-28.6] * maxLv)), skills=['圣拳锤击'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
 # 斗志沸腾
 # priest_female/infighter_female/4e9e8942841b9767f683fb23c1ef1435
@@ -1330,7 +1374,11 @@ class Skill36(PassiveSkill):
     # 基本攻击力及转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 怒气贯地击
 # priest_female/infighter_female/ef896bbdc68660c22b6e60502044d690
@@ -1544,7 +1592,11 @@ class Skill40(PassiveSkill):
     # 敌人强制控制时间 : {value2}秒
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 圣光三重破
 # priest_female/infighter_female/f8226512ea3dbcb1fe1374baa0c6bbee

backend/core/character/GF/priest_female/inquistor.py

@@ -1,6 +1,14 @@
 # 0c1b401bb09241570d364420b3ba3fd7
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "priest_female/inquistor/cn/skillDetail"
 
@@ -111,7 +119,11 @@ class Skill3(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['神焰']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['神焰']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['神焰']),
+    ]
 
 # 受身蹲伏
 # priest_female/inquistor/ce26c6b69d02a440a81b552bec94f03b
@@ -629,7 +641,11 @@ class Skill20(PassiveSkill):
     # 命中率增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '$*PAtkP', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '$*PAtkP', 'data': data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 裁决之击
 # priest_female/inquistor/01384bbfc346775d1267fa0bc4ca605f
@@ -780,7 +796,12 @@ class Skill24(ActiveSkill):
     # 攻击范围比率 : {value8}%
     data8 = get_data(f'{prefix}/{uuid}', 8)
 
-    associate = [{'data': data1}, {'data': data4, 'exceptSkills': ['火焰精华']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1}, {'data': data4, 'exceptSkills': ['火焰精华']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), except_skills=['火焰精华']),
+    ]
 
 # 狂热信仰
 # priest_female/inquistor/e49e57b2e8fbeceb0a2c56a0c63fe6c5
@@ -1244,7 +1265,11 @@ class Skill34(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data1, 'type': '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'type': '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 火之净化
 # priest_female/inquistor/1fadde0eece18649caddbca7bd58cc2f
@@ -1439,7 +1464,13 @@ class Skill38(PassiveSkill):
     # [神焰]、 [火焰精华]技能冷却时间减少率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0, 'type': '*skillDamage', 'skills': ['火焰精华']}, {'data': data1, 'type': '*skillDamage', 'exceptSkills': ['火焰精华']}, {'data': data2, 'type': '*cdReduce', 'skills': ['神焰', '火焰精华']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage', 'skills': ['火焰精华']}, {'data': data1, 'type': '*skillDamage', 'exceptSkills': ['火焰精华']}, {'data': data2, 'type': '*cdReduce', 'skills': ['神焰', '火焰精华']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['火焰精华']),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), except_skills=['火焰精华']),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data2)), skills=['神焰', '火焰精华']),
+    ]
 
 # 裁决轮回斩
 # priest_female/inquistor/1812a1ece67bb37b6b44b54766450064
@@ -1642,7 +1673,12 @@ class Skill42(PassiveSkill):
     data4 = get_data(f'{prefix}/{uuid}', 4)
     # [审判重击]火焰地带持续时间 : 2秒
 
-    associate = [{'data': data0, 'type': '*skillDamage'}, {'data': [(i * j) for i, j in zip(data3, data4)], 'type': '*skillDamage', 'skills': ['审判重击']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '*skillDamage'}, {'data': [(i * j) for i, j in zip(data3, data4)], 'type': '*skillDamage', 'skills': ['审判重击']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * j for i, j in zip(data3, data4)])), skills=['审判重击']),
+    ]
     # [审判重击]火焰地带持续时间 : 2秒
 
 # 补赎逆十字

backend/core/character/GF/priest_female/mistress.py

@@ -1,6 +1,14 @@
 #0c1b401bb09241570d364420b3ba3fd7
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "priest_female/mistress/cn/skillDetail"
 
 
@@ -557,7 +565,11 @@ class Skill18(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 回避率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 负罪者镰刀精通
 # priest_female/mistress/ecc23c980ea71450c0ad0c3fd232f329
@@ -590,7 +602,11 @@ class Skill19(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 命中率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"type":"$*PAtkM","data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"$*PAtkM","data":data0}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 镰勾旋击
 # priest_female/mistress/f0cc2c950f3bdf4103c75fa496bcac34
@@ -764,8 +780,12 @@ class Skill22(ActiveSkill):
     # [暴食之噬] - 生命值恢复量增加率 : {value31}%
     data31 = get_data(f'{prefix}/{uuid}', 31)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data12,"skills":['欲望之手', '傲慢之堕', '怠惰之息', '贪婪之刺', '愤怒之袭', '嫉妒之吻', '暴食之噬']}
+    # ]
     associate = [
-        {"data":data12,"skills":['欲望之手', '傲慢之堕', '怠惰之息', '贪婪之刺', '愤怒之袭', '嫉妒之吻', '暴食之噬']}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data12)), skills=['欲望之手', '傲慢之堕', '怠惰之息', '贪婪之刺', '愤怒之袭', '嫉妒之吻', '暴食之噬']),
     ]
 
 # 暴击
@@ -1181,7 +1201,11 @@ class Skill31(PassiveSkill):
     # 魔法暴击率增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{"data":data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 原罪释放·净化
 # priest_female/mistress/a2d943797daca862a6f321aca6ac9bfa
@@ -1428,7 +1452,11 @@ class Skill36(ActiveSkill):
     # [原罪释放·净化]冷却时间最大减少 : {value5}秒
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
     def getSkillCD(self, mode=None):
         return 2.0
@@ -1614,7 +1642,11 @@ class Skill40(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [怠惰之息] - 聚拢敌人速度和范围比率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 至高之刑
 # priest_female/mistress/8b08f9504167a9c0f3a1d29d71b7943e

backend/core/character/GF/priest_female/sorceress.py

@@ -1,6 +1,20 @@
 # 0c1b401bb09241570d364420b3ba3fd7
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Percent,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class SorceressAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    PEARL_CD_REDUCE = 'cdReduceP'
+    """巫女：神龙如意珠的专用冷却参数。"""
+
 
 prefix = "priest_female/sorceress/cn/skillDetail"
 
@@ -108,7 +122,11 @@ class Skill3(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['念珠连射']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['念珠连射']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['念珠连射']),
+    ]
 
 # 受身蹲伏
 # priest_female/sorceress/ce26c6b69d02a440a81b552bec94f03b
@@ -714,7 +732,11 @@ class Skill23(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 和合之玉
 # priest_female/sorceress/2a3c96b88d02372505692da0a8b54743
@@ -781,7 +803,11 @@ class Skill25(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 施放速度增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 聚魂吸星符
 # priest_female/sorceress/b163d099c8cc27fdb6fd3639c2ee6df9
@@ -1058,7 +1084,11 @@ class Skill30(ActiveSkill):
     # [范围信息]
     # 追加打击大小比率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
     def getSkillCD(self, mode=None):
         return self.cd * (1 - self.cdReduceP)
@@ -1258,10 +1288,16 @@ class Skill34(PassiveSkill):
     # 所受伤害减少效果冷却时间 : {value5}秒
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'data': data0},
+    #     {'data': data1, 'skills': ['念珠连射']},
+    #     {'data': data2, 'skills': ['神龙如意珠'], 'type': '*cdReduceP'},
+    # ]
     associate = [
-        {'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {'data': data1, 'skills': ['念珠连射']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['念珠连射']),
-        {'data': data2, 'skills': ['神龙如意珠'], 'type': '*cdReduceP'},
+        SkillEffect(attribute=SorceressAttribute.PEARL_CD_REDUCE, value=1 - Percent(LevelTable(data2)), skills=['神龙如意珠']),
     ]
 
 # 退魔阴阳符
@@ -1454,7 +1490,11 @@ class Skill38(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 天泽神龙阵
 # priest_female/sorceress/d429147c372b549c3dadcabcba50787f

backend/core/character/GF/priest_male/avenger.py

@@ -1,6 +1,16 @@
 #f6a4ad30555b99b499c07835f87ce522
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "priest_male/avenger/cn/skillDetail"
 
 
@@ -357,7 +367,12 @@ class Skill11(ActiveSkill):
     # [范围信息]
     # 手大小比率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{"data":data4,"skills":[name]},{"data":data5,"skills":[name],"type":"*cd"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data4,"skills":[name]},{"data":data5,"skills":[name],"type":"*cd"}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), skills=[name]),
+        SkillEffect(attribute=SkillAttribute.CD, value=1 + Percent(LevelTable(data5)), skills=[name]),
+    ]
 
 # 强化 - 后跳
 # priest_male/avenger/2b340542e776818b78f3212af184bd6b
@@ -572,7 +587,12 @@ class Skill17(ActiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 冷却时间增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"data":data2,"skills":[name]},{"data":data3,"skills":[name],"type":"*cd"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data2,"skills":[name]},{"data":data3,"skills":[name],"type":"*cd"}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), skills=[name]),
+        SkillEffect(attribute=SkillAttribute.CD, value=1 + Percent(LevelTable(data3)), skills=[name]),
+    ]
 
 # 半魔化
 # priest_male/avenger/5c00ce6d7dbbb5e9a0f6e1071d486832
@@ -683,7 +703,11 @@ class Skill20(PassiveSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
     # 光属性抗性减少 : {value4}
     data4 = get_data(f'{prefix}/{uuid}', 4)
-    associate = [{"data":data0,"type":"$*PAtkM"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"type":"$*PAtkM"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 裂地锤
 # priest_male/avenger/0c3a468aee1f7ce06bf91eb3319518c1
@@ -719,7 +743,11 @@ class Skill21(ActiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 冷却时间增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"data":data3,"skills":[name],"type":"*cd"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data3,"skills":[name],"type":"*cd"}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD, value=1 + Percent(LevelTable(data3)), skills=[name]),
+    ]
 
 # 暴击
 # priest_male/avenger/fc1262c19f3d0477ee8eda47b8db8696
@@ -791,7 +819,12 @@ class Skill23(ActiveSkill):
     # [范围信息]
     # [魔化 ： 末日守卫者]状态下，攻击范围比率 : {value10}%
     data10 = get_data(f'{prefix}/{uuid}', 10)
-    associate = [{"data":data8,"skills":[name]},{"data":data9,"skills":[name],"type":"*cd"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data8,"skills":[name]},{"data":data9,"skills":[name],"type":"*cd"}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data8)), skills=[name]),
+        SkillEffect(attribute=SkillAttribute.CD, value=1 + Percent(LevelTable(data9)), skills=[name]),
+    ]
 
 # 堕落之魂
 # priest_male/avenger/527cdc3ecca985e18ef819d456532b26
@@ -863,7 +896,11 @@ class Skill25(ActiveSkill):
     # [范围信息]
     # 大小比率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{"data":data3,"skills":[name],"type":"*cd"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data3,"skills":[name],"type":"*cd"}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD, value=1 + Percent(LevelTable(data3)), skills=[name]),
+    ]
 
 # 恶魔诅咒
 # priest_male/avenger/002cbdd9bfd0f0b970451ae8d48d029e
@@ -894,7 +931,11 @@ class Skill26(PassiveSkill):
     # [恶魔诅咒]持续时间 : {value3}秒
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{"data":data0,"exceptSkills":["魔化 : 末日守卫者"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"exceptSkills":["魔化 : 末日守卫者"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), except_skills=['魔化 : 末日守卫者']),
+    ]
 
 # 厄运之轮
 # priest_male/avenger/ac21c02567f04a92b54dd85c091d1e5a
@@ -944,7 +985,12 @@ class Skill27(ActiveSkill):
     # [魔化 ： 末日守卫者]状态下攻击范围比率 : {value8}%
     data8 = get_data(f'{prefix}/{uuid}', 8)
 
-    associate = [{"data":data3,"skills":[name]},{"data":data4,"skills":[name],"type":"*cd"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data3,"skills":[name]},{"data":data4,"skills":[name],"type":"*cd"}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), skills=[name]),
+        SkillEffect(attribute=SkillAttribute.CD, value=1 + Percent(LevelTable(data4)), skills=[name]),
+    ]
 
     def vp_1(self):
         """
@@ -1221,11 +1267,17 @@ class Skill31(PassiveSkill):
     # 技能攻击力增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data1,"skills":["魔化 : 末日守卫者"]},
+    #     {"data":data2,"skills":["审判"]},
+    #     {"data":data3,"exceptSkills":["审判","魔化 : 末日守卫者"]},
+    #     ]
     associate = [
-        {"data":data1,"skills":["魔化 : 末日守卫者"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['魔化 : 末日守卫者']),
-        {"data":data2,"skills":["审判"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), skills=['审判']),
-        {"data":data3,"exceptSkills":["审判","魔化 : 末日守卫者"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), except_skills=['审判', '魔化 : 末日守卫者']),
-        ]
+    ]
 
 # 魔化 : 末日守卫者
 # priest_male/avenger/5cac3411ccef1af333953e0ded5e942d
@@ -1303,7 +1355,11 @@ class Skill32(ActiveSkill):
 
     mode = ["x","z","z蓄力"]
 
-    associate = [{"data":data4,"type":"$*PAtkM"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data4,"type":"$*PAtkM"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data4))),
+    ]
 
     def setMode(self, mode):
         if mode == "x":
@@ -1381,7 +1437,11 @@ class Skill33(ActiveSkill):
     data11 = get_data(f'{prefix}/{uuid}', 11)
     data12 = get_data(f'{prefix}/{uuid}', 12)
 
-    associate = [{"data": [0] + [10]*maxLv,"skills":[name]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": [0] + [10]*maxLv,"skills":[name]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [10] * maxLv)), skills=[name]),
+    ]
 
     level_source = '魔化 : 末日守卫者'
 
@@ -1475,7 +1535,11 @@ class Skill36(ActiveSkill):
     # [范围信息]
     # 发射距离比率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"data":data2,"skills":[name]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data2,"skills":[name]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), skills=[name]),
+    ]
 
     def vp_1(self):
         """
@@ -1531,7 +1595,11 @@ class Skill37(ActiveSkill):
     # 冲击波范围比率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{"data":data1,"skills":[name]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1,"skills":[name]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=[name]),
+    ]
 
     def vp_1(self):
         """
@@ -1667,10 +1735,15 @@ class Skill39(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 基本攻击和除[恶魔之力]外所有技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data1,"exceptSkills":["恶魔之力"]},
+    #     {"data":data0,"skills":["恶魔之力"]}
+    #     ]
     associate = [
-        {"data":data1,"exceptSkills":["恶魔之力"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), except_skills=['恶魔之力']),
-        {"data":data0,"skills":["恶魔之力"]}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), skills=['恶魔之力']),
-        ]
+    ]
 
 # 毁灭强击
 # priest_male/avenger/b1732acfaf117f8e9ff130f47d3ed0e7
@@ -1724,7 +1797,11 @@ class Skill40(ActiveSkill):
     # 爆炸大小比率 : {value7}%
     data7 = get_data(f'{prefix}/{uuid}', 7)
 
-    associate = [{"data":data6,"skills":[name]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data6,"skills":[name]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data6)), skills=[name]),
+    ]
 
     def vp_1(self):
         """
@@ -1799,7 +1876,12 @@ class Skill41(ActiveSkill):
     # - [半魔化状态下] -
     # 恶魔能量消耗量减少 : 100%
 
-    associate = [{"data":data9,"skills":[name]},{"data":data7,"skills":[name],"type":"+power5"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data9,"skills":[name]},{"data":data7,"skills":[name],"type":"+power5"}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data9)), skills=[name]),
+        SkillEffect(attribute=Power(5), operation=Operation.ADD, value=Percent(LevelTable(data7)), skills=[name]),
+    ]
     # - [半魔化状态下] -
     # 恶魔能量消耗量减少 : 100%
 
@@ -1838,7 +1920,11 @@ class Skill42(PassiveSkill):
     # [回旋飞镰]镰刀回收最大攻击数 : {value5}次
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 极恶洪流
 # priest_male/avenger/7f9ffcd296361f1367b8b74e773d5e99
@@ -1881,7 +1967,12 @@ class Skill43(ActiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
     # [半魔化]状态下施放时
     # 恶魔能量消耗量减少 : 100%
-    associate = [{"data":data5,"skills":[name]},{"data":data4,"skills":[name]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data5,"skills":[name]},{"data":data4,"skills":[name]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data5)), skills=[name]),
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), skills=[name]),
+    ]
     # [半魔化]状态下施放时
     # 恶魔能量消耗量减少 : 100%
 
@@ -1930,7 +2021,11 @@ class Skill44(ActiveSkill):
     # 压制力 (4人队伍) : {value5}秒 ({value6}秒)
     data5 = get_data(f'{prefix}/{uuid}', 5)
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{"data":data4,"skills":[name]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data4,"skills":[name]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), skills=[name]),
+    ]
 
 class classChange(Character):
     def __init__(self, equVersion):

backend/core/character/GF/priest_male/crusader_male.py

@@ -1,6 +1,14 @@
 #f6a4ad30555b99b499c07835f87ce522
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data, ActiveBufferSkill, PassiveBufferSkill
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Constant,
+    LevelTable,
+    Operation,
+    Percent,
+)
 prefix = "priest_male/crusader_male/cn/skillDetail"
 
 
@@ -538,9 +546,14 @@ class Skill17(PassiveBufferSkill):
     Vitality = data0
     Spirit = data1
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"$+Vitality","ratio":1},
+    #     {"data":data1,"type":"$+Spirit","ratio":1}
+    # ]
     associate = [
-        {"data":data0,"type":"$+Vitality","ratio":1},
+        CharacterEffect(attribute=CharacterAttribute.VITALITY, operation=Operation.ADD, value=LevelTable(data0)),
-        {"data":data1,"type":"$+Spirit","ratio":1}
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=LevelTable(data1)),
     ]
     CarryRatio = [0]+[(1.055 ** 3) * 100 - 100]*maxLv# noqa: E501
 
@@ -781,7 +794,12 @@ class Skill23(ActiveBufferSkill):
     Vitality = data3
     Spirit = data4
 
-    associate = [{"type":"$+Vitality","value":data3,"ratio":1},{"type":"$+Spirit","value":data4,"ratio":1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"$+Vitality","value":data3,"ratio":1},{"type":"$+Spirit","value":data4,"ratio":1}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.VITALITY, operation=Operation.ADD, value=Constant(0)),
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=Constant(0)),
+    ]
 
 # 圣光守护
 # priest_male/crusader_male/ff171dc487807bb9aa28900ca9a46b41
@@ -1758,7 +1776,12 @@ class Skill44(ActiveBufferSkill):
     Vitality = data0
     Spirit = data0
 
-    associate = [{"data": Vitality, "type": "$+Vitality"}, {"data": Spirit, "type": "$+Spirit"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": Vitality, "type": "$+Vitality"}, {"data": Spirit, "type": "$+Spirit"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.VITALITY, operation=Operation.ADD, value=Percent(LevelTable(Vitality))),
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=Percent(LevelTable(Spirit))),
+    ]
 
     def vp_1(self):
         """
@@ -2004,7 +2027,12 @@ class Skill49(PassiveBufferSkill):
 
     Vitality = Spirit = data1
 
-    associate = [{"data": Vitality, "type": "$+Vitality"}, {"data": Spirit, "type": "$+Spirit"}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": Vitality, "type": "$+Vitality"}, {"data": Spirit, "type": "$+Spirit"}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.VITALITY, operation=Operation.ADD, value=Percent(LevelTable(Vitality))),
+        CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=Percent(LevelTable(Spirit))),
+    ]
 
 # 生命礼赞 : 神威
 # priest_male/crusader_male/a81e5b7defa1819263ed8e86f69fd06f

backend/core/character/GF/priest_male/crusader_male_carry.py

@@ -1,6 +1,13 @@
 #f6a4ad30555b99b499c07835f87ce522
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Percent,
+    Power,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "priest_male/crusader_male/cn/skillDetail"
 
 # 空斩打
@@ -128,13 +135,22 @@ class Skill4(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['空斩打', '光之正义']},
+    #     {'type': '*power2', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+    #     {'type': '*power3', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+    #     {'type': '*power4', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+    #     {'type': '*power6', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+    #     {'type': '*power7', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']}
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['空斩打', '光之正义']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['空斩打', '光之正义']),
-        {'type': '*power2', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['惩罚之锤']),
-        {'type': '*power3', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['惩罚之锤']),
-        {'type': '*power4', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+        SkillEffect(attribute=Power(4), value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['惩罚之锤']),
-        {'type': '*power6', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']},
+        SkillEffect(attribute=Power(6), value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['惩罚之锤']),
-        {'type': '*power7', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['惩罚之锤']}
+        SkillEffect(attribute=Power(7), value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['惩罚之锤']),
     ]
 
 
@@ -265,7 +281,11 @@ class Skill16(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 
 
@@ -359,7 +379,11 @@ class Skill19(PassiveSkill):
     # 队员魔法值恢复量 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
     
-    associate = [{'data': data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 胜利之矛
 # priest_male/crusader_male/8510294202d0e042dd29a2422fc6770d
@@ -601,7 +625,11 @@ class Skill30(PassiveSkill):
     # 魔法暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 圣光球
 # priest_male/crusader_male/9bff7f2559e003766fee2853dca00631
@@ -748,7 +776,11 @@ class Skill32(PassiveSkill):
     # 眩晕范围 : {value4}px
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{'data': [0, 92.5 - 100], 'skills': ['圣光球']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': [0, 92.5 - 100], 'skills': ['圣光球']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0, 92.5 - 100])), skills=['圣光球']),
+    ]
 
 # 圣光聚合
 # priest_male/crusader_male/dacd5c2848a1eb33489e5471f1a73759
@@ -1116,7 +1148,11 @@ class Skill38(PassiveSkill):
     # 光环范围 : {value5}px
     data5 = get_data(f'{prefix}/{uuid}', 5)
     
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 天启之光
 # priest_male/crusader_male/dcb31a63ef58954f44ff2070c42a9a98
@@ -1622,7 +1658,11 @@ class Skill45(ActiveSkill):
     # [雷霆粉碎]冲击波攻击力 : {value9}
     data9 = get_data(f'{prefix}/{uuid}', 9)
 
-    associate = [{'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
     mode = ["平X一轮","空斩打","落凤锤"]
 
@@ -1822,7 +1862,11 @@ class Skill49(PassiveSkill):
     # 矛的大小额外增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 生命礼赞 : 神威
 # priest_male/crusader_male/a81e5b7defa1819263ed8e86f69fd06f

backend/core/character/GF/priest_male/exorcist.py

@@ -2,6 +2,16 @@
 from core.basic.formula import 武器冷却惩罚
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "priest_male/exorcist/cn/skillDetail"
 
@@ -134,7 +144,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['空斩打', '疾风打']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['空斩打', '疾风打']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['空斩打', '疾风打']),
+    ]
 
 # 受身蹲伏
 # priest_male/exorcist/ce26c6b69d02a440a81b552bec94f03b
@@ -712,7 +726,11 @@ class Skill22(PassiveSkill):
     # 物理、 魔法攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data1, 'type': '$*PAtkP'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'type': '$*PAtkP'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 升天阵
 # priest_male/exorcist/b89c9ab317bc0a443f6497b7cca2f6a8
@@ -908,7 +926,12 @@ class Skill28(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 冷却时间减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0}, {'data': data1, 'type': '*cdReduce', 'exceptSkills': ['四座千泰门', '真龙焚天', '雷鸣怒海·火啸山崩']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}, {'data': data1, 'type': '*cdReduce', 'exceptSkills': ['四座千泰门', '真龙焚天', '雷鸣怒海·火啸山崩']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=['四座千泰门', '真龙焚天', '雷鸣怒海·火啸山崩']),
+    ]
 
 # 式神 : 空之白虎
 # priest_male/exorcist/0ed3148658fe37b3336ccb718dc0fdb0
@@ -1096,13 +1119,18 @@ class Skill31(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [
+    #     if self.vp == 2:
-                {'type': '*skillRation', 'data': [0] + [150] * self.maxLv, 'skills': ['式神 : 热炎朱雀']},
+    #         self.associate = [
-                {'type': '*cdReduce', 'data': [0] + [-150] * self.maxLv, 'skills': ['式神 : 热炎朱雀']},
+    #             {'type': '*skillRation', 'data': [0] + [150] * self.maxLv, 'skills': ['式神 : 热炎朱雀']},
-            ]
+    #             {'type': '*cdReduce', 'data': [0] + [-150] * self.maxLv, 'skills': ['式神 : 热炎朱雀']},
-        return super().effect(old, new)
+    #         ]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [150] * maxLv)), skills=['式神 : 热炎朱雀'], when=Equals(Read(SkillAttribute.VP), 2)),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable([0] + [-150] * maxLv)), skills=['式神 : 热炎朱雀'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 无双击
 # priest_male/exorcist/d53301bb328baf12a3ae482cc6a565dd
@@ -1180,7 +1208,11 @@ class Skill33(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 四座千泰门
 # priest_male/exorcist/5892d1fa4462e561ac8f8d2c74892b0a
@@ -1362,7 +1394,11 @@ class Skill37(PassiveSkill):
     # 驱魔师和队友所有速度增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 式神之力
 # priest_male/exorcist/328867949b763ce73e243da84fd59157
@@ -1389,7 +1425,11 @@ class Skill38(PassiveSkill):
     # 暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 逆龙七杀
 # priest_male/exorcist/5197b141332a65a89d452adf227c2f30
@@ -1585,7 +1625,11 @@ class Skill42(PassiveSkill):
     # 共鸣填充冷却时间 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 式神灭却·合
 # priest_male/exorcist/3153ca0e6752a6283412c59c5ec8e002

backend/core/character/GF/priest_male/infighter.py

@@ -1,6 +1,14 @@
 #f6a4ad30555b99b499c07835f87ce522
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "priest_male/infighter/cn/skillDetail"
 
 
@@ -599,7 +607,12 @@ class Skill18(ActiveSkill):
     # 离开[意念驱动]范围后增益效果持续时间 : {value6}秒
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
-    associate = [{"data":data2},{"data":data5,"type":"*cdReduce","exceptSkills":["泯灭神击","制裁 : 怒火疾风","正义执行 : 雷米迪奥斯的圣座"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data2},{"data":data5,"type":"*cdReduce","exceptSkills":["泯灭神击","制裁 : 怒火疾风","正义执行 : 雷米迪奥斯的圣座"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data5)), except_skills=['泯灭神击', '制裁 : 怒火疾风', '正义执行 : 雷米迪奥斯的圣座']),
+    ]
 
 # 百炼成刚
 # priest_male/infighter/da6e37c1e3f0e8867f70007d89c239ff
@@ -744,14 +757,23 @@ class Skill22(PassiveSkill):
     data15 = get_data(f'{prefix}/{uuid}', 15)
     data16 = get_data(f'{prefix}/{uuid}', 16)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0},
+    #     {"data":[i*j for i,j in zip(data9,data10)],"skills":["俯冲直拳"]},
+    #     {"data":[i*j for i,j in zip(data11,data12)],"skills":["俯冲腹拳"]},
+    #     {"data":[i*j for i,j in zip(data13,data14)],"skills":["俯冲翔拳"]},
+    #     {"data":[i*j for i,j in zip(data15,data16)],"skills":["圣拳连击"]},
+    #     {"data":data6,type:"=preRatio", "skills":["神圣反击"]},
+    #     ]
     associate = [
-        {"data":data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {"data":[i*j for i,j in zip(data9,data10)],"skills":["俯冲直拳"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * j for i, j in zip(data9, data10)])), skills=['俯冲直拳']),
-        {"data":[i*j for i,j in zip(data11,data12)],"skills":["俯冲腹拳"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * j for i, j in zip(data11, data12)])), skills=['俯冲腹拳']),
-        {"data":[i*j for i,j in zip(data13,data14)],"skills":["俯冲翔拳"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * j for i, j in zip(data13, data14)])), skills=['俯冲翔拳']),
-        {"data":[i*j for i,j in zip(data15,data16)],"skills":["圣拳连击"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i * j for i, j in zip(data15, data16)])), skills=['圣拳连击']),
-        {"data":data6,type:"=preRatio", "skills":["神圣反击"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data6)), skills=['神圣反击']),
-        ]
+    ]
 
 # 俯冲腹拳
 # priest_male/infighter/c61f5a010370101402b05b21916c2071
@@ -1413,7 +1435,11 @@ class Skill38(PassiveSkill):
     # 攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 泯灭神击
 # priest_male/infighter/dbf8b30c7057032af0d68fcfa289fdae
@@ -1516,10 +1542,14 @@ class Skill40(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"data":[0]+[-28.5]*self.maxLv,"skills":["刺拳猛击"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"data":[0]+[-28.5]*self.maxLv,"skills":["刺拳猛击"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-28.5] * maxLv)), skills=['刺拳猛击'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 破坏之拳
 # priest_male/infighter/0fbb8de70002ad34f046c94c2cb3e863
@@ -1657,7 +1687,11 @@ class Skill43(PassiveSkill):
     # 命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 超重拳
 # priest_male/infighter/d204ec03a0aed2f20211fb6ccc48d46d
@@ -1785,7 +1819,11 @@ class Skill46(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 正义铁拳
 # priest_male/infighter/87a918bb22cfc959a16e0bf939bb6c24

backend/core/character/GF/swordman_female/dark_templar.py

@@ -1,6 +1,13 @@
 # 1645c45aabb008c98406b3a16447040d
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    MissingTargetPolicy,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "swordman_female/dark_templar/cn/skillDetail"
 
@@ -138,7 +145,11 @@ class Skill4(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['影刃']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['影刃']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['影刃'], missing_target=MissingTargetPolicy.SKIP),
+    ]
 
 # 受身蹲伏
 # swordman_female/dark_templar/ce26c6b69d02a440a81b552bec94f03b
@@ -604,7 +615,11 @@ class Skill20(PassiveSkill):
     # 转职技能攻击力增加率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{"data":data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
     # - [赋予烙印技能] -
     # [暗影穿刺]
     # [暗影劫戮]
@@ -794,7 +809,11 @@ class Skill26(PassiveSkill):
 
     # 转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 暗影禁锢
 # swordman_female/dark_templar/51a08fd0c90f0a5276cd552047fac93d
@@ -1184,7 +1203,11 @@ class Skill35(PassiveSkill):
     # [黑暗烙印]移动速度额外增加率 :  {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{"data":data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 末日狂战
 # swordman_female/dark_templar/b3659936a9a74c4ed6f7faf07cca1f9e
@@ -1414,7 +1437,11 @@ class Skill40(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
     # - [乌希尔骑士团辅佐技能] -
     # [令行禁止]
     # [暗影横扫]
@@ -1577,7 +1604,11 @@ class Skill44(PassiveSkill):
     # [魅影暗魂斩]幻影的剑气攻击力 : 剑气攻击力的{value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 审判日 : 净土救赎
 # swordman_female/dark_templar/0e3da11226dd30c2aaef52e36eff7f3f

backend/core/character/GF/swordman_female/demon_slayer.py

@@ -1,6 +1,17 @@
 #1645c45aabb008c98406b3a16447040d
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    Hit,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "swordman_female/demon_slayer/cn/skillDetail"
 
 
@@ -540,8 +551,12 @@ class Skill18(PassiveSkill):
     # 出血持续时间 : {value5}秒
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data2,"type":"*skillDamage"}
+    # ]
     associate = [
-        {"data":data2,"type":"*skillDamage"}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
     ]
 
 # 蛇腹剑 : 破
@@ -774,8 +789,12 @@ class Skill25(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*skillDamage"}
+    # ]
     associate = [
-        {"data":data0,"type":"*skillDamage"}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 蛇腹剑 : 灭
@@ -876,10 +895,14 @@ class Skill27(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{"type":"*skillRation","data":[0] + [-11]*self.maxLv,"skills":["蛇腹剑 : 破"]}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{"type":"*skillRation","data":[0] + [-11]*self.maxLv,"skills":["蛇腹剑 : 破"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-11] * maxLv)), skills=['蛇腹剑 : 破'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
 # 魔刃狂舞
 # swordman_female/demon_slayer/1fadde0eece18649caddbca7bd58cc2f
@@ -1119,8 +1142,12 @@ class Skill31(PassiveSkill):
     # 效果叠加上限 : {value4}次
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data2,"type":"*skillDamage"}
+    # ]
     associate = [
-        {"data":data2,"type":"*skillDamage"}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
     ]
 
 # 空绝斩 : 千刃
@@ -1343,10 +1370,14 @@ class Skill35(ActiveSkill):
         self.skillRation *= 0.5
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{"type":"*skillDamage","data":[0] + [-11]*self.maxLv,"skills":["蛇腹剑 : 舞"]}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{"type":"*skillDamage","data":[0] + [-11]*self.maxLv,"skills":["蛇腹剑 : 舞"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-11] * maxLv)), skills=['蛇腹剑 : 舞'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
 # 唤魔 : 弑神剑
 # swordman_female/demon_slayer/d429147c372b549c3dadcabcba50787f
@@ -1399,14 +1430,24 @@ class Skill36(PassiveSkill):
     # 塔莫斯最终一击攻击力增加率 : {value5}%
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*skillDamage","exceptSkills":["魔刃狂舞","蛇腹剑 : 缠","唤魔 : 塔莫斯之袭"]},
+    #     {"data":data1,"type":"+power8","skills":["蛇腹剑 : 缠"]},
+    #     {"data":data1,"type":"+power9","skills":["蛇腹剑 : 缠"]},
+    #     {"data":data3,"type":"+power4","skills":["魔刃狂舞"]},
+    #     {"data":data3,"type":"+power5","skills":["魔刃狂舞"]},
+    #     {"data":data4,"type":"+hit1","skills":["唤魔 : 塔莫斯之袭"],"ratio": 1},
+    #     {"data":data5,"type":"*power3","skills":["唤魔 : 塔莫斯之袭"]}
+    # ]
     associate = [
-        {"data":data0,"type":"*skillDamage","exceptSkills":["魔刃狂舞","蛇腹剑 : 缠","唤魔 : 塔莫斯之袭"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), except_skills=['魔刃狂舞', '蛇腹剑 : 缠', '唤魔 : 塔莫斯之袭']),
-        {"data":data1,"type":"+power8","skills":["蛇腹剑 : 缠"]},
+        SkillEffect(attribute=Power(8), operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['蛇腹剑 : 缠']),
-        {"data":data1,"type":"+power9","skills":["蛇腹剑 : 缠"]},
+        SkillEffect(attribute=Power(9), operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['蛇腹剑 : 缠']),
-        {"data":data3,"type":"+power4","skills":["魔刃狂舞"]},
+        SkillEffect(attribute=Power(4), operation=Operation.ADD, value=Percent(LevelTable(data3)), skills=['魔刃狂舞']),
-        {"data":data3,"type":"+power5","skills":["魔刃狂舞"]},
+        SkillEffect(attribute=Power(5), operation=Operation.ADD, value=Percent(LevelTable(data3)), skills=['魔刃狂舞']),
-        {"data":data4,"type":"+hit1","skills":["唤魔 : 塔莫斯之袭"],"ratio": 1},
+        SkillEffect(attribute=Hit(1), operation=Operation.ADD, value=LevelTable(data4), skills=['唤魔 : 塔莫斯之袭']),
-        {"data":data5,"type":"*power3","skills":["唤魔 : 塔莫斯之袭"]}
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable(data5)), skills=['唤魔 : 塔莫斯之袭']),
     ]
 
 # 弑神剑 : 极
@@ -1571,10 +1612,16 @@ class Skill40(PassiveSkill):
     # [蛇腹剑 ： 缠]下劈攻击力 : 总攻击力的{value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*skillDamage","exceptSkills":["蛇腹剑 : 缠"]},
+    #     {"data":data1,"type":"+power8","skills":["蛇腹剑 : 缠"]},
+    #     {"data":data1,"type":"+power9","skills":["蛇腹剑 : 缠"]},
+    # ]
     associate = [
-        {"data":data0,"type":"*skillDamage","exceptSkills":["蛇腹剑 : 缠"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), except_skills=['蛇腹剑 : 缠']),
-        {"data":data1,"type":"+power8","skills":["蛇腹剑 : 缠"]},
+        SkillEffect(attribute=Power(8), operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['蛇腹剑 : 缠']),
-        {"data":data1,"type":"+power9","skills":["蛇腹剑 : 缠"]},
+        SkillEffect(attribute=Power(9), operation=Operation.ADD, value=Percent(LevelTable(data1)), skills=['蛇腹剑 : 缠']),
     ]
 
 # 弑神剑 : 恶魔孤岛

backend/core/character/GF/swordman_female/spectre.py

@@ -1,6 +1,16 @@
 # 1645c45aabb008c98406b3a16447040d
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "swordman_female/spectre/cn/skillDetail"
 
@@ -106,7 +116,11 @@ class Skill3(PassiveSkill):
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['鬼缚钉']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['鬼缚钉']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['鬼缚钉']),
+    ]
 
 # 受身蹲伏
 # swordman_female/spectre/ce26c6b69d02a440a81b552bec94f03b
@@ -628,8 +642,12 @@ class Skill21(PassiveSkill):
     # 装备太刀时命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkI', 'data': data0},
+    # ]
     associate = [
-        {'type': '$*PAtkI', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_I, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 封喉丝
@@ -870,8 +888,12 @@ class Skill28(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 黑夜之花
@@ -1149,8 +1171,12 @@ class Skill33(PassiveSkill):
     # 装备太刀时攻击速度增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 沉寂之狱
@@ -1313,10 +1339,14 @@ class Skill36(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 1:
+    # def effect(self, old, new):
-            self.associate = [{'type': '*skillDamage', 'data': [0] + [-12.3] * self.maxLv, 'skills': ['鬼缚钉']}]
+    #     if self.vp == 1:
-        return super().effect(old, new)
+    #         self.associate = [{'type': '*skillDamage', 'data': [0] + [-12.3] * self.maxLv, 'skills': ['鬼缚钉']}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-12.3] * maxLv)), skills=['鬼缚钉'], when=Equals(Read(SkillAttribute.VP), 1)),
+    ]
 
 # 无情夜行
 # swordman_female/spectre/863295a0fc634cf5fcc01e82a735fd6b
@@ -1344,9 +1374,14 @@ class Skill37(PassiveSkill):
     # 技能冷却时间减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    #     {'type': '*cdReduce', 'data': data1, 'exceptSkills': ['沉寂之狱', '黑曜真刃·破晓', '秘术·雨夜终曲']},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {'type': '*cdReduce', 'data': data1, 'exceptSkills': ['沉寂之狱', '黑曜真刃·破晓', '秘术·雨夜终曲']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=['沉寂之狱', '黑曜真刃·破晓', '秘术·雨夜终曲']),
     ]
 
 # 秘术·曜夜斩
@@ -1543,8 +1578,12 @@ class Skill41(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data1},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data1},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
     ]
 
 # 绚烂之舞

backend/core/character/GF/swordman_female/sword_master.py

@@ -1,6 +1,26 @@
 # 1645c45aabb008c98406b3a16447040d
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    ExtraData,
+    Hit,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class SwordMasterAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    SUB_POWER = 'power_sub'
+    """驭剑士：魔剑奥义附加分段倍率。"""
+
 
 prefix = "swordman_female/sword_master/cn/skillDetail"
 
@@ -182,7 +202,11 @@ class Skill5(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['帝国剑术']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['帝国剑术']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['帝国剑术']),
+    ]
 
 # 受身蹲伏
 # swordman_female/sword_master/ce26c6b69d02a440a81b552bec94f03b
@@ -617,7 +641,11 @@ class Skill20(PassiveSkill):
     hasUP = False
     custom = get_data(f'{prefix}/{uuid}', 'custom')  # noqa: E501
 
-    associate = [{'type': '+lv', 'data': [i + 1 if i > 0 else i for i in range(0, maxLv + 2)], 'ratio': 1, 'skills': ['波动之钝器精通', '血影之太刀精通', '毁灭之巨剑精通', '魔性之短剑精通']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+lv', 'data': [i + 1 if i > 0 else i for i in range(0, maxLv + 2)], 'ratio': 1, 'skills': ['波动之钝器精通', '血影之太刀精通', '毁灭之巨剑精通', '魔性之短剑精通']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.LEVEL, operation=Operation.ADD, value=LevelTable([i + 1 if i > 0 else i for i in range(0, maxLv + 2)]), skills=['波动之钝器精通', '血影之太刀精通', '毁灭之巨剑精通', '魔性之短剑精通']),
+    ]
 
 
 # 驭剑术
@@ -750,13 +778,22 @@ class Skill23(PassiveSkill):
     # [瞬影三绝斩]异常状态几率增加 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0, 'weapon': ['短剑']},
+    #     {'type': '*skillDamage', 'data': data1, 'weapon': ['短剑']},
+    #     {'type': '+power_sub', 'data': data2, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+    #     {'type': '+power_sub', 'data': data2, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+    #     {'type': '*skillDamage', 'data': data3, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+    #     {'type': '*cdReduce', 'data': data4, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0, 'weapon': ['短剑']},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0)), weapon=['短剑']),
-        {'type': '*skillDamage', 'data': data1, 'weapon': ['短剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), weapon=['短剑']),
-        {'type': '+power_sub', 'data': data2, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+        SkillEffect(attribute=SwordMasterAttribute.SUB_POWER, operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔剑奥义'], weapon=['短剑']),
-        {'type': '+power_sub', 'data': data2, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+        SkillEffect(attribute=SwordMasterAttribute.SUB_POWER, operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['魔剑奥义'], weapon=['短剑']),
-        {'type': '*skillDamage', 'data': data3, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), skills=['魔剑奥义'], weapon=['短剑']),
-        {'type': '*cdReduce', 'data': data4, 'skills': ['魔剑奥义'], 'weapon': ['短剑']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data4)), skills=['魔剑奥义'], weapon=['短剑']),
     ]
 
 # 血影之太刀精通
@@ -806,14 +843,24 @@ class Skill24(PassiveSkill):
     # [瞬影三绝斩]剑气追加次数 : 1次
     data8 = [0] + [1] * maxLv
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0, 'weapon': ['太刀']},
+    #     {'type': '*skillDamage', 'data': data1, 'skills': ['帝国剑术'], 'weapon': ['太刀']},
+    #     {'type': '*skillDamage', 'data': data2, 'skills': ['魔剑降临'], 'weapon': ['太刀']},
+    #     {'type': '*skillDamage', 'data': [0] + [29 + 0.5 * i for i in range(maxLv)], 'weapon': ['太刀']},
+    #     {'type': '*cdRatio', 'data': data7, 'weapon': ['太刀']},
+    #     {'type': '+hit0', 'data': data8, 'skills': ['瞬影三绝斩'], 'weapon': ['太刀'], 'ratio': 1},
+    #     {'type': '+hit3', 'data': data8, 'skills': ['瞬影三绝斩'], 'weapon': ['太刀'], 'ratio': 1},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0, 'weapon': ['太刀']},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0)), weapon=['太刀']),
-        {'type': '*skillDamage', 'data': data1, 'skills': ['帝国剑术'], 'weapon': ['太刀']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['帝国剑术'], weapon=['太刀']),
-        {'type': '*skillDamage', 'data': data2, 'skills': ['魔剑降临'], 'weapon': ['太刀']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), skills=['魔剑降临'], weapon=['太刀']),
-        {'type': '*skillDamage', 'data': [0] + [29 + 0.5 * i for i in range(maxLv)], 'weapon': ['太刀']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [29 + 0.5 * i for i in range(maxLv)])), weapon=['太刀']),
-        {'type': '*cdRatio', 'data': data7, 'weapon': ['太刀']},
+        SkillEffect(attribute=SkillAttribute.CD_RATIO, value=1 - Percent(LevelTable(data7)), weapon=['太刀']),
-        {'type': '+hit0', 'data': data8, 'skills': ['瞬影三绝斩'], 'weapon': ['太刀'], 'ratio': 1},
+        SkillEffect(attribute=Hit(0), operation=Operation.ADD, value=LevelTable(data8), skills=['瞬影三绝斩'], weapon=['太刀']),
-        {'type': '+hit3', 'data': data8, 'skills': ['瞬影三绝斩'], 'weapon': ['太刀'], 'ratio': 1},
+        SkillEffect(attribute=Hit(3), operation=Operation.ADD, value=LevelTable(data8), skills=['瞬影三绝斩'], weapon=['太刀']),
     ]
     # [瞬影三绝斩]剑气追加次数 : 1次
 
@@ -860,12 +907,20 @@ class Skill25(PassiveSkill):
     # [恶即斩]蓄气后最终一击攻击力增加率 : {value8}%
     data8 = get_data(f'{prefix}/{uuid}', 8)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0, 'weapon': ['巨剑']},
+    #     {'type': '*skillDamage', 'data': data1, 'skills': ['帝国剑术'], 'weapon': ['巨剑']},
+    #     {'type': '*skillDamage', 'data': data5, 'weapon': ['巨剑']},
+    #     {'type': '*skillDamage', 'data': data6, 'skills': ['破军旋舞斩'], 'weapon': ['巨剑']},
+    #     {'type': '*power1', 'data': data8, 'skills': ['恶即斩'], 'weapon': ['巨剑']},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0, 'weapon': ['巨剑']},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0)), weapon=['巨剑']),
-        {'type': '*skillDamage', 'data': data1, 'skills': ['帝国剑术'], 'weapon': ['巨剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['帝国剑术'], weapon=['巨剑']),
-        {'type': '*skillDamage', 'data': data5, 'weapon': ['巨剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data5)), weapon=['巨剑']),
-        {'type': '*skillDamage', 'data': data6, 'skills': ['破军旋舞斩'], 'weapon': ['巨剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data6)), skills=['破军旋舞斩'], weapon=['巨剑']),
-        {'type': '*power1', 'data': data8, 'skills': ['恶即斩'], 'weapon': ['巨剑']},
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable(data8)), skills=['恶即斩'], weapon=['巨剑']),
     ]
 
 # 波动之钝器精通
@@ -911,12 +966,20 @@ class Skill26(PassiveSkill):
     data8 = get_data(f'{prefix}/{uuid}', 8)
     # 技能攻击力增加增益效果持续时间 : {value9}秒
     data9 = get_data(f'{prefix}/{uuid}', 9)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0, 'weapon': ['钝器']},
+    #     {'type': '*power3', 'data': data3, 'skills': ['穿云破空剑'], 'weapon': ['钝器']},
+    #     {'type': '*power2', 'data': data5, 'skills': ['幻剑术'], 'weapon': ['钝器']},
+    #     {'type': '*skillDamage', 'data': data8, 'weapon': ['钝器']},
+    #     {'type': '*skillDamage', 'data': data7, 'skills': ['雷鸣千军破'], 'weapon': ['钝器']},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0, 'weapon': ['钝器']},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0)), weapon=['钝器']),
-        {'type': '*power3', 'data': data3, 'skills': ['穿云破空剑'], 'weapon': ['钝器']},
+        SkillEffect(attribute=Power(3), value=1 + Percent(LevelTable(data3)), skills=['穿云破空剑'], weapon=['钝器']),
-        {'type': '*power2', 'data': data5, 'skills': ['幻剑术'], 'weapon': ['钝器']},
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable(data5)), skills=['幻剑术'], weapon=['钝器']),
-        {'type': '*skillDamage', 'data': data8, 'weapon': ['钝器']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data8)), weapon=['钝器']),
-        {'type': '*skillDamage', 'data': data7, 'skills': ['雷鸣千军破'], 'weapon': ['钝器']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data7)), skills=['雷鸣千军破'], weapon=['钝器']),
     ]
 
 # 自动招架
@@ -1213,8 +1276,12 @@ class Skill34(ActiveSkill):
 
     mode = ['火/暗', '暗火', '冰/光', '冰光', '冰火', '暗冰']
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '+dataplus0', 'data': data7, 'skills': ['飓风魔剑'], 'ratio': 1},
+    # ]
     associate = [
-        {'type': '+dataplus0', 'data': data7, 'skills': ['飓风魔剑'], 'ratio': 1},
+        SkillEffect(attribute=ExtraData(0), operation=Operation.ADD, value=LevelTable(data7), skills=['飓风魔剑']),
     ]
 
     def setMode(self, mode):
@@ -1252,8 +1319,12 @@ class Skill35(PassiveSkill):
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 瞬影三绝斩
@@ -1614,7 +1685,11 @@ class Skill40(PassiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
     # 国服特色被动+3%
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 极 · 驭剑术 (时空斩)
 # swordman_female/sword_master/0232c151ef3731c2dede51931a374723
@@ -1919,8 +1994,12 @@ class Skill45(PassiveSkill):
     # 使用巨剑时物理攻击力增加量 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 极 · 驭剑术 (破剑阵)
@@ -2099,8 +2178,12 @@ class Skill49(PassiveSkill):
     # 可以强制中断的次数增加 : {value2}次
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 誓约之引 : 万剑之巅

backend/core/character/GF/swordman_female/vegabond.py

@@ -3,6 +3,13 @@ from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
 from core.basic.roleinfo import CharacterEquipInfo
 from core.basic.formula import 武器强化计算, 增幅计算
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Operation,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "swordman_female/vegabond/cn/skillDetail"
 
 
@@ -80,8 +87,12 @@ class Skill2(PassiveSkill):
     # 技能冷却时间减少率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*cdReduce", 'exceptSkills': ['花开寒影', '飞花逐月', '轻云出月风静夜']}
+    # ]
     associate = [
-        {"data":data0,"type":"*cdReduce", 'exceptSkills': ['花开寒影', '飞花逐月', '轻云出月风静夜']}
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['花开寒影', '飞花逐月', '轻云出月风静夜']),
     ]
 
 # 冥思
@@ -736,8 +747,12 @@ class Skill24(PassiveSkill):
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*skillDamage"}
+    # ]
     associate = [
-        {"data":data0,"type":"*skillDamage"}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 四象引
@@ -1294,8 +1309,12 @@ class Skill37(PassiveSkill):
     # 增益效果持续时间 : {value4}秒
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*skillDamage"}
+    # ]
     associate = [
-        {"data":data0,"type":"*skillDamage"}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 花开寒影
@@ -1551,8 +1570,12 @@ class Skill42(PassiveSkill):
     # 基本攻击、 剑术、 掌法技能攻击力增加量 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*skillDamage"}
+    # ]
     associate = [
-        {"data":data0,"type":"*skillDamage"}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
     ]
 
 # 樱花劫
@@ -1730,9 +1753,14 @@ class Skill46(PassiveSkill):
     # [游龙掌]发射速度比率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"type":"*skillDamage"},
+    #     {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['一花渡江'], 'ratio': 1},
+    # ]
     associate = [
-        {"data":data0,"type":"*skillDamage"},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {'type': '+cd', 'data': [0] + [-1] * maxLv, 'skills': ['一花渡江'], 'ratio': 1},
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [-1] * maxLv), skills=['一花渡江']),
     ]
 
 # 轻云出月风静夜

backend/core/character/GF/swordman_male/asura.py

@@ -1,6 +1,12 @@
 # 41f1cdc2ff58bb5fdc287be0db2a8df3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "swordman_male/asura/cn/skillDetail"
 
@@ -134,7 +140,11 @@ class Skill3(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['波动刻印']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['波动刻印']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['波动刻印']),
+    ]
 
 # 受身蹲伏
 # swordman_male/asura/ce26c6b69d02a440a81b552bec94f03b
@@ -897,9 +907,14 @@ class Skill23(ActiveSkill):
     data7 = get_data(f'{prefix}/{uuid}', 7)
     hit7 = 1
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0},
+    #     {'type': '*skillDamage', 'data': [0] + [20] * maxLv, 'skills': ['鬼印珠', '不动明王阵']},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {'type': '*skillDamage', 'data': [0] + [20] * maxLv, 'skills': ['鬼印珠', '不动明王阵']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [20] * maxLv)), skills=['鬼印珠', '不动明王阵']),
     ]
 
 # 十字刃
@@ -1087,7 +1102,11 @@ class Skill28(PassiveSkill):
     data3 = get_data(f'{prefix}/{uuid}', 3)
     # 邪光剑气多段攻击次数 : 3次
 
-    associate = [{'type': '*skillDamage', 'data': data1, 'skills': ['邪光斩']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data1, 'skills': ['邪光斩']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['邪光斩']),
+    ]
     # 邪光剑气多段攻击次数 : 3次
 
 # 暴击
@@ -1248,7 +1267,11 @@ class Skill33(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 每分钟魔法值恢复增加 : {value2}
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 冰刃 · 波动剑
 # swordman_male/asura/ade01c1d6afc8a05055225045e89fe49
@@ -1628,9 +1651,14 @@ class Skill40(PassiveSkill):
     # 命中率增加 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data2, 'exceptSkills': ['地裂 · 波动剑']},
+    #     {'type': '*skillDamage', 'data': data3, 'skills': ['地裂 · 波动剑']},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data2, 'exceptSkills': ['地裂 · 波动剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), except_skills=['地裂 · 波动剑']),
-        {'type': '*skillDamage', 'data': data3, 'skills': ['地裂 · 波动剑']},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3)), skills=['地裂 · 波动剑']),
     ]
 
 # 暗天波动眼
@@ -1955,7 +1983,11 @@ class Skill44(ActiveSkill):
     # 感电持续时间 : {value5}秒
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'type': '*skillDamage', 'data': data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
     def getSkillCD(self, mode=None):
         return 2.5
@@ -2207,7 +2239,11 @@ class Skill48(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [修罗邪光斩]施放时波动刻印额外生成数量 : {value1}个
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 波动慧眼 : 无为法
 # swordman_male/asura/61c8cb33dd20b4ff335e8deed70d3d9c

backend/core/character/GF/swordman_male/berserker.py

@@ -1,6 +1,14 @@
 #41f1cdc2ff58bb5fdc287be0db2a8df3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "swordman_male/berserker/cn/skillDetail"
 
 
@@ -870,7 +878,11 @@ class Skill23(PassiveSkill):
     # 回避率增加率 : {value14}%
     data14 = get_data(f'{prefix}/{uuid}', 14)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 地裂 · 波动剑
 # swordman_male/berserker/3d8f3d438405d79f8d3ed68072674d1e
@@ -987,9 +999,14 @@ class Skill26(ActiveSkill):
     # 生命值吸收量上限 : {value6}
     data6 = get_data(f'{prefix}/{uuid}', 6)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data": data4, "type": '*skillDamage'},
+    #     {'data': data5, 'type': '*cdReduce', 'exceptSkills': ['魔狱血刹', '血魔 · 弑天', '血魔极道 : 灭世']}
+    # ]
     associate = [
-        {"data": data4, "type": '*skillDamage'},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4))),
-        {'data': data5, 'type': '*cdReduce', 'exceptSkills': ['魔狱血刹', '血魔 · 弑天', '血魔极道 : 灭世']}
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data5)), except_skills=['魔狱血刹', '血魔 · 弑天', '血魔极道 : 灭世']),
     ]
 
 # 月光斩
@@ -1362,7 +1379,11 @@ class Skill35(ActiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
     # 出血诱发范围 : {value6}px
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{"data":data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data3}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
+    ]
 
 # 嗜魂封魔斩
 # swordman_male/berserker/1b1cfab062e0768bcc889e33e1f30dbf
@@ -1630,7 +1651,11 @@ class Skill40(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 物理暴击率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"data": data1,"type": '$*PAtkI'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data1,"type": '$*PAtkI'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_I, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 魔狱血刹
 # swordman_male/berserker/8572675ec6a1f50b6eff6a867376c2de
@@ -1837,7 +1862,11 @@ class Skill45(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data": data0,"type": '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data0,"type": '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 浴血之怒
 # swordman_male/berserker/8ec9da6f808889b63adf2680fbf1f331
@@ -2043,7 +2072,11 @@ class Skill50(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data": data0,"type": '*skillDamage'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data0,"type": '*skillDamage'}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 血魔极道 : 灭世
 # swordman_male/berserker/d59c9840f65381bde8487757f1753c71

backend/core/character/GF/swordman_male/ghostblade.py

@@ -3,6 +3,17 @@ from core.basic.roleinfo import CharacterEquipInfo
 from core.basic.formula import 武器强化计算
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "swordman_male/ghostblade/cn/skillDetail"
 
 
@@ -811,7 +822,11 @@ class Skill24(PassiveSkill):
     # 命中率增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [ {"type":"$*PAtkP","data":data0}, ]
+    # 迁移前实现（保留对照）：
+    # associate = [ {"type":"$*PAtkP","data":data0}, ]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 嗜魂之手
 # swordman_male/ghostblade/3829c15bf5f520c13998a3479ba0ce7b
@@ -965,7 +980,11 @@ class Skill28(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 暴击伤害增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"data":data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data3}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
+    ]
 
 # 双魂共鸣
 # swordman_male/ghostblade/89a4529234904fcbb3abe289e281f2fd
@@ -1108,10 +1127,14 @@ class Skill32(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"type":"*skillRation","data":[0] + [-25]*self.maxLv,"skills":["鬼步"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"type":"*skillRation","data":[0] + [-25]*self.maxLv,"skills":["鬼步"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-25] * maxLv)), skills=['鬼步'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 共鸣 : 鬼灵斩
 # swordman_male/ghostblade/aa51c4ddf1659092fa9ed612b9837061
@@ -1274,10 +1297,14 @@ class Skill35(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"type":"*skillRation","data":[0] + [-11]*self.maxLv,"skills":["鬼步"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"type":"*skillRation","data":[0] + [-11]*self.maxLv,"skills":["鬼步"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.PANEL_RATIO, value=1 + Percent(LevelTable([0] + [-11] * maxLv)), skills=['鬼步'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 鬼夜
 # swordman_male/ghostblade/02ac8e048f7bbcfa616e74ac68988872
@@ -1303,7 +1330,11 @@ class Skill36(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 物理暴击率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 冥夜鬼天杀
 # swordman_male/ghostblade/ca2536eb56df0e812c88c59cabd38be0
@@ -1483,9 +1514,14 @@ class Skill40(PassiveSkill):
     # [鬼步]Y轴攻击范围增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"*skillDamage","data":data0},
+    #     {"type":"+cd","data":[0] + [-1]*maxLv,"skills":["鬼步","三段刃"],"ratio":1},
+    # ]
     associate = [
-        {"type":"*skillDamage","data":data0},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
-        {"type":"+cd","data":[0] + [-1]*maxLv,"skills":["鬼步","三段刃"],"ratio":1},
+        SkillEffect(attribute=SkillAttribute.CD, operation=Operation.ADD, value=LevelTable([0] + [-1] * maxLv), skills=['鬼步', '三段刃']),
     ]
 
 # 幻鬼 : 大回天
@@ -1696,7 +1732,11 @@ class Skill44(PassiveSkill):
     # 空中、 倒地状态下被攻击时施放冷却时间 : {value4}秒
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 无式·极影剑
 # swordman_male/ghostblade/7a3fc9d473e8ffe21dd900ddf228a437

backend/core/character/GF/swordman_male/soul_bender.py

@@ -1,6 +1,17 @@
 # 41f1cdc2ff58bb5fdc287be0db2a8df3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    Select,
+    SkillAttribute,
+    SkillEffect,
+    WeaponCategoryContains,
+)
 
 prefix = "swordman_male/soul_bender/cn/skillDetail"
 
@@ -58,7 +69,11 @@ class Skill0(ActiveSkill):
     # [范围信息]
     # 斩击范围比率 : {value9}%
     data9 = get_data(f'{prefix}/{uuid}', 9)
-    associate = [{'data': data2, 'skills': ['鬼斩']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2, 'skills': ['鬼斩']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2)), skills=['鬼斩']),
+    ]
 
 # 上挑
 # swordman_male/soul_bender/fc7a3f4c2852c832a2f20af63d5d212f
@@ -138,7 +153,11 @@ class Skill3(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['残影之凯贾']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['残影之凯贾']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['残影之凯贾']),
+    ]
 
 # 受身蹲伏
 # swordman_male/soul_bender/ce26c6b69d02a440a81b552bec94f03b
@@ -389,7 +408,11 @@ class Skill11(ActiveSkill):
     # [范围信息]
     # 领域范围 : {value4}px
     data4 = get_data(f'{prefix}/{uuid}', 4)
-    associate = [{'data': data3}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data3}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data3))),
+    ]
 
 # 裂波斩
 # swordman_male/soul_bender/202edb928046f4fa6dedf6337377efd5
@@ -616,15 +639,19 @@ class Skill17(PassiveSkill):
     # 命中率增加 : {value15}%
     data15 = get_data(f'{prefix}/{uuid}', 15)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.charEquipInfo['武器'].equInfo
+    # def effect(self, old, new):
-        if weapon is None or weapon.itemDetailType != '短剑':
+    #     weapon = self.char.charEquipInfo['武器'].equInfo
-            return
+    #     if weapon is None or weapon.itemDetailType != '短剑':
-        data = self.data1
+    #         return
-        if '传世武器' in weapon.categorize:
+    #     data = self.data1
-            data = self.data14
+    #     if '传世武器' in weapon.categorize:
-        self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #         data = self.data14
-        return super().effect(old, new)
+    #     self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data14), LevelTable(data1))), weapon=['短剑']),
+    ]
 
 # 太刀精通
 # swordman_male/soul_bender/8f73f243041c2d27739fe7696f02bf9b
@@ -682,15 +709,19 @@ class Skill18(PassiveSkill):
     # 命中率增加 : {value12}%
     data12 = get_data(f'{prefix}/{uuid}', 12)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.charEquipInfo['武器'].equInfo
+    # def effect(self, old, new):
-        if weapon is None or weapon.itemDetailType != '太刀':
+    #     weapon = self.char.charEquipInfo['武器'].equInfo
-            return
+    #     if weapon is None or weapon.itemDetailType != '太刀':
-        data = self.data1
+    #         return
-        if '传世武器' in weapon.categorize:
+    #     data = self.data1
-            data = self.data11
+    #     if '传世武器' in weapon.categorize:
-        self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #         data = self.data11
-        return super().effect(old, new)
+    #     self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data11), LevelTable(data1))), weapon=['太刀']),
+    ]
 
 # 巨剑精通
 # swordman_male/soul_bender/8c2379737c5acc935c1731f67f607655
@@ -746,15 +777,19 @@ class Skill19(PassiveSkill):
     # 命中率增加 : {value11}%
     data11 = get_data(f'{prefix}/{uuid}', 11)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.charEquipInfo['武器'].equInfo
+    # def effect(self, old, new):
-        if weapon is None or weapon.itemDetailType != '巨剑':
+    #     weapon = self.char.charEquipInfo['武器'].equInfo
-            return
+    #     if weapon is None or weapon.itemDetailType != '巨剑':
-        data = self.data1
+    #         return
-        if '传世武器' in weapon.categorize:
+    #     data = self.data1
-            data = self.data10
+    #     if '传世武器' in weapon.categorize:
-        self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #         data = self.data10
-        return super().effect(old, new)
+    #     self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data10), LevelTable(data1))), weapon=['巨剑']),
+    ]
 
 # 钝器精通
 # swordman_male/soul_bender/9cb6f9ed646fa87f9b7680a42ce83d1a
@@ -810,15 +845,19 @@ class Skill20(PassiveSkill):
     # 命中率增加 : {value11}%
     data11 = get_data(f'{prefix}/{uuid}', 11)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.charEquipInfo['武器'].equInfo
+    # def effect(self, old, new):
-        if weapon is None or weapon.itemDetailType != '钝器':
+    #     weapon = self.char.charEquipInfo['武器'].equInfo
-            return
+    #     if weapon is None or weapon.itemDetailType != '钝器':
-        data = self.data1
+    #         return
-        if '传世武器' in weapon.categorize:
+    #     data = self.data1
-            data = self.data10
+    #     if '传世武器' in weapon.categorize:
-        self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #         data = self.data10
-        return super().effect(old, new)
+    #     self.associate = [{'type': '$*PAtkM', 'data': data}]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data10), LevelTable(data1))), weapon=['钝器']),
+    ]
 
 # 地裂 · 波动剑
 # swordman_male/soul_bender/3d8f3d438405d79f8d3ed68072674d1e
@@ -873,7 +912,11 @@ class Skill22(PassiveSkill):
     # 自身属性攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 封印解除
 # swordman_male/soul_bender/27bade584bb42fef68148d3a0b72bace
@@ -903,7 +946,11 @@ class Skill23(PassiveSkill):
     # 施放速度增加 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
 
-    associate = [{'type': '+lv', 'data': [0] + [1] * maxLv, 'skills': ['刀魂之卡赞', '冰霜之萨亚', '侵蚀之普戾蒙', '鬼斩', '瘟疫之罗刹', '冥炎之卡洛'], 'ratio': 1}]  # noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+lv', 'data': [0] + [1] * maxLv, 'skills': ['刀魂之卡赞', '冰霜之萨亚', '侵蚀之普戾蒙', '鬼斩', '瘟疫之罗刹', '冥炎之卡洛'], 'ratio': 1}]  # noqa: E501
+    associate = [
+        SkillEffect(attribute=SkillAttribute.LEVEL, operation=Operation.ADD, value=LevelTable([0] + [1] * maxLv), skills=['刀魂之卡赞', '冰霜之萨亚', '侵蚀之普戾蒙', '鬼斩', '瘟疫之罗刹', '冥炎之卡洛']),
+    ]
 
 # 侵蚀之普戾蒙
 # swordman_male/soul_bender/01384bbfc346775d1267fa0bc4ca605f
@@ -945,7 +992,11 @@ class Skill24(ActiveSkill):
     # [范围信息]
     # 效果范围 : {value5}px
     data5 = get_data(f'{prefix}/{uuid}', 5)
-    associate = [{'data': data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 十字刃
 # swordman_male/soul_bender/ca75c965f20a150f99f54155a37400df
@@ -1260,7 +1311,11 @@ class Skill33(PassiveSkill):
     # [范围信息]
     # 噬灵鬼斩大小比率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data1, 'skills': ['鬼斩']}]  # noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'skills': ['鬼斩']}]  # noqa: E501
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['鬼斩']),
+    ]
 
 # 嗜魂之手
 # swordman_male/soul_bender/3829c15bf5f520c13998a3479ba0ce7b
@@ -1804,7 +1859,11 @@ class Skill43(PassiveSkill):
     data5 = get_data(f'{prefix}/{uuid}', 5)
     # 技能攻击力增加率 : {value6}%
     data6 = get_data(f'{prefix}/{uuid}', 6)
-    associate = [{'data': data6}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data6}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data6))),
+    ]
 
 # 第7鬼神 : 怖拉修
 # swordman_male/soul_bender/b8f4966608e4ebb3cc80ba4eac3649bb
@@ -2087,7 +2146,11 @@ class Skill48(PassiveSkill):
 
     # 技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 幽魂降临 : 式
 # swordman_male/soul_bender/96e72ec364dada85600c907ecd95a140
@@ -2231,7 +2294,11 @@ class Skill51(PassiveSkill):
 
     # 基本攻击力和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 鬼神剑·黄泉摆渡
 # swordman_male/soul_bender/0dbdeaf846356f8b9380f8fbb8e97377

backend/core/character/GF/swordman_male/weapon_master.py

@@ -1,6 +1,10 @@
 # 41f1cdc2ff58bb5fdc287be0db2a8df3
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data, characterLv
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute, CharacterEffect, ExtraData, ExtraPower, LevelTable, Operation,
+    Percent, Power, Read, Select, SkillAttribute, SkillEffect, WeaponCategoryContains,
+)
 
 prefix = "swordman_male/weapon_master/cn/skillDetail"
 
@@ -178,7 +182,11 @@ class Skill4(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 跳跃攻击力变化率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['里 · 鬼剑术', '空之连刃']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': [i - 100 if i > 0 else 0 for i in data0], 'skills': ['里 · 鬼剑术', '空之连刃']}]
+    associate = [
+        SkillEffect(value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0])), skills=['里 · 鬼剑术', '空之连刃']),
+    ]
 
 # 受身蹲伏
 # swordman_male/weapon_master/ce26c6b69d02a440a81b552bec94f03b
@@ -635,15 +643,19 @@ class Skill17(PassiveSkill):
     # 命中率增加 : {value18}%
     data18 = get_data(f'{prefix}/{uuid}', 18)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.GetWeaponType()
+    # def effect(self, old, new):
-        if weapon[0] != '光剑':
+    #     weapon = self.char.GetWeaponType()
-            return None
+    #     if weapon[0] != '光剑':
-        data = self.data0
+    #         return None
-        if '传世武器' in weapon[1]:
+    #     data = self.data0
-            data = self.data16
+    #     if '传世武器' in weapon[1]:
-        self.associate = [{'type': '$*PAtkP', 'data': data}]
+    #         data = self.data16
-        return super().effect(old, new)
+    #     self.associate = [{'type': '$*PAtkP', 'data': data}]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data16), LevelTable(data0))), weapon=['光剑']),
+    ]
 
 # 三段刃
 # swordman_male/weapon_master/f2fb27162beb0b87a7cb9af7900e95f2
@@ -742,20 +754,27 @@ class Skill19(PassiveSkill):
     # 命中率增加 : {value15}%
     data15 = get_data(f'{prefix}/{uuid}', 15)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.GetWeaponType()
+    # def effect(self, old, new):
-        if weapon[0] != '短剑':
+    #     weapon = self.char.GetWeaponType()
-            return None
+    #     if weapon[0] != '短剑':
-        data = self.data0
+    #         return None
-        if '传世武器' in weapon[1]:
+    #     data = self.data0
-            data = self.data13
+    #     if '传世武器' in weapon[1]:
-        self.associate = [
+    #         data = self.data13
-            {'type': '$*PAtkP', 'data': data},
+    #     self.associate = [
-            {'type': '+dataplus0', 'data': self.data3, 'skills': ['里 · 鬼剑术'], 'ratio': 1},
+    #         {'type': '$*PAtkP', 'data': data},
-            {'type': '*skillDamage', 'data': self.data11, 'skills': ['破军升龙击']},
+    #         {'type': '+dataplus0', 'data': self.data3, 'skills': ['里 · 鬼剑术'], 'ratio': 1},
-            {'type': '*skillDamage', 'data': self.data12, 'skills': ['猛龙断空斩']},
+    #         {'type': '*skillDamage', 'data': self.data11, 'skills': ['破军升龙击']},
-        ]
+    #         {'type': '*skillDamage', 'data': self.data12, 'skills': ['猛龙断空斩']},
-        return super().effect(old, new)
+    #     ]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data13), LevelTable(data0))), weapon=['短剑']),
+        SkillEffect(attribute=ExtraData(0), operation=Operation.ADD, value=LevelTable(data3), skills=['里 · 鬼剑术'], weapon=['短剑']),
+        SkillEffect(value=1 + Percent(LevelTable(data11)), skills=['破军升龙击'], weapon=['短剑']),
+        SkillEffect(value=1 + Percent(LevelTable(data12)), skills=['猛龙断空斩'], weapon=['短剑']),
+    ]
 
 # 太刀精通
 # swordman_male/weapon_master/8f73f243041c2d27739fe7696f02bf9b
@@ -813,18 +832,23 @@ class Skill20(ActiveSkill):
     # 命中率增加 : {value12}%
     data12 = get_data(f'{prefix}/{uuid}', 12)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.GetWeaponType()
+    # def effect(self, old, new):
-        if weapon[0] != '太刀':
+    #     weapon = self.char.GetWeaponType()
-            return None
+    #     if weapon[0] != '太刀':
-        data = self.data0
+    #         return None
-        if '传世武器' in weapon[1]:
+    #     data = self.data0
-            data = self.data10
+    #     if '传世武器' in weapon[1]:
-        self.associate = [
+    #         data = self.data10
-            {'type': '$*PAtkP', 'data': data},
+    #     self.associate = [
-            {'type': '*power1', 'data': [i - 100 if i > 100 else 0 for i in self.data9], 'skills': ['空中连斩']},
+    #         {'type': '$*PAtkP', 'data': data},
-        ]
+    #         {'type': '*power1', 'data': [i - 100 if i > 100 else 0 for i in self.data9], 'skills': ['空中连斩']},
-        return super().effect(old, new)
+    #     ]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data10), LevelTable(data0))), weapon=['太刀']),
+        SkillEffect(attribute=Power(1), value=1 + Percent(LevelTable([i - 100 if i > 100 else 0 for i in data9])), skills=['空之连刃'], weapon=['太刀']),
+    ]
 
     def getSkillData(self, lv=0):
         weapon = self.char.GetWeaponType()
@@ -887,19 +911,25 @@ class Skill21(PassiveSkill):
     # 命中率增加 : {value11}%
     data11 = get_data(f'{prefix}/{uuid}', 11)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.GetWeaponType()
+    # def effect(self, old, new):
-        if weapon[0] != '巨剑':
+    #     weapon = self.char.GetWeaponType()
-            return None
+    #     if weapon[0] != '巨剑':
-        data = self.data0
+    #         return None
-        if '传世武器' in weapon[1]:
+    #     data = self.data0
-            data = self.data9
+    #     if '传世武器' in weapon[1]:
-        self.associate = [
+    #         data = self.data9
-            {'type': '$*PAtkP', 'data': data},
+    #     self.associate = [
-            {'type': '+dataplus0', 'data': self.data3, 'skills': ['里 · 鬼剑术'], 'ratio': 1},
+    #         {'type': '$*PAtkP', 'data': data},
-            {'type': '+power12', 'data': [i - 100 if i > 100 else i for i in self.data8], 'skills': ['拔刀斩']},
+    #         {'type': '+dataplus0', 'data': self.data3, 'skills': ['里 · 鬼剑术'], 'ratio': 1},
-        ]
+    #         {'type': '+power12', 'data': [i - 100 if i > 100 else i for i in self.data8], 'skills': ['拔刀斩']},
-        return super().effect(old, new)
+    #     ]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data9), LevelTable(data0))), weapon=['巨剑']),
+        SkillEffect(attribute=ExtraData(0), operation=Operation.ADD, value=LevelTable(data3), skills=['里 · 鬼剑术'], weapon=['巨剑']),
+        SkillEffect(attribute=Power(12), operation=Operation.ADD, value=Percent(LevelTable([i - 100 if i > 100 else i for i in data8])), skills=['拔刀斩'], weapon=['巨剑']),
+    ]
 
 # 钝器精通
 # swordman_male/weapon_master/9cb6f9ed646fa87f9b7680a42ce83d1a
@@ -952,17 +982,21 @@ class Skill22(PassiveSkill):
     # 命中率增加 : {value11}%
     data11 = get_data(f'{prefix}/{uuid}', 11)
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        weapon = self.char.GetWeaponType()
+    # def effect(self, old, new):
-        if weapon[0] != '钝器':
+    #     weapon = self.char.GetWeaponType()
-            return None
+    #     if weapon[0] != '钝器':
-        data = self.data0
+    #         return None
-        if '传世武器' in weapon[1]:
+    #     data = self.data0
-            data = self.data9
+    #     if '传世武器' in weapon[1]:
-        self.associate = [
+    #         data = self.data9
-            {'type': '$*PAtkP', 'data': data},
+    #     self.associate = [
-        ]
+    #         {'type': '$*PAtkP', 'data': data},
-        return super().effect(old, new)
+    #     ]
+    #     return super().effect(old, new)
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable(data9), LevelTable(data0))), weapon=['钝器']),
+    ]
 
 # 地裂 · 波动剑
 # swordman_male/weapon_master/3d8f3d438405d79f8d3ed68072674d1e
@@ -1010,7 +1044,14 @@ class Skill24(PassiveSkill):
     rangeLv = 3
     uuid = '8ee0099656df08a0b39225f8a21d514b'
 
-    associate = [{'type': '+lv', 'data': [i + 1 if i > 0 else i for i in range(0, maxLv + 2)], 'ratio': 1, 'skills': ['光剑精通', '钝器精通', '太刀精通', '巨剑精通', '短剑精通']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+lv', 'data': [i + 1 if i > 0 else i for i in range(0, maxLv + 2)], 'ratio': 1, 'skills': ['光剑精通', '钝器精通', '太刀精通', '巨剑精通', '短剑精通']}]
+    associate = [
+        SkillEffect(
+            attribute=SkillAttribute.LEVEL, operation=Operation.ADD, value=Read(SkillAttribute.LEVEL) + 1,
+            skills=['光剑精通', '钝器精通', '太刀精通', '巨剑精通', '短剑精通'],
+        ),
+    ]
 
 
 # 光剑掌握
@@ -1036,8 +1077,12 @@ class Skill25(PassiveSkill):
     # 装备光剑时，攻击速度增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*cdReduce', 'data': data0, 'exceptSkills': ['极 · 鬼剑术 (暴风式)', '万剑归宗', '万剑极诣·开天斩']},
+    # ]
     associate = [
-        {'type': '*cdReduce', 'data': data0, 'exceptSkills': ['极 · 鬼剑术 (暴风式)', '万剑归宗', '万剑极诣·开天斩']},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['极 · 鬼剑术 (暴风式)', '万剑归宗', '万剑极诣·开天斩']),
     ]
 
 # 后跳斩
@@ -1350,7 +1395,11 @@ class Skill33(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 自动格挡
 # swordman_male/weapon_master/0969cd4054d93da07708108c0cc1c4b5
@@ -1727,7 +1776,11 @@ class Skill41(ActiveSkill):
     # 物理暴击率增加 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'type': '*skillDamage', 'data': data2, 'skills': ['流心 : 升', '流心 : 刺', '流心 : 跃']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data2, 'skills': ['流心 : 升', '流心 : 刺', '流心 : 跃']}]
+    associate = [
+        SkillEffect(value=1 + Percent(LevelTable(data2)), skills=['流心 : 升', '流心 : 刺', '流心 : 跃']),
+    ]
 
     def getWeaponCDRatio(self):
         return 1.0
@@ -2132,7 +2185,11 @@ class Skill46(PassiveSkill):
     # 基本攻击力和技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
 
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 极 · 鬼剑术 (暴风式)
 # swordman_male/weapon_master/4f2e001e9a19eb7bae50ad1840dfb329
@@ -2174,7 +2231,11 @@ class Skill47(ActiveSkill):
     # 压制力 (4人队伍) : {value4}秒 ({value5}秒)
     data4 = get_data(f'{prefix}/{uuid}', 4)
     data5 = get_data(f'{prefix}/{uuid}', 5)
-    associate = [{'type': '*skillDamage', 'data': data3, 'skills': [name]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data3, 'skills': [name]}]
+    associate = [
+        SkillEffect(value=1 + Percent(LevelTable(data3)), skills=[name]),
+    ]
 
 # 极 · 神剑术 (流星落)
 # swordman_male/weapon_master/0c262dac3ec41ff79e359ada9c7a7faf
@@ -2577,18 +2638,32 @@ class Skill52(PassiveSkill):
     # 攻击力 : [极 · 神剑术 (破空斩)]爆炸攻击力的{value23}%
     data23 = get_data(f'{prefix}/{uuid}', 23)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '*skillDamage', 'data': data0, 'skills': ['拔刀斩', '破军斩龙击', '极 · 鬼剑术 (暴风式)', '破空拔刀斩', '极 · 神剑术 (瞬斩)', '万剑归宗', '极 · 神剑术 (无形斩)', '万剑极诣·开天斩']},
+    #     {'type': '+power13', 'data': data2, 'skills': ['破军升龙击']},
+    #     {'type': '+power4', 'data': data3, 'skills': ['猛龙断空斩']},
+    #     {'type': '+power18', 'data': data4, 'skills': ['幻影剑舞']},
+    #     {'type': '+power19', 'data': data5, 'skills': ['幻影剑舞']},
+    #     {'type': '+power20', 'data': data6, 'skills': ['幻影剑舞'], 'weapon': ['钝器']},
+    #     {'type': '+dataplus0', 'data': data7, 'skills': ['极 · 神剑术 (流星落)'], 'ratio': 1},
+    #     {'type': '+dataplus1', 'data': data15, 'skills': ['极 · 神剑术 (流星落)'], 'weapon': ['光剑'], 'ratio': 1},
+    #     {'type': '*powerplus0', 'data': data19, 'skills': ['极 · 神剑术 (流星落)'], 'weapon': ['巨剑']},
+    #     {'type': '+dataplus1', 'data': data20, 'skills': ['极 · 神剑术 (流星落)'], 'weapon': ['钝器'], 'ratio': 1},
+    #     {'type': '*power2', 'data': data23, 'skills': ['极 · 神剑术 (破空斩)']},
+    # ]
     associate = [
-        {'type': '*skillDamage', 'data': data0, 'skills': ['拔刀斩', '破军斩龙击', '极 · 鬼剑术 (暴风式)', '破空拔刀斩', '极 · 神剑术 (瞬斩)', '万剑归宗', '极 · 神剑术 (无形斩)', '万剑极诣·开天斩']},
+        SkillEffect(value=1 + Percent(LevelTable(data0)), skills=['拔刀斩', '破军斩龙击', '极 · 鬼剑术 (暴风式)', '破空拔刀斩', '极 · 神剑术 (瞬斩)', '万剑归宗', '极 · 神剑术 (无形斩)', '万剑极诣·开天斩']),
-        {'type': '+power13', 'data': data2, 'skills': ['破军升龙击']},
+        SkillEffect(attribute=Power(13), operation=Operation.ADD, value=Percent(LevelTable(data2)), skills=['破军升龙击']),
-        {'type': '+power4', 'data': data3, 'skills': ['猛龙断空斩']},
+        SkillEffect(attribute=Power(4), operation=Operation.ADD, value=Percent(LevelTable(data3)), skills=['猛龙断空斩']),
-        {'type': '+power18', 'data': data4, 'skills': ['幻影剑舞']},
+        SkillEffect(attribute=Power(18), operation=Operation.ADD, value=Percent(LevelTable(data4)), skills=['幻影剑舞']),
-        {'type': '+power19', 'data': data5, 'skills': ['幻影剑舞']},
+        SkillEffect(attribute=Power(19), operation=Operation.ADD, value=Percent(LevelTable(data5)), skills=['幻影剑舞']),
-        {'type': '+power20', 'data': data6, 'skills': ['幻影剑舞'], 'weapon': ['钝器']},
+        SkillEffect(attribute=Power(20), operation=Operation.ADD, value=Percent(LevelTable(data6)), skills=['幻影剑舞'], weapon=['钝器']),
-        {'type': '+dataplus0', 'data': data7, 'skills': ['极 · 神剑术 (流星落)'], 'ratio': 1},
+        SkillEffect(attribute=ExtraData(0), operation=Operation.ADD, value=LevelTable(data7), skills=['极 · 神剑术 (流星落)']),
-        {'type': '+dataplus1', 'data': data15, 'skills': ['极 · 神剑术 (流星落)'], 'weapon': ['光剑'], 'ratio': 1},
+        SkillEffect(attribute=ExtraData(1), operation=Operation.ADD, value=LevelTable(data15), skills=['极 · 神剑术 (流星落)'], weapon=['光剑']),
-        {'type': '*powerplus0', 'data': data19, 'skills': ['极 · 神剑术 (流星落)'], 'weapon': ['巨剑']},
+        SkillEffect(attribute=ExtraPower(0), value=1 + Percent(LevelTable(data19)), skills=['极 · 神剑术 (流星落)'], weapon=['巨剑']),
-        {'type': '+dataplus1', 'data': data20, 'skills': ['极 · 神剑术 (流星落)'], 'weapon': ['钝器'], 'ratio': 1},
+        SkillEffect(attribute=ExtraData(1), operation=Operation.ADD, value=LevelTable(data20), skills=['极 · 神剑术 (流星落)'], weapon=['钝器']),
-        {'type': '*power2', 'data': data23, 'skills': ['极 · 神剑术 (破空斩)']},
+        SkillEffect(attribute=Power(2), value=1 + Percent(LevelTable(data23)), skills=['极 · 神剑术 (破空斩)']),
     ]
 
 # 极 · 神剑术 (瞬斩)
@@ -2784,7 +2859,11 @@ class Skill55(PassiveSkill):
     data18 = get_data(f'{prefix}/{uuid}', 18)
 
     # 对流系技能存在技能形态变动，但是实际加成和其他技能一致，这里简单化处理
-    associate = [{'type': '*skillDamage', 'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*skillDamage', 'data': data0}]
+    associate = [
+        SkillEffect(value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 极 · 神剑术 (无形斩)
 # swordman_male/weapon_master/0113c8b1306ca76d208f83f2d093dd62

backend/core/character/GF/thief/kunoichi.py

@@ -1,6 +1,23 @@
 # ddc49e9ad1ff72a00b53c6cff5b1e920
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class KunoichiAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    NINPOU = 'ninpou'
+    """忍者：六道轮回记录技能的伤害倍率。"""
+
 
 prefix = "thief/kunoichi/cn/skillDetail"
 
@@ -763,7 +780,11 @@ class Skill22(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 忍术技能冷却时间减少率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data1, 'type': '*cdReduce', 'skills': ['火遁·豪火球之术', '忍法 : 幻影手里剑', '火遁·飓风煞', '火遁·螺旋手里剑', '火遁·炎天道', '火遁·蟾蜍油炎弹', '火遁·炎舞天璇', '火遁·风魔手里剑', '八岐大蛇', '天照']}]  # noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'type': '*cdReduce', 'skills': ['火遁·豪火球之术', '忍法 : 幻影手里剑', '火遁·飓风煞', '火遁·螺旋手里剑', '火遁·炎天道', '火遁·蟾蜍油炎弹', '火遁·炎舞天璇', '火遁·风魔手里剑', '八岐大蛇', '天照']}]  # noqa: E501
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), skills=['火遁·豪火球之术', '忍法 : 幻影手里剑', '火遁·飓风煞', '火遁·螺旋手里剑', '火遁·炎天道', '火遁·蟾蜍油炎弹', '火遁·炎舞天璇', '火遁·风魔手里剑', '八岐大蛇', '天照']),
+    ]
 
 # 火遁·豪火球之术
 # thief/kunoichi/dcb31a63ef58954f44ff2070c42a9a98
@@ -1066,7 +1087,11 @@ class Skill30(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # 基本攻击投掷出苦无的几率 : {value2}%
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'data': data0, 'type': '$*PAtkM'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '$*PAtkM'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_M, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 烈焰印记
 # thief/kunoichi/374f53e8989ef04a8506c8ec99d9ecdc
@@ -1101,7 +1126,11 @@ class Skill31(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 灼伤持续时间 : {value3}秒
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 火遁·螺旋手里剑
 # thief/kunoichi/7e904ea3d2a9faa054604e55120a9268
@@ -1190,7 +1219,11 @@ class Skill33(ActiveSkill):
     # 决斗场前置冷却时间 : {value3}秒
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{'data': [i - 100 if i > 0 else 0 for i in data0]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': [i - 100 if i > 0 else 0 for i in data0]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([i - 100 if i > 0 else 0 for i in data0]))),
+    ]
 
 # 火遁·炎天道
 # thief/kunoichi/5152480fdde81362575a488d4cec4af9
@@ -1390,7 +1423,11 @@ class Skill36(ActiveSkill):
     # 范围 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{'data': data1, 'type': '+ninpou'}]  # noqa: E501
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1, 'type': '+ninpou'}]  # noqa: E501
+    associate = [
+        SkillEffect(attribute=KunoichiAttribute.NINPOU, operation=Operation.ADD, value=Percent(LevelTable(data1))),
+    ]
 
 # 火遁·蟾蜍油炎弹
 # thief/kunoichi/fc458e449ee00b01dbf88d09aae65462
@@ -1581,7 +1618,11 @@ class Skill39(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 追踪标记持续时间 : {value1}秒
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 毕方之印
 # thief/kunoichi/2c9d9a36c8401bddff6cdb80fab8dc24
@@ -1637,7 +1678,11 @@ class Skill40(ActiveSkill):
     data11 = get_data(f'{prefix}/{uuid}', 11)
     hit11 = 1
 
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
     def getSkillCD(self, mode=None):
         return 1.0
@@ -1909,7 +1954,11 @@ class Skill44(PassiveSkill):
     # [忍法 ： 六道轮回]强化残影攻击速度增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
 
-    associate = [{"data": data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data": data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 八岐大蛇
 # thief/kunoichi/147d005ac868e0de52b1f255eea35d62
@@ -2064,7 +2113,11 @@ class Skill47(ActiveSkill):
     # 锁定敌人范围 : {value5}px
     data5 = get_data(f'{prefix}/{uuid}', 5)
 
-    associate = [{'data': data4, 'skills': ['天照']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data4, 'skills': ['天照']}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data4)), skills=['天照']),
+    ]
 
     mode = ['普通', '六道']
 
@@ -2206,7 +2259,11 @@ class Skill49(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 基本攻击力和技能攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 勾玉之火 : 镰鼬
 # thief/kunoichi/845e0ce3235e19f60cc82a082d072cba

backend/core/character/GF/thief/necro.py

@@ -1,6 +1,16 @@
 #ddc49e9ad1ff72a00b53c6cff5b1e920
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    Equals,
+    LevelTable,
+    Operation,
+    Percent,
+    Power,
+    Read,
+    SkillAttribute,
+    SkillEffect,
+)
 prefix = "thief/necro/cn/skillDetail"
 
 
@@ -780,7 +790,11 @@ class Skill22(PassiveSkill):
     # [装备手杖时]
     # 施放速度增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"type":"*cdReduce","data":data0,"exceptSkills":["千魂祭","亡者君临 : 巴拉克之戮","命运殇痕·摩罗斯之咒"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"type":"*cdReduce","data":data0,"exceptSkills":["千魂祭","亡者君临 : 巴拉克之戮","命运殇痕·摩罗斯之咒"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data0)), except_skills=['千魂祭', '亡者君临 : 巴拉克之戮', '命运殇痕·摩罗斯之咒']),
+    ]
 
 # 驱使枯灵
 # thief/necro/d0cdaca82892e54097f22a1f60817048
@@ -895,7 +909,11 @@ class Skill24(ActiveSkill):
     # 黑夜术士魔法防御力增加 : {value4}
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{"data":data1,"skills":["降临 : 尼古拉斯"]}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data1,"skills":["降临 : 尼古拉斯"]}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['降临 : 尼古拉斯']),
+    ]
 
 # 暴击
 # thief/necro/fc1262c19f3d0477ee8eda47b8db8696
@@ -1032,7 +1050,11 @@ class Skill29(PassiveSkill):
 
     # 属性攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 百鬼夜行
 # thief/necro/04883563896fe1adac7505c6146b5f59
@@ -1148,7 +1170,11 @@ class Skill32(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [复苏者之缚]范围增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{"data":data0,"exceptSkills":["降临 : 尼古拉斯"]},]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0,"exceptSkills":["降临 : 尼古拉斯"]},]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), except_skills=['降临 : 尼古拉斯']),
+    ]
 
 # 降临 : 暴君巴拉克
 # thief/necro/dcd536f1674630f01fc9667bb202b851
@@ -1247,12 +1273,19 @@ class Skill33(ActiveSkill):
         self.setMode("x3")
         ...
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"type":"+power0","data":data6,"skills":["暗击拳"],"ratio":1},
+    #     {"type":"+power1","data":data7,"skills":["暗击拳"],"ratio":1},
+    #     {"type":"+power0","data":data8,"skills":["狂野乱舞"],"ratio":1},
+    #     {"type":"+power0","data":data9,"skills":["巴拉克强击"],"ratio":1}
+    #     ]
     associate = [
-        {"type":"+power0","data":data6,"skills":["暗击拳"],"ratio":1},
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=LevelTable(data6), skills=['暗击拳']),
-        {"type":"+power1","data":data7,"skills":["暗击拳"],"ratio":1},
+        SkillEffect(attribute=Power(1), operation=Operation.ADD, value=LevelTable(data7), skills=['暗击拳']),
-        {"type":"+power0","data":data8,"skills":["狂野乱舞"],"ratio":1},
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=LevelTable(data8), skills=['狂野乱舞']),
-        {"type":"+power0","data":data9,"skills":["巴拉克强击"],"ratio":1}
+        SkillEffect(attribute=Power(0), operation=Operation.ADD, value=LevelTable(data9), skills=['巴拉克强击']),
-        ]
+    ]
 
 # 暗击拳
 # thief/necro/1c1a9606eb702ebe5a7bb4397f3aeae0
@@ -1478,7 +1511,11 @@ class Skill39(PassiveSkill):
 
     # 技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 巴拉克的愤怒
 # thief/necro/0ed3148658fe37b3336ccb718dc0fdb0
@@ -1642,7 +1679,11 @@ class Skill42(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 暴击伤害增加率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{"data":data2}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data2}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data2))),
+    ]
 
 # 千魂祭
 # thief/necro/2a3c96b88d02372505692da0a8b54743
@@ -1878,10 +1919,14 @@ class Skill46(ActiveSkill):
         """
         ...
 
-    def effect(self, old, new):
+    # 迁移前实现（保留对照）：
-        if self.vp == 2:
+    # def effect(self, old, new):
-            self.associate = [{"data":[0]+[-50]*self.maxLv,"skills":["降临 : 莱迪娅"]}]
+    #     if self.vp == 2:
-        return super().effect(old, new)
+    #         self.associate = [{"data":[0]+[-50]*self.maxLv,"skills":["降临 : 莱迪娅"]}]
+    #     return super().effect(old, new)
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable([0] + [-50] * maxLv)), skills=['降临 : 莱迪娅'], when=Equals(Read(SkillAttribute.VP), 2)),
+    ]
 
 # 亡魂之息
 # thief/necro/78b86e64fbb74c1db1b71c50a5ac21cd
@@ -1907,9 +1952,14 @@ class Skill47(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # [暗魂波]、 [诅咒之箭]攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {"data":data0,"exceptSkills":["暗魂波","诅咒之箭"]},
+    #     {"data":data1,"skills":["暗魂波","诅咒之箭"]}
+    # ]
     associate = [
-        {"data":data0,"exceptSkills":["暗魂波","诅咒之箭"]},
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0)), except_skills=['暗魂波', '诅咒之箭']),
-        {"data":data1,"skills":["暗魂波","诅咒之箭"]}
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1)), skills=['暗魂波', '诅咒之箭']),
     ]
 
 # 暴君湮灭斩
@@ -2021,7 +2071,11 @@ class Skill50(PassiveSkill):
 
     # 基本攻击和转职技能攻击力增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{"data":data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{"data":data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 亡者之茧
 # thief/necro/b1ccbd90d0b40f543ece3b18fcef827f

backend/core/character/GF/thief/rogue.py

@@ -1,6 +1,25 @@
 # ddc49e9ad1ff72a00b53c6cff5b1e920
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data, _get_skill_damage_suffixes, _get_skill_dataplus_suffixes
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    Constant,
+    Hit,
+    LevelTable,
+    Operation,
+    Percent,
+    ProfessionAttribute,
+    SkillAttribute,
+    SkillEffect,
+)
+
+
+class RogueAttribute(ProfessionAttribute):
+    """本职业专用的最终效果属性；字段含义与技能实现保持一致。"""
+    END_POWER = 'endpower'
+    """刺客：终结追击分组的伤害倍率。"""
+
 
 prefix = "thief/rogue/cn/skillDetail"
 
@@ -744,13 +763,20 @@ class Skill20(ActiveSkill):
 
     maxLayer = 6
 
-    associate = [{'type': '*endpower', 'data': data0}, {'type': '*endpower'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '*endpower', 'data': data0}, {'type': '*endpower'}]
+    associate = [
+        SkillEffect(attribute=RogueAttribute.END_POWER, value=1 + Percent(LevelTable(data0))),
+        SkillEffect(attribute=RogueAttribute.END_POWER, value=1 + Percent(Constant(0))),
+    ]
 
-    def update_skill_attribute(self, skill, type, old, new, data, ratio=100, weapon=(), weapon_type=None, weapon_options=()):
+    # 迁移前实现（保留对照）：
-        if len(data) == 0:
+    # def update_skill_attribute(self, skill, type, old, new, data, ratio=100, weapon=(), weapon_type=None, weapon_options=()):
-            data = getattr(self, f'data{int(self.maxLayer)}')
+    #     if len(data) == 0:
-            data = [i - 100 if i > 100 else 0 for i in data]
+    #         data = getattr(self, f'data{int(self.maxLayer)}')
-        super().update_skill_attribute(skill, type, old, new, data, ratio, weapon, weapon_type, weapon_options)
+    #         data = [i - 100 if i > 100 else 0 for i in data]
+    #     super().update_skill_attribute(skill, type, old, new, data, ratio, weapon, weapon_type, weapon_options)
+    # 原第二条关联未提供 data，旧引擎默认零表，不进入空表分支；保留原有效倍率。
 
 # 诅咒之箭
 # thief/rogue/547ab2b2bd860d3e37355a9cfbc1077c
@@ -806,7 +832,11 @@ class Skill22(PassiveSkill):
 
     # [弧光闪]追加攻击发动次数增加 : {value0}
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'type': '+hit0', 'data': data0, 'ratio': 1, 'skills': ['弧光闪']}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'type': '+hit0', 'data': data0, 'ratio': 1, 'skills': ['弧光闪']}]
+    associate = [
+        SkillEffect(attribute=Hit(0), operation=Operation.ADD, value=LevelTable(data0), skills=['弧光闪']),
+    ]
 
 # 迅影
 # thief/rogue/1b1cfab062e0768bcc889e33e1f30dbf
@@ -1061,10 +1091,16 @@ class Skill27(PassiveSkill):
     # 命中率增加 : {value10}%
     data10 = get_data(f'{prefix}/{uuid}', 10)
 
+    # 迁移前实现（保留对照）：
+    # associate = [
+    #     {'type': '$*PAtkP', 'data': data0},
+    #     {'type': '*cdReduce', 'data': data1, 'exceptSkills': []},
+    #     {'type': '+maxLayer', 'data': data2, 'ratio': 1, 'skills': ['终结之击']},
+    # ]
     associate = [
-        {'type': '$*PAtkP', 'data': data0},
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
-        {'type': '*cdReduce', 'data': data1, 'exceptSkills': []},
+        SkillEffect(attribute=SkillAttribute.CD_REDUCE, value=1 - Percent(LevelTable(data1)), except_skills=[]),
-        {'type': '+maxLayer', 'data': data2, 'ratio': 1, 'skills': ['终结之击']},
+        SkillEffect(attribute=SkillAttribute.MAX_LAYER, operation=Operation.ADD, value=LevelTable(data2), skills=['终结之击']),
     ]
 
 # 旋舞斩
@@ -1664,7 +1700,11 @@ class Skill40(PassiveSkill):
     # 命中率增加 : {value4}%
     data4 = get_data(f'{prefix}/{uuid}', 4)
 
-    associate = [{'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 月轮舞
 # thief/rogue/c61f5a010370101402b05b21916c2071
@@ -1914,7 +1954,11 @@ class Skill45(PassiveSkill):
     data0 = get_data(f'{prefix}/{uuid}', 0)
     # 连击点数上限增加量 : {value1}个
     data1 = get_data(f'{prefix}/{uuid}', 1)
-    associate = [{'data': data0, 'type': '$*PAtkP'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '$*PAtkP'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 乱空杀
 # thief/rogue/5cac3411ccef1af333953e0ded5e942d
@@ -2148,7 +2192,11 @@ class Skill50(PassiveSkill):
     data2 = get_data(f'{prefix}/{uuid}', 2)
     # 多段攻击间隔减少率 : {value3}%
     data3 = get_data(f'{prefix}/{uuid}', 3)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 影·万古星辰
 # thief/rogue/ef9d26746effee9199b54541f01b8752

backend/core/character/GF/thief/shadow_dancer.py

@@ -1,6 +1,14 @@
 # ddc49e9ad1ff72a00b53c6cff5b1e920
 from core.basic.skill import PassiveSkill, ActiveSkill, get_data
 from core.basic.character import Character
+from core.basic.skill_effect_types import (
+    CharacterAttribute,
+    CharacterEffect,
+    LevelTable,
+    Percent,
+    SkillAttribute,
+    SkillEffect,
+)
 
 prefix = "thief/shadow_dancer/cn/skillDetail"
 
@@ -730,7 +738,11 @@ class Skill21(PassiveSkill):
 
     # 暴击伤害增加率 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 追影步
 # thief/shadow_dancer/0fbb8de70002ad34f046c94c2cb3e863
@@ -811,7 +823,11 @@ class Skill24(PassiveSkill):
     # 命中率增加 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data0, 'type': '$*PAtkP'}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0, 'type': '$*PAtkP'}]
+    associate = [
+        CharacterEffect(attribute=CharacterAttribute.P_ATK_P, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 挑空
 # thief/shadow_dancer/e0a072e8cef2d77893aad5f68aeed56a
@@ -1322,7 +1338,11 @@ class Skill36(PassiveSkill):
     # 背击时攻击力增加率 : {value1}%
     data1 = get_data(f'{prefix}/{uuid}', 1)
 
-    associate = [{'data': data1}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data1}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data1))),
+    ]
 
 # 影斩·乱舞
 # thief/shadow_dancer/8b08f9504167a9c0f3a1d29d71b7943e
@@ -1574,7 +1594,11 @@ class Skill41(PassiveSkill):
 
     # 基本攻击力和技能攻击力增加量 : {value0}%
     data0 = get_data(f'{prefix}/{uuid}', 0)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 摧心
 # thief/shadow_dancer/b163d099c8cc27fdb6fd3639c2ee6df9
@@ -1752,7 +1776,11 @@ class Skill44(PassiveSkill):
     data1 = get_data(f'{prefix}/{uuid}', 1)
     # [潜行领域]暗袭分身召唤数增加 : {value2}
     data2 = get_data(f'{prefix}/{uuid}', 2)
-    associate = [{'data': data0}]
+    # 迁移前实现（保留对照）：
+    # associate = [{'data': data0}]
+    associate = [
+        SkillEffect(attribute=SkillAttribute.DAMAGE, value=1 + Percent(LevelTable(data0))),
+    ]
 
 # 影缚追魂锁
 # thief/shadow_dancer/9ceb0c55f40f1fc0fe0fcc65c8fee3a0

backend/tests/unit/test_demon_slayer_blade_dance.py

@@ -41,26 +41,20 @@ def test_blade_dance_shadow_uses_final_hit_damage_not_hit_count():
     assert shadow_final_hit.value.id == "data2"
 
 
-def test_blade_dance_shadow_uses_its_own_passive_ratio():
+def test_blade_dance_shadow_uses_its_own_passive_ratio(minimal_calc_config):
-    passive = _skill_class("唤魔 : 弑神剑")
+    from core.basic.character import createCharacter
-    associations = next(
+    from core.basic.skill_effect_types import Operation, Power, SkillEffect
-        item.value
-        for item in passive.body
-        if isinstance(item, ast.Assign)
-        and any(isinstance(target, ast.Name) and target.id == "associate" for target in item.targets)
-    )
-    shadow_associations = [
-        dict(zip((key.value for key in entry.keys), entry.values))
-        for entry in associations.elts
-        if isinstance(entry, ast.Dict)
-    ]
 
-    for power in ("+power4", "+power5"):
+    char = createCharacter('GF.swordman_female.demon_slayer')
-        association = next(
+    char.calc(minimal_calc_config)
-            entry
+    passive = char.GetSkillByName('唤魔 : 弑神剑')
-            for entry in shadow_associations
+    for level in (1, 10, passive.maxLv):
-            if isinstance(entry.get("type"), ast.Constant)
+        passive.lv = level
-            and entry["type"].value == power
+        for index in (4, 5):
-        )
+            association = next(
-        assert isinstance(association["data"], ast.Name)
+                entry for entry in passive.associate
-        assert association["data"].id == "data3"
+                if isinstance(entry, SkillEffect) and entry.attribute == Power(index)
+            )
+            assert association.operation == Operation.ADD
+            assert '魔刃狂舞' in association.skills
+            assert association.evaluate(passive) == passive.data3[level] / 100

backend/tests/unit/test_typed_skill_effects.py

@@ -0,0 +1,334 @@
+"""Typed declarations must preserve baselines and expose all state dependencies."""
+import pytest
+
+from core.basic.skill import ActiveSkill, PassiveSkill
+from core.basic.skill_effects import SkillEffectEngine
+from core.basic.skill_effect_types import (
+    CharacterAttribute, CharacterEffect, Equals, ExtraData, LevelTable, Operation,
+    Percent, Power, Read, Select, SkillAttribute as Attr, SkillEffect, WeaponCategoryContains,
+)
+
+
+def character(*classes):
+    class Character:
+        role = name = 'test'
+        武器选项 = ['test']
+        Spirit = 100
+
+    char = Character()
+    char.GetWeaponType = lambda: ('test', '')
+    char.skills = [cls(char) for cls in classes]
+    char.GetSkillByName = lambda name: next((s for s in char.skills if s.name == name), None)
+    char.GetSkills = lambda *args: [s for s in char.skills if s.damage]
+    char.skill_effects = SkillEffectEngine(char)
+    return char
+
+
+def learn(char, values=None):
+    with char.skill_effects.batch():
+        for skill, value in zip(char.skills, values or [1] * len(char.skills)):
+            char.skill_effects.set_input_level(skill, value)
+
+
+@pytest.mark.parametrize('reverse', [False, True])
+def test_typed_cross_parameter_and_condition_use_final_state(reverse):
+    class Skill1(PassiveSkill):
+        name = 'reader'
+        maxLv = 1
+        associate = [SkillEffect(
+            skills=['mastery'], attribute=Attr.RATIO,
+            value=Read(Attr.RATIO, 'parameter'), when=Equals(Read(Attr.LEVEL, 'parameter'), 2),
+        )]
+
+    class Skill2(PassiveSkill):
+        name = 'upstream'
+        maxLv = 1
+        associate = [
+            {'type': '+lv', 'data': [0, 100], 'skills': ['parameter']},
+            {'type': '*ratio', 'data': [0, 50], 'skills': ['parameter']},
+        ]
+
+    class Skill3(PassiveSkill):
+        name = 'parameter'
+        maxLv = 3
+        ratio = 1.0
+
+    class Skill4(PassiveSkill):
+        name = 'mastery'
+        maxLv = 1
+        ratio = 1.0
+        associate = [SkillEffect(skills=['target'], value=1 + Read(Attr.RATIO))]
+
+    class Skill5(ActiveSkill):
+        name = 'target'
+        maxLv = 1
+
+    char = character(Skill1, Skill2, Skill3, Skill4, Skill5)
+    with char.skill_effects.batch():
+        for skill in char.skills[::-1] if reverse else char.skills:
+            char.skill_effects.set_input_level(skill, 1)
+    assert char.skills[-1].skillDamage == pytest.approx(2.5)
+    char.skills[1].lv = 0
+    assert char.skills[-1].skillDamage == pytest.approx(2)
+    char.skills[1].lv = 1
+    assert char.skills[-1].skillDamage == pytest.approx(2.5)
+
+
+def test_discovery_does_not_evaluate_provisional_divisor_or_inactive_branch():
+    class Skill1(PassiveSkill):
+        name = 'reader'
+        maxLv = 1
+        vp = 0
+        associate = [SkillEffect(skills=['target'], value=Select(
+            Equals(Read(Attr.VP), 0), 1 / Read(Attr.RATIO, 'parameter'), 1 / Read(Attr.VP),
+        ))]
+
+    class Skill2(PassiveSkill):
+        name = 'upstream'
+        maxLv = 1
+        associate = [SkillEffect(skills=['parameter'], attribute=Attr.RATIO, operation=Operation.ASSIGN, value=2)]
+
+    class Skill3(PassiveSkill):
+        name = 'parameter'
+        maxLv = 1
+        ratio = 0
+
+    class Skill4(ActiveSkill):
+        name = 'target'
+        maxLv = 1
+
+    char = character(Skill1, Skill2, Skill3, Skill4)
+    learn(char)
+    assert char.skills[-1].skillDamage == pytest.approx(.5)
+    char.skills[0].vp = 1
+    assert char.skills[-1].skillDamage == 1
+
+
+def test_typed_level_assignment_can_activate_a_previously_unlearned_source():
+    class Skill1(PassiveSkill):
+        name = 'new source'
+        maxLv = 1
+        associate = [SkillEffect(skills=['target'], value=1 + Percent(LevelTable([0, 30])))]
+
+    class Skill2(PassiveSkill):
+        name = 'activator'
+        maxLv = 1
+        associate = [SkillEffect(skills=['new source'], attribute=Attr.LEVEL, operation=Operation.ASSIGN, value=1)]
+
+    class Skill3(ActiveSkill):
+        name = 'target'
+        maxLv = 1
+
+    char = character(Skill1, Skill2, Skill3)
+    learn(char, [0, 1, 1])
+    assert char.skills[0].lv == 1
+    assert char.skills[-1].skillDamage == pytest.approx(1.3)
+    char.skills[1].lv = 0
+    assert char.skills[0].lv == 0
+    assert char.skills[-1].skillDamage == 1
+
+
+def test_typed_and_legacy_contributions_preserve_character_and_component_baselines():
+    class Skill1(PassiveSkill):
+        name = 'source'
+        maxLv = 1
+        associate = [
+            CharacterEffect(attribute=CharacterAttribute.SPIRIT, operation=Operation.ADD, value=10),
+            {'type': '$*Spirit', 'data': [0, 10]},
+            SkillEffect(skills=['target'], attribute=ExtraData(0), operation=Operation.ADD, value=20),
+            SkillEffect(skills=['target'], attribute=Power(0), operation=Operation.ASSIGN, value=0),
+            {'data': [50, 100], 'skills': ['target']},
+            SkillEffect(skills=['target'], value=1.5),
+        ]
+
+    class Skill2(ActiveSkill):
+        name = 'target'
+        maxLv = 1
+        dataplus0 = 5
+
+    char = character(Skill1, Skill2)
+    learn(char)
+    source, target = char.skills
+    assert char.Spirit == pytest.approx(121)
+    assert target.dataplus0 == 25
+    assert target.power0 == 0
+    assert target.skillDamage == pytest.approx(2)
+    with char.skill_effects.batch():
+        char.Spirit += 30
+        target.dataplus0 += 3
+    assert char.Spirit == pytest.approx(154)
+    assert target.dataplus0 == 28
+    source.lv = 0
+    assert char.Spirit == 130
+    assert target.dataplus0 == 8
+    assert not hasattr(target, 'power0')
+    assert target.skillDamage == 1
+
+
+def test_name_arrays_and_level_tables_are_snapshotted_and_filters_apply():
+    names, data = ['first'], [0, 50]
+    rule = SkillEffect(skills=names, value=1 + Percent(LevelTable(data)))
+    names.append('second')
+    data[1] = 100
+
+    class Skill1(PassiveSkill):
+        name = 'source'
+        maxLv = 1
+        vp = 1
+        associate = [
+            rule,
+            SkillEffect(value=2, except_skills=['second'], weapon=['test'], when=Equals(Read(Attr.VP), 1)),
+            SkillEffect(value=100, weapon=['other']),
+        ]
+
+    class Skill2(ActiveSkill):
+        name = 'first'
+        maxLv = 1
+
+    class Skill3(ActiveSkill):
+        name = 'second'
+        maxLv = 1
+
+    char = character(Skill1, Skill2, Skill3)
+    learn(char)
+    assert char.skills[1].skillDamage == 3
+    assert char.skills[2].skillDamage == 1
+    char.skills[0].vp = 0
+    assert char.skills[1].skillDamage == 1.5
+
+
+@pytest.mark.parametrize('factory', [
+    lambda: SkillEffect(value=1, operation='*'),
+    lambda: SkillEffect(value=1, attribute='skillDamage'),
+    lambda: SkillEffect(value=1, attribute=Attr.VP),
+    lambda: SkillEffect(value=1, skills='target'),
+    lambda: CharacterEffect(value=1, attribute=Attr.RATIO),
+    lambda: Read(Attr.DAMAGE),
+    lambda: LevelTable([0, float('inf')]),
+    lambda: SkillEffect(value=lambda: 1),
+    lambda: Power(-1),
+])
+def test_invalid_declarations_fail_at_construction(factory):
+    with pytest.raises((TypeError, ValueError)):
+        factory()
+
+
+@pytest.mark.parametrize('rule, message', [
+    (SkillEffect(skills=['missing'], value=1), '目标不存在'),
+    (SkillEffect(value=Read(Attr.LEVEL, 'missing')), '引用技能不存在'),
+    (SkillEffect(value=Read(Attr.RATIO)), '引用属性不存在'),
+    (SkillEffect(value=1 / Read(Attr.VP)), '除数为零'),
+])
+def test_invalid_reference_and_arithmetic_report_errors(rule, message):
+    class Skill1(ActiveSkill):
+        name = 'source'
+        maxLv = 1
+        associate = [rule]
+
+    with pytest.raises(ValueError, match=message):
+        learn(character(Skill1))
+
+
+def test_typed_state_cycles_are_rejected():
+    class Skill1(PassiveSkill):
+        name = 'first'
+        maxLv = 1
+        ratio = 1
+        associate = [SkillEffect(skills=['second'], attribute=Attr.RATIO, value=1.2)]
+
+    class Skill2(PassiveSkill):
+        name = 'second'
+        maxLv = 1
+        ratio = 1
+        associate = [SkillEffect(skills=['first'], attribute=Attr.RATIO, value=1.2)]
+
+    with pytest.raises(ValueError, match='循环依赖'):
+        learn(character(Skill1, Skill2))
+
+
+@pytest.mark.parametrize('category, expected', [('制式武器', 1.1), ('传世武器', 1.3), ('狄瑞吉传世武器', 1.3)])
+def test_weapon_category_selects_mastery_table(category, expected):
+    class Skill1(PassiveSkill):
+        name = 'mastery'
+        maxLv = 1
+        associate = [CharacterEffect(
+            attribute=CharacterAttribute.P_ATK_P,
+            value=1 + Percent(Select(WeaponCategoryContains('传世武器'), LevelTable([0, 30]), LevelTable([0, 10]))),
+        )]
+
+    char = character(Skill1)
+    char.PAtkP = 1
+    char.GetWeaponType = lambda: ('test', category)
+    learn(char)
+    assert char.PAtkP == pytest.approx(expected)
+
+
+def test_profession_attributes_are_local_typed_outputs():
+    from core.basic.skill_effect_types import ProfessionAttribute
+
+    class LocalAttribute(ProfessionAttribute):
+        BONUS = 'localBonus'
+        """测试职业的独立加成。"""
+
+    class OtherAttribute(ProfessionAttribute):
+        BONUS = 'localBonus'
+
+    class Source(PassiveSkill):
+        name = 'source'
+        maxLv = 1
+        associate = [SkillEffect(attribute=LocalAttribute.BONUS, operation=Operation.ADD, value=2)]
+
+    class Target(ActiveSkill):
+        name = 'target'
+        maxLv = 1
+        localBonus = 3
+
+    char = character(Source, Target)
+    learn(char)
+    assert char.skills[1].localBonus == 5
+    char.skills[0].lv = 0
+    assert char.skills[1].localBonus == 3
+    assert SkillEffect(attribute=OtherAttribute.BONUS, value=2).attribute is OtherAttribute.BONUS
+    with pytest.raises(ValueError, match='Read'):
+        Read(LocalAttribute.BONUS)
+
+
+@pytest.mark.parametrize('name', ['lv', 'skillDamage', 'power2', 'hit0', 'not-valid'])
+def test_profession_attribute_rejects_shared_or_invalid_names(name):
+    from core.basic.skill_effect_types import ProfessionAttribute
+
+    local = ProfessionAttribute('LocalAttribute', {'VALUE': name})
+    with pytest.raises(ValueError):
+        SkillEffect(attribute=local.VALUE, value=1)
+
+
+def test_composed_conditions_track_inactive_dependencies_and_skip_only_explicit_missing_targets():
+    from core.basic.skill_effect_types import All, GreaterThan, Hit, MissingTargetPolicy, Not
+
+    class Source(PassiveSkill):
+        name = 'source'
+        maxLv = 1
+        associate = [SkillEffect(
+            attribute=Hit(0), operation=Operation.ADD, value=2,
+            skills=['old missing name', 'target'], missing_target=MissingTargetPolicy.SKIP,
+            when=All([GreaterThan(Read(Attr.LEVEL, 'gate'), 0), Not(Equals(Read(Attr.LEVEL), 0))]),
+        )]
+
+    class Gate(PassiveSkill):
+        name = 'gate'
+        maxLv = 1
+
+    class Target(ActiveSkill):
+        name = 'target'
+        maxLv = 1
+        hit0 = 1
+
+    char = character(Source, Gate, Target)
+    learn(char, [1, 0, 1])
+    assert char.skills[-1].hit0 == 1
+    char.skills[1].lv = 1
+    assert char.skills[-1].hit0 == 3
+    assert ('source', 'old missing name') in char.skill_effects.unresolved_targets
+    assert Read(Attr.LEVEL, 'gate') in Source.associate[0].dependencies()
+    char.skills[1].lv = 0
+    assert char.skills[-1].hit0 == 1