444 lines
20 KiB
C#
444 lines
20 KiB
C#
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
|
||
namespace TKS
|
||
{
|
||
/// <summary>
|
||
/// 스킬 수치 질의(2026-11-10 #1112 · 효과 표 skill_effects.csv) — ActionResolver · Combat · EnemyAI · BattleManager · SlingshotInput 이 수치를 읽을 때 부른다.
|
||
/// Get(unit, key, other, crit) = 그 유닛에게 지금 걸린 효과: 패시브(대상 칸 = 자신 · 같은 편 · 진영 · 반경 · 슬링 범위) · 장착된 예약 액티브 · 시한 효과 · 보물 진영 효과.
|
||
/// 조건 칸(치명타 · 상대 상태 이상 · 병종 · 성별 · 턴 · 장착 중)은 other(공격 대상 또는 공격자)·crit 으로 판정한다. 효과가 없으면 중립값(합 0 · 곱 1).
|
||
/// note = 실제 적용 때만 true → 패시브 발동 HUD 한 줄.
|
||
/// </summary>
|
||
public static class SkillMods
|
||
{
|
||
static readonly List<SkillHit> Empty = new List<SkillHit>();
|
||
|
||
public static List<SkillHit> Get(Unit u, string key, Unit other = null, bool crit = false)
|
||
{
|
||
var sys = SkillSystem.Current;
|
||
if (sys == null || u == null) return Empty;
|
||
List<SkillHit> list = null;
|
||
foreach (var s in sys.Entries)
|
||
{
|
||
var src = s.Unit;
|
||
if (src == null) continue;
|
||
if (s.PassiveEffects != null && (src.IsAlive || s.BannerLeft > 0))
|
||
{
|
||
foreach (var e in s.PassiveEffects)
|
||
{
|
||
if (e.Key != key || !Applies(s, src, u, e, false) || !CondOk(sys, s, e, u, other, crit)) continue;
|
||
if (list == null) list = new List<SkillHit>();
|
||
list.Add(new SkillHit { Owner = s, Def = s.Passive, E = e, Passive = true });
|
||
}
|
||
}
|
||
if ((s.Armed || s.Casting) && src == u && s.ActiveEffects != null)
|
||
{
|
||
foreach (var e in s.ActiveEffects)
|
||
{
|
||
if (e.Key != key || e.Key == SkillKeys.Invuln || !CondOk(sys, s, e, u, other, crit)) continue;
|
||
if (e.Scope != SkillScope.Self && e.Dur > 0) continue; // 대상이 다른 지속 효과 = 시한 효과로만
|
||
if (list == null) list = new List<SkillHit>();
|
||
list.Add(new SkillHit { Owner = s, Def = s.Active, E = e, Passive = false });
|
||
}
|
||
}
|
||
}
|
||
foreach (var t in sys.TimedEffects)
|
||
{
|
||
if (t.E.Key != key || !TimedApplies(t, u) || !CondOk(sys, t.Owner, t.E, u, other, crit)) continue;
|
||
if (list == null) list = new List<SkillHit>();
|
||
list.Add(new SkillHit { Owner = t.Owner, Def = t.Def, E = t.E, Passive = false, Timed = t });
|
||
}
|
||
// 진영 상시 효과(보물 수집품 crit·range·splash · PD #1093 C) — 주인 없음 · HUD 한 줄 없음
|
||
var side = sys.Battle != null ? sys.Battle.SideEffects(u.Faction) : null;
|
||
if (side != null)
|
||
foreach (var e in side)
|
||
{
|
||
if (e.Key != key) continue;
|
||
if (list == null) list = new List<SkillHit>();
|
||
list.Add(new SkillHit { Owner = null, Def = null, E = e, Passive = false });
|
||
}
|
||
return list ?? Empty;
|
||
}
|
||
|
||
/// <summary>보물 전용 크리 피해 % 키(skills 표 키 아님 · SkillKeys.All 에 넣지 않음 · PD #1093 C).</summary>
|
||
public const string SideCritPct = "side_crit_pct";
|
||
|
||
/// <summary>「행동 반경」 = 주인의 기본 슬링 최대 거리(효과로 늘어난 값이 아님 — 질의가 서로 부르지 않게).</summary>
|
||
public static float BaseReach(Unit owner)
|
||
{
|
||
return owner != null ? owner.SlingMaxDistance : 0f;
|
||
}
|
||
|
||
public static bool Within(Unit owner, Unit u, float r)
|
||
{
|
||
return owner != null && u != null && Vector2.Distance(owner.Position, u.Position) <= r + u.Radius;
|
||
}
|
||
|
||
/// <summary>대상 칸 판정(dynamic = 매번 · Range 는 시한 효과에서 고정 대상으로 처리).</summary>
|
||
public static bool Applies(UnitSkills s, Unit src, Unit u, SkillEffect e, bool timed)
|
||
{
|
||
if (e.Scope == SkillScope.Self) return src == u;
|
||
if (src.Faction != u.Faction) return false;
|
||
switch (e.Scope)
|
||
{
|
||
case SkillScope.Allies: return true;
|
||
case SkillScope.Camp: return u.Camp == e.Camp && (!e.HasType || u.Type == e.Type);
|
||
case SkillScope.CampMale: return u.Camp == e.Camp && !u.Female;
|
||
case SkillScope.Radius: return u != src && Within(src, u, e.Radius);
|
||
case SkillScope.Range:
|
||
case SkillScope.Aura:
|
||
if (!src.IsAlive && s != null && s.BannerLeft > 0) return Vector2.Distance(s.BannerPos, u.Position) <= BaseReach(src) + u.Radius;
|
||
return Within(src, u, BaseReach(src));
|
||
}
|
||
return false;
|
||
}
|
||
|
||
static bool TimedApplies(SkillSystem.Timed t, Unit u)
|
||
{
|
||
if (t.Targets != null) return t.Targets.Contains(u);
|
||
var src = t.Owner != null ? t.Owner.Unit : null;
|
||
if (src == null) return false;
|
||
if (t.E.Scope != SkillScope.Self && !src.IsAlive) return false;
|
||
return Applies(t.Owner, src, u, t.E, true);
|
||
}
|
||
|
||
/// <summary>조건 칸 — self = 효과를 받는 유닛 · other = 상대(공격 대상 또는 공격자).</summary>
|
||
static bool CondOk(SkillSystem sys, UnitSkills owner, SkillEffect e, Unit self, Unit other, bool crit)
|
||
{
|
||
switch (e.Cond)
|
||
{
|
||
case SkillCondKind.None: return true;
|
||
case SkillCondKind.Crit: return crit;
|
||
case SkillCondKind.TurnLe: return sys.Battle != null && sys.Battle.TurnNumber <= e.CondN;
|
||
case SkillCondKind.Armed: return owner != null && (owner.Armed || owner.Casting);
|
||
}
|
||
if (other == null) return false;
|
||
switch (e.Cond)
|
||
{
|
||
case SkillCondKind.VsStatus: return SkillStatus.HasAny(other);
|
||
case SkillCondKind.VsBleed: return SkillStatus.Bleeding(other);
|
||
case SkillCondKind.VsConfused: return SkillStatus.Confused(other);
|
||
case SkillCondKind.VsStunned: return SkillStatus.Stunned(other);
|
||
case SkillCondKind.VsType: return other.Type == e.CondType;
|
||
case SkillCondKind.VsMale: return !other.Female;
|
||
case SkillCondKind.VsMaleHero: return !other.Female && sys.IsGeneral(other);
|
||
case SkillCondKind.VsFemaleHero: return other.Female && sys.IsGeneral(other);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
static void Note(SkillHit h, bool note)
|
||
{
|
||
if (!note || !h.Passive || SkillSystem.Current == null) return;
|
||
SkillSystem.Current.NotePassive(h.Owner, h.Def);
|
||
}
|
||
|
||
// ---------- 일반 ----------
|
||
|
||
public static float Sum(Unit u, string key, bool note = false, Unit other = null, bool crit = false)
|
||
{
|
||
float s = 0f;
|
||
foreach (var h in Get(u, key, other, crit))
|
||
{
|
||
s += h.E.P;
|
||
Note(h, note);
|
||
}
|
||
return s;
|
||
}
|
||
|
||
public static float Product(Unit u, string key, bool note = false, Unit other = null)
|
||
{
|
||
float p = 1f;
|
||
foreach (var h in Get(u, key, other))
|
||
{
|
||
p *= h.E.P;
|
||
Note(h, note);
|
||
}
|
||
return p;
|
||
}
|
||
|
||
/// <summary>Π(1 + 값) · 0 아래로 내려가지 않음(받는 피해 −% 류).</summary>
|
||
public static float PctProduct(Unit u, string key, bool note = false, Unit other = null)
|
||
{
|
||
float p = 1f;
|
||
foreach (var h in Get(u, key, other))
|
||
{
|
||
p *= Mathf.Max(0f, 1f + h.E.P);
|
||
Note(h, note);
|
||
}
|
||
return p;
|
||
}
|
||
|
||
public static bool Has(Unit u, string key, bool note = false, Unit other = null, bool crit = false)
|
||
{
|
||
var l = Get(u, key, other, crit);
|
||
foreach (var h in l) Note(h, note);
|
||
return l.Count > 0;
|
||
}
|
||
|
||
/// <summary>첫 효과(수치 칸을 그대로 쓰는 처리기) · 없으면 null.</summary>
|
||
public static SkillEffect First(Unit u, string key, bool note = false)
|
||
{
|
||
var l = Get(u, key);
|
||
if (l.Count == 0) return null;
|
||
Note(l[0], note);
|
||
return l[0].E;
|
||
}
|
||
|
||
// ---------- 슬링 거리 · 사거리 · 광역 ----------
|
||
|
||
/// <summary>
|
||
/// 슬링 최대 거리 = 기본 × (1 + 이동 % 합) × (1 + 진중 축적) × 혼란 배율 · 재행동 남은 거리 상한(감녕·고순) — 조준 · 실제 이동 · 적 AI 공용.
|
||
/// </summary>
|
||
public static float SlingMax(Unit u, bool note = false)
|
||
{
|
||
if (u == null) return 0f;
|
||
float pct = Sum(u, SkillKeys.SlingDistPct, note);
|
||
var sys = SkillSystem.Current;
|
||
var s = sys != null ? sys.Of(u) : null;
|
||
float bank = s != null ? s.Bank : 0f;
|
||
float v = u.SlingMaxDistance * Mathf.Max(0.1f, 1f + pct) * (1f + bank) * SkillStatus.ConfuseMult(u);
|
||
if (s != null && s.ReactLimit > 0f) v = Mathf.Min(v, s.ReactLimit);
|
||
return Mathf.Max(0.1f, v);
|
||
}
|
||
|
||
/// <summary>궁병·책사 사거리 = (기본 + 고지 p1(PD #1097)) × range_mult(대상·조건 칸 · 보물) · 근접 병종이 원거리로 쏠 때(축융 비도·주태 검기) = 슬링 거리 기준.</summary>
|
||
public static float Range(Unit u, bool note = false)
|
||
{
|
||
if (u == null) return 0f;
|
||
float b = UnitTypeInfo.IsRanged(u.Type) ? u.AttackRange : u.SlingMaxDistance;
|
||
float r = b + GimmickLayer.RangeBonusOf(u);
|
||
return Mathf.Max(0f, r * Product(u, SkillKeys.RangeMult, note));
|
||
}
|
||
|
||
public static float SplashRadius(Unit u, BalanceConfig cfg, bool note = false)
|
||
{
|
||
return cfg.strategistSplashRadius * Product(u, SkillKeys.SplashRadiusMult, note);
|
||
}
|
||
|
||
public static float SplashRatio(Unit u, BalanceConfig cfg, bool note = false)
|
||
{
|
||
return cfg.strategistSplashRatio;
|
||
}
|
||
|
||
/// <summary>광역 아군 비율 = 서서·제갈근 치환값(여럿이면 작은 값) · 없으면 자산 값.</summary>
|
||
public static float SplashAllyRatio(Unit u, BalanceConfig cfg, bool note = false)
|
||
{
|
||
var l = Get(u, SkillKeys.SplashAllyRatio);
|
||
if (l.Count == 0) return cfg.strategistAllyDamageRatio;
|
||
float r = float.MaxValue;
|
||
foreach (var h in l)
|
||
{
|
||
r = Mathf.Min(r, h.E.P);
|
||
Note(h, note);
|
||
}
|
||
return Mathf.Max(0f, r);
|
||
}
|
||
|
||
// ---------- 피해 ----------
|
||
|
||
/// <summary>상성 하한(불리 상성 무시 = 1 · 0 = 없음).</summary>
|
||
public static float MatchupFloor(Unit a, bool note = false)
|
||
{
|
||
float f = 0f;
|
||
foreach (var h in Get(a, SkillKeys.MatchupFloor))
|
||
{
|
||
f = Mathf.Max(f, h.E.P);
|
||
Note(h, note);
|
||
}
|
||
return f;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 공격력 배율 = (1 + 공 % 합(조건 = 상대 d) + 처치 누적 + 잃은 HP + 범위 안 아군 + 아군 전사 + 돌진 거리 + 재행동 누적 + 고육계 이월) × 「공격력의 X %」(atk_ratio) × 저HP 스킬 위력(주유).
|
||
/// </summary>
|
||
public static float AttackMult(Unit a, bool note = false, Unit d = null)
|
||
{
|
||
var sys = SkillSystem.Current;
|
||
if (sys == null || a == null) return 1f;
|
||
var s = sys.Of(a);
|
||
float pct = Sum(a, SkillKeys.AtkPct, note, d);
|
||
foreach (var h in Get(a, SkillKeys.KillStackAtk))
|
||
{
|
||
int kills = s != null ? s.Kills : 0;
|
||
if (kills <= 0) continue;
|
||
pct += Mathf.Min(h.E.HasA2 ? h.E.A2 : float.MaxValue, h.E.P * kills);
|
||
Note(h, note);
|
||
}
|
||
float missing = a.MaxHp > 0 ? Mathf.Clamp01(1f - (float)a.Hp / a.MaxHp) : 0f;
|
||
foreach (var h in Get(a, SkillKeys.AtkMissingHp))
|
||
{
|
||
if (missing <= 0f) continue;
|
||
pct += Mathf.Min(h.E.HasA2 && h.E.A2 > 0f ? h.E.A2 : float.MaxValue, h.E.P * missing);
|
||
Note(h, note);
|
||
}
|
||
foreach (var h in Get(a, SkillKeys.AtkPerAllyRange))
|
||
{
|
||
int n = 0;
|
||
foreach (var o in sys.Battle.AliveUnits(a.Faction))
|
||
if (o != a && Within(a, o, BaseReach(a))) n++;
|
||
if (n == 0) continue;
|
||
pct += h.E.P * n;
|
||
Note(h, note);
|
||
}
|
||
var deaths = Get(a, SkillKeys.OnAllyDeathAtk);
|
||
if (deaths.Count > 0)
|
||
{
|
||
int dead = DeadAllies(a);
|
||
if (dead > 0)
|
||
foreach (var h in deaths)
|
||
{
|
||
pct += h.E.P * dead;
|
||
Note(h, note);
|
||
}
|
||
}
|
||
var ctx = sys.Ctx;
|
||
if (ctx != null && ctx.Actor == a && ctx.SlingRatio > 0f)
|
||
foreach (var h in Get(a, SkillKeys.DashDmgPct))
|
||
{
|
||
pct += h.E.P * ctx.SlingRatio;
|
||
Note(h, note);
|
||
}
|
||
if (s != null && s.ReactsThisTurn > 0)
|
||
foreach (var h in Get(a, SkillKeys.ReactionAtkStack))
|
||
{
|
||
pct += h.E.P * Mathf.Pow(2f, s.ReactsThisTurn - 1);
|
||
Note(h, note);
|
||
}
|
||
if (s != null && s.AtkFlat > 0f && a.Atk > 0) pct += s.AtkFlat / a.Atk; // 고육계: 지난 턴 받은 피해 → 이번 턴 공격력
|
||
float m = Mathf.Max(0f, 1f + pct);
|
||
m *= Product(a, SkillKeys.AtkRatio, note);
|
||
if (s != null && (s.Armed || s.Casting))
|
||
foreach (var h in Get(a, SkillKeys.SkillPowerLowHp))
|
||
{
|
||
float step = h.E.HasA2 && h.E.A2 > 0f ? h.E.A2 : 0.1f;
|
||
int k = Mathf.FloorToInt(missing / step + 1e-4f);
|
||
if (k <= 0) continue;
|
||
m *= 1f + h.E.P * k;
|
||
Note(h, note);
|
||
}
|
||
return m;
|
||
}
|
||
|
||
public static int DeadAllies(Unit a)
|
||
{
|
||
var sys = SkillSystem.Current;
|
||
if (sys == null) return 0;
|
||
int n = 0;
|
||
foreach (var u in sys.Battle.Units)
|
||
if (u != null && u != a && u.Faction == a.Faction && !u.IsAlive && !SkillSystem.IsSummon(u)) n++;
|
||
return n;
|
||
}
|
||
|
||
/// <summary>주는 피해 배율 = 1 + 피해 % 합(조건 = 상대 d) + 마초 「맞힌 적 1기당」.</summary>
|
||
public static float DealtMult(Unit a, Unit d, bool note = false)
|
||
{
|
||
var sys = SkillSystem.Current;
|
||
float m = 1f + Sum(a, SkillKeys.DmgPct, note, d);
|
||
var ctx = sys != null ? sys.Ctx : null;
|
||
if (ctx != null && ctx.Actor == a && ctx.HitCount > 0)
|
||
foreach (var h in Get(a, SkillKeys.DmgPerHit))
|
||
{
|
||
m += h.E.P * ctx.HitCount;
|
||
Note(h, note);
|
||
}
|
||
return Mathf.Max(0f, m);
|
||
}
|
||
|
||
/// <summary>받는 피해 배율 = 받는 피해 %(조건 = 공격자 a) × 원거리 받는 피해 × 적 궁병 피해 × 수성(남은 이동 거리) × 노장(잃은 HP).</summary>
|
||
public static float TakenMult(Unit d, Unit a, bool note = false, bool ranged = false)
|
||
{
|
||
float m = PctProduct(d, SkillKeys.DmgTakenPct, note, a);
|
||
if (ranged) m *= PctProduct(d, SkillKeys.DmgTakenRangedPct, note, a);
|
||
if (a != null && a.Type == UnitType.Archer) m *= PctProduct(d, SkillKeys.DmgTakenFromArcherPct, note, a);
|
||
var sys = SkillSystem.Current;
|
||
var s = sys != null ? sys.Of(d) : null;
|
||
if (s != null && s.UnusedMove > 0f)
|
||
foreach (var h in Get(d, SkillKeys.UnusedMoveDr))
|
||
{
|
||
m *= Mathf.Max(0f, 1f - h.E.P * s.UnusedMove);
|
||
Note(h, note);
|
||
}
|
||
float lost = d.MaxHp > 0 ? Mathf.Clamp01(1f - (float)d.Hp / d.MaxHp) * 100f : 0f;
|
||
if (lost > 0f)
|
||
foreach (var h in Get(d, SkillKeys.LowHpTaken))
|
||
{
|
||
m *= 1f + h.E.P * lost;
|
||
Note(h, note);
|
||
}
|
||
return m;
|
||
}
|
||
|
||
// ---------- 치명타 ----------
|
||
|
||
/// <summary>크리 배율 = 자산 critMultiplier × (1 + 보물 크리 %) × (1 + 치명타 피해 % 합).</summary>
|
||
public static float CritMult(Unit a, BalanceConfig cfg, Unit d = null)
|
||
{
|
||
return cfg.critMultiplier * (1f + Sum(a, SideCritPct)) * (1f + Sum(a, SkillKeys.CritDmgPct, true, d));
|
||
}
|
||
|
||
public static float CritChance(Unit a, Unit d)
|
||
{
|
||
return Mathf.Clamp01(Sum(a, SkillKeys.CritChance, false, d));
|
||
}
|
||
|
||
public static bool CritAlways(Unit a, Unit d)
|
||
{
|
||
return Has(a, SkillKeys.CritAlways, true, d);
|
||
}
|
||
|
||
// ---------- 반격 ----------
|
||
|
||
/// <summary>받는 반격 피해 배율(공격한 유닛 a 기준 · 조건 = 반격하는 상대) · 0 = 반격 안 받음.</summary>
|
||
public static float CounterTakenMult(Unit a, Unit counterer, bool note = false)
|
||
{
|
||
return PctProduct(a, SkillKeys.CounterTakenPct, note, counterer);
|
||
}
|
||
|
||
/// <summary>주는 반격 피해 배율 = 1 + 반격 피해 % 합 + 노장(잃은 HP 1 %당 p2).</summary>
|
||
public static float CounterDmgMult(Unit counterer, bool note = false)
|
||
{
|
||
float m = 1f + Sum(counterer, SkillKeys.CounterDmgPct, note);
|
||
float lost = counterer.MaxHp > 0 ? Mathf.Clamp01(1f - (float)counterer.Hp / counterer.MaxHp) * 100f : 0f;
|
||
if (lost > 0f)
|
||
foreach (var h in Get(counterer, SkillKeys.LowHpTaken))
|
||
if (h.E.HasA2) m += h.E.A2 * lost;
|
||
return Mathf.Max(0f, m);
|
||
}
|
||
|
||
// ---------- 밀기 · 튕김 ----------
|
||
|
||
public static float PushMult(Unit actor, bool note = false)
|
||
{
|
||
return Mathf.Max(0f, Product(actor, SkillKeys.PushMult, note));
|
||
}
|
||
|
||
public static float SelfBounceMult(Unit actor, bool note = false)
|
||
{
|
||
return Mathf.Max(0f, Product(actor, SkillKeys.SelfBounceMult, note));
|
||
}
|
||
|
||
/// <summary>밀리는 거리 배율(거구 −100 % = 안 밀림).</summary>
|
||
public static float KnockbackTakenMult(Unit target, bool note = false)
|
||
{
|
||
return PctProduct(target, SkillKeys.KnockbackTakenPct, note);
|
||
}
|
||
|
||
/// <summary>서황 대부: 도끼가 도는 동안 자신을 공격한 유닛은 × p3 멀리 튕긴다.</summary>
|
||
public static float AxeBounce(Unit struck)
|
||
{
|
||
if (struck == null) return 1f;
|
||
float m = 1f;
|
||
foreach (var h in Get(struck, SkillKeys.AxeAura))
|
||
if (h.E.HasA3) m = Mathf.Max(m, h.E.A3);
|
||
return m;
|
||
}
|
||
|
||
/// <summary>전위 고지악래: 지형 오브젝트 밀기 거리·그것으로 준 피해 배율.</summary>
|
||
public static float GimmickMult(Unit u)
|
||
{
|
||
return u != null ? Mathf.Max(0f, Product(u, SkillKeys.GimmickMult, true)) : 1f;
|
||
}
|
||
}
|
||
}
|