284 lines
9.8 KiB
Python
284 lines
9.8 KiB
Python
from __future__ import annotations
|
||
|
||
from dataclasses import dataclass, field
|
||
from enum import Enum
|
||
from typing import Optional, Dict, List
|
||
import json
|
||
from src.classes.effect import load_effect_from_str
|
||
|
||
from src.utils.df import game_configs
|
||
from src.classes.alignment import Alignment
|
||
from src.classes.root import Root, RootElement
|
||
|
||
|
||
class TechniqueAttribute(Enum):
|
||
GOLD = "金"
|
||
WOOD = "木"
|
||
WATER = "水"
|
||
FIRE = "火"
|
||
EARTH = "土"
|
||
ICE = "冰"
|
||
WIND = "风"
|
||
DARK = "暗"
|
||
THUNDER = "雷"
|
||
EVIL = "邪"
|
||
|
||
def __str__(self) -> str:
|
||
return self.value
|
||
|
||
|
||
class TechniqueGrade(Enum):
|
||
LOWER = "下品"
|
||
MIDDLE = "中品"
|
||
UPPER = "上品"
|
||
|
||
@staticmethod
|
||
def from_str(s: str) -> "TechniqueGrade":
|
||
s = str(s).strip()
|
||
if s == "上品":
|
||
return TechniqueGrade.UPPER
|
||
if s == "中品":
|
||
return TechniqueGrade.MIDDLE
|
||
return TechniqueGrade.LOWER
|
||
|
||
|
||
@dataclass
|
||
class Technique:
|
||
id: int
|
||
name: str
|
||
attribute: TechniqueAttribute
|
||
grade: TechniqueGrade
|
||
desc: str
|
||
weight: float
|
||
condition: str
|
||
# 归属宗门名称；None/空表示无宗门要求（散修可修）
|
||
sect: Optional[str] = None
|
||
# 影响角色或系统的效果
|
||
effects: dict[str, object] = field(default_factory=dict)
|
||
|
||
def is_allowed_for(self, avatar) -> bool:
|
||
if not self.condition:
|
||
return True
|
||
return bool(eval(self.condition, {"__builtins__": {}}, {"avatar": avatar, "Alignment": Alignment}))
|
||
|
||
def get_info(self) -> str:
|
||
return f"{self.name}（{self.attribute}）{self.grade.value}"
|
||
|
||
def get_detailed_info(self) -> str:
|
||
return f"{self.name}（{self.attribute}）{self.grade.value} {self.desc}"
|
||
|
||
# 五行与扩展属性的克制关系
|
||
# - 五行：金克木，木克土，土克水，水克火，火克金
|
||
# - 雷克邪；邪、冰、风、暗不克任何人
|
||
SUPPRESSION: dict[TechniqueAttribute, set[TechniqueAttribute]] = {
|
||
TechniqueAttribute.GOLD: {TechniqueAttribute.WOOD},
|
||
TechniqueAttribute.WOOD: {TechniqueAttribute.EARTH},
|
||
TechniqueAttribute.EARTH: {TechniqueAttribute.WATER},
|
||
TechniqueAttribute.WATER: {TechniqueAttribute.FIRE},
|
||
TechniqueAttribute.FIRE: {TechniqueAttribute.GOLD},
|
||
TechniqueAttribute.THUNDER: {TechniqueAttribute.EVIL},
|
||
TechniqueAttribute.ICE: set(),
|
||
TechniqueAttribute.WIND: set(),
|
||
TechniqueAttribute.DARK: set(),
|
||
TechniqueAttribute.EVIL: set(),
|
||
}
|
||
|
||
|
||
def loads() -> tuple[dict[int, Technique], dict[str, Technique]]:
|
||
techniques_by_id: dict[int, Technique] = {}
|
||
techniques_by_name: dict[str, Technique] = {}
|
||
df = game_configs["technique"]
|
||
for _, row in df.iterrows():
|
||
attr = TechniqueAttribute(str(row["technique_root"]).strip())
|
||
name = str(row["name"]).strip()
|
||
grade = TechniqueGrade.from_str(row.get("grade", "下品"))
|
||
cond_val = row.get("condition", "")
|
||
condition = "" if str(cond_val) == "nan" else str(cond_val).strip()
|
||
weight_val = row.get("weight", 1)
|
||
weight = float(str(weight_val)) if str(weight_val) != "nan" else 1.0
|
||
sect_val = row.get("sect", "")
|
||
sect = None if str(sect_val) == "nan" or str(sect_val).strip() == "" else str(sect_val).strip()
|
||
# 读取 effects（兼容 JSON/单引号字面量/空）
|
||
effects = load_effect_from_str(row.get("effects", ""))
|
||
|
||
t = Technique(
|
||
id=int(row["id"]),
|
||
name=name,
|
||
attribute=attr,
|
||
grade=grade,
|
||
desc=str(row.get("desc", "")),
|
||
weight=weight,
|
||
condition=condition,
|
||
sect=sect,
|
||
effects=effects,
|
||
)
|
||
techniques_by_id[t.id] = t
|
||
techniques_by_name[t.name] = t
|
||
return techniques_by_id, techniques_by_name
|
||
|
||
|
||
techniques_by_id, techniques_by_name = loads()
|
||
|
||
|
||
def is_attribute_compatible_with_root(attr: TechniqueAttribute, root: Root) -> bool:
|
||
if attr == TechniqueAttribute.EVIL:
|
||
# 邪功法仅由阵营约束，这里视为与灵根无关
|
||
return True
|
||
|
||
# 天灵根：除邪外全系可修
|
||
if root == Root.HEAVEN:
|
||
return attr != TechniqueAttribute.EVIL
|
||
|
||
# 单属性灵根：只能修行对应属性
|
||
single_map = {
|
||
Root.GOLD: TechniqueAttribute.GOLD,
|
||
Root.WOOD: TechniqueAttribute.WOOD,
|
||
Root.WATER: TechniqueAttribute.WATER,
|
||
Root.FIRE: TechniqueAttribute.FIRE,
|
||
Root.EARTH: TechniqueAttribute.EARTH,
|
||
}
|
||
if root in single_map:
|
||
return attr == single_map[root]
|
||
|
||
# 复合/扩展灵根：根名属性 + 其元素列表中的属性
|
||
complex_map: dict[Root, set[TechniqueAttribute]] = {
|
||
Root.ICE: {TechniqueAttribute.ICE, TechniqueAttribute.GOLD, TechniqueAttribute.WATER},
|
||
Root.WIND: {TechniqueAttribute.WIND, TechniqueAttribute.WOOD, TechniqueAttribute.WATER},
|
||
Root.DARK: {TechniqueAttribute.DARK, TechniqueAttribute.FIRE, TechniqueAttribute.EARTH},
|
||
Root.THUNDER: {TechniqueAttribute.THUNDER, TechniqueAttribute.WATER, TechniqueAttribute.EARTH},
|
||
}
|
||
if root in complex_map:
|
||
return attr in complex_map[root]
|
||
|
||
return False
|
||
|
||
def get_random_technique_for_avatar(avatar) -> Technique:
|
||
import random
|
||
candidates: List[Technique] = []
|
||
for t in techniques_by_id.values():
|
||
if not t.is_allowed_for(avatar):
|
||
continue
|
||
if t.attribute == TechniqueAttribute.EVIL and avatar.alignment != Alignment.EVIL:
|
||
continue
|
||
if not is_attribute_compatible_with_root(t.attribute, avatar.root):
|
||
continue
|
||
candidates.append(t)
|
||
if not candidates:
|
||
# 回退：不考虑条件，仅按灵根兼容挑选（若仍为空，则全量）
|
||
fallback = [
|
||
t for t in techniques_by_id.values()
|
||
if (t.attribute != TechniqueAttribute.EVIL) and is_attribute_compatible_with_root(t.attribute, avatar.root)
|
||
]
|
||
candidates = fallback or list(techniques_by_id.values())
|
||
weights = [max(0.0, t.weight) for t in candidates]
|
||
return random.choices(candidates, weights=weights, k=1)[0]
|
||
|
||
|
||
def get_random_upper_technique_for_avatar(avatar) -> Technique | None:
|
||
"""
|
||
返回一个与 avatar 灵根/阵营/条件相容的上品功法；若无则返回 None。
|
||
仅用于奇遇奖励优先挑选上品功法。
|
||
"""
|
||
import random
|
||
candidates: List[Technique] = []
|
||
for t in techniques_by_id.values():
|
||
if t.grade is not TechniqueGrade.UPPER:
|
||
continue
|
||
if not t.is_allowed_for(avatar):
|
||
continue
|
||
if t.attribute == TechniqueAttribute.EVIL and avatar.alignment != Alignment.EVIL:
|
||
continue
|
||
if not is_attribute_compatible_with_root(t.attribute, avatar.root):
|
||
continue
|
||
candidates.append(t)
|
||
if not candidates:
|
||
return None
|
||
weights = [max(0.0, t.weight) for t in candidates]
|
||
return random.choices(candidates, weights=weights, k=1)[0]
|
||
|
||
def get_technique_by_sect(sect) -> Technique:
|
||
"""
|
||
简化版：仅按宗门筛选并按权重抽样，不考虑灵根与 condition。
|
||
- 散修（sect 为 None/空）：只从无宗门要求（sect 为空）的功法中抽样；
|
||
- 有宗门：从“无宗门 + 该宗门”的功法中抽样；
|
||
若集合为空，则退回全量功法。
|
||
"""
|
||
import random
|
||
|
||
sect_name: Optional[str] = None
|
||
if sect is not None:
|
||
sect_name = getattr(sect, "name", sect)
|
||
if isinstance(sect_name, str):
|
||
sect_name = sect_name.strip() or None
|
||
|
||
allowed_sects: set[Optional[str]] = {None, ""}
|
||
if sect_name is not None:
|
||
allowed_sects.add(sect_name)
|
||
|
||
def _in_allowed_sect(t: Technique) -> bool:
|
||
return (t.sect in allowed_sects) or (t.sect is None) or (t.sect == "")
|
||
|
||
candidates: List[Technique] = [t for t in techniques_by_id.values() if _in_allowed_sect(t)]
|
||
if not candidates:
|
||
candidates = list(techniques_by_id.values())
|
||
weights = [max(0.0, t.weight) for t in candidates]
|
||
return random.choices(candidates, weights=weights, k=1)[0]
|
||
|
||
|
||
def get_grade_bonus(grade: TechniqueGrade) -> float:
|
||
if grade is TechniqueGrade.UPPER:
|
||
return 0.10
|
||
if grade is TechniqueGrade.MIDDLE:
|
||
return 0.05
|
||
return 0.0
|
||
|
||
|
||
def get_suppression_bonus(att_attr: TechniqueAttribute, def_attr: TechniqueAttribute) -> float:
|
||
return 0.10 if def_attr in SUPPRESSION.get(att_attr, set()) else 0.0
|
||
|
||
|
||
# 相对品阶优势加成：按“品阶差×步进”的方式计算
|
||
# - 品阶映射：下品=0，中品=1，上品=2
|
||
# - 每级差距步进：5%（最大±10%）
|
||
_GRADE_RANK: dict[TechniqueGrade, int] = {
|
||
TechniqueGrade.LOWER: 0,
|
||
TechniqueGrade.MIDDLE: 1,
|
||
TechniqueGrade.UPPER: 2,
|
||
}
|
||
|
||
|
||
def get_grade_advantage_bonus(attacker_grade: Optional[TechniqueGrade], defender_grade: Optional[TechniqueGrade]) -> float:
|
||
"""
|
||
根据双方品阶差计算进攻方的相对加成：
|
||
- diff = rank(att) - rank(def)
|
||
- bonus = 0.05 × diff，夹紧到 [-0.10, 0.10]
|
||
- 任一为空则视为无加成
|
||
返回：进攻方概率或伤害的相对加成（可为负）。
|
||
"""
|
||
if attacker_grade is None or defender_grade is None:
|
||
return 0.0
|
||
diff = _GRADE_RANK[attacker_grade] - _GRADE_RANK[defender_grade]
|
||
bonus = 0.05 * diff
|
||
if bonus > 0.10:
|
||
bonus = 0.10
|
||
if bonus < -0.10:
|
||
bonus = -0.10
|
||
return bonus
|
||
|
||
|
||
|
||
# 将功法属性映射为默认的灵根（邪功法不返回）
|
||
def attribute_to_root(attr: TechniqueAttribute) -> Optional[Root]:
|
||
mapping: dict[TechniqueAttribute, Root] = {
|
||
TechniqueAttribute.GOLD: Root.GOLD,
|
||
TechniqueAttribute.WOOD: Root.WOOD,
|
||
TechniqueAttribute.WATER: Root.WATER,
|
||
TechniqueAttribute.FIRE: Root.FIRE,
|
||
TechniqueAttribute.EARTH: Root.EARTH,
|
||
TechniqueAttribute.THUNDER: Root.THUNDER,
|
||
TechniqueAttribute.ICE: Root.ICE,
|
||
TechniqueAttribute.WIND: Root.WIND,
|
||
TechniqueAttribute.DARK: Root.DARK,
|
||
}
|
||
return mapping.get(attr)
|