ThreeKingdomsSlingshot/Assets/Scripts/OutGame/Awaken/AwakenRules.cs

518 lines
24 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System;
using System.Collections.Generic;
using System.Globalization;
using UnityEngine;
namespace TKS.OutGame
{
/// <summary>비서 교환에 쓸 영웅 조각 한 줄(남는 몫 = 보유 − 앞으로 그 영웅에 쓸 몫).</summary>
public class SpareShard
{
public HeroDb.Hero h;
public HeroState s;
public int owned;
public int need;
public int Spare
{
get { return Mathf.Max(0, owned - need); }
}
}
/// <summary>
/// 영웅 각성 · 진화 · 비서 교환 규칙(2026-11-20 요청서 §2 · §5 2차 · PD 구현 지시) — 표 = AwakenDb + EvolveTable(evolve_stars) · 상태 = HeroState.awaken · inv.goods · tomeShop.
/// 진화 = ★ +1 · 조건 = 지금 ★ 최대 레벨 · 재료 = 영웅 진영의 n_tier 비서 × n_item + 골드 · 각성 칸과 상관없음.
/// 각성 칸 = 승급 장비 6칸을 모두 그 등급 장비로 채우면 1칸(awaken_slots) · 새 칸 = 무료 1회 굴림(장착 순간 · OutGameSession.Equip).
/// 각성 = 보이는 줄 가운데 잠그지 않은 줄을 모두 다시 굴림(등급 → 능력치(겹침 제외) → 값(그 등급 범위 · 소수 1자리)) · 비용 = 잠금 수 · 바로 적용.
/// 능력치 반영 = 공격 · 체력 · 방어 % → HeroRules.Compute 배율(전투력 포함 · 보물 세트와 같은 영웅 스탯 키) · 그 밖 7종 → 유닛 추가 효과(SkillMods 질의 · 출전 편성 LineupEntry.extraEffects).
/// </summary>
public static class AwakenRules
{
// ---------- 재화 ----------
public static int Goods(SaveData d, string key)
{
return d != null && d.inv != null ? Counts.Get(d.inv.goods, key) : 0;
}
public static void AddGoods(SaveData d, string key, int n)
{
if (d == null || string.IsNullOrEmpty(key) || n == 0) return;
if (d.inv.goods == null) d.inv.goods = new List<CountEntry>();
Counts.Add(d.inv.goods, key, n);
}
// ---------- 진화 · 레벨 상한 ----------
/// <summary>그 ★ 의 최대 레벨(evolve_stars n_max_lv · 없으면 레벨 표 끝).</summary>
public static int StarMaxLv(OutGameData db, int star)
{
var r = db.Evolve != null ? db.Evolve.Get(star) : null;
return r != null && r.maxLv > 0 ? r.maxLv : db.Levels.MaxLevel;
}
/// <summary>영웅 레벨 상한 = min(★ 최대 레벨, 챕터 상한) · 병사 = 챕터 상한(evolve_config level_cap).</summary>
public static int HeroLevelCap(OutGameData db, SaveData d, LevelState s)
{
int cap = HeroRules.LevelCap(db, d);
var hs = s as HeroState;
if (hs != null) cap = Mathf.Min(cap, StarMaxLv(db, hs.star));
return cap;
}
/// <summary>다음 ★ 진화 행(최고 ★ = null).</summary>
public static EvolveTable.Row NextRow(OutGameData db, HeroState hs)
{
return hs != null && db.Evolve != null ? db.Evolve.Get(hs.star + 1) : null;
}
/// <summary>다음 진화 재료 = 영웅 진영(evolve_config item_by)의 그 등급 비서.</summary>
public static AwakenDb.Item EvolveItem(OutGameData db, HeroDb.Hero h, HeroState hs)
{
var next = NextRow(db, hs);
return next != null && db.Awaken != null && h != null ? db.Awaken.ItemOf(h.faction, next.tier) : null;
}
/// <summary>null = 진화 가능 · 아니면 사유.</summary>
public static string CanEvolve(OutGameData db, SaveData d, HeroDb.Hero h, HeroState hs)
{
if (h == null || hs == null || h.isSoldier || db.Awaken == null) return "진화 없음";
var next = NextRow(db, hs);
if (next == null) return "최고 ★";
if (AwakenDb.ToInt(db.Awaken.EvCfg("need_max_lv")) > 0 && hs.lv < StarMaxLv(db, hs.star)) return "최대 레벨 도달 필요 Lv " + hs.lv + " / " + StarMaxLv(db, hs.star);
var it = EvolveItem(db, h, hs);
if (it == null) return "진화 재료 없음";
int have = Goods(d, it.key);
if (have < next.item) return it.nameKo + " " + have + " / " + next.item;
if (d.gold < next.gold) return "골드 부족 " + d.gold.ToString("N0") + " / " + next.gold.ToString("N0");
return null;
}
/// <summary>진화 → ★ +1 · 재료 · 골드 소모(각성 칸과는 상관없다 · 2차 §5-1-3) · 실패 = false.</summary>
public static bool Evolve(OutGameData db, SaveData d, HeroDb.Hero h, HeroState hs)
{
if (CanEvolve(db, d, h, hs) != null) return false;
var next = NextRow(db, hs);
var it = EvolveItem(db, h, hs);
AddGoods(d, it.key, -next.item);
d.gold -= next.gold;
hs.star++;
return true;
}
// ---------- 각성 칸 = 승급 장비 등급(2차 §5-1) ----------
/// <summary>
/// 다 채운 승급 장비 등급(gear_items 순서)의 최댓값 — 지금보다 낮은 승급 등급의 요구 장비(승급했으니 6칸을 다 채웠음) + 지금 등급의 요구 장비(6칸이 다 찼으면).
/// 저장 값 없이 승급 등급 + 장착 상태로 계산 → 승급으로 장비가 비어도 열린 칸은 그대로.
/// </summary>
public static int FilledGearOrder(OutGameData db, HeroDb.Hero h, HeroState hs)
{
if (h == null || hs == null || h.isSoldier || db.Gear == null || db.Promotion == null || db.Heroes == null) return 0;
var cur = db.Promotion.Get(hs.grade);
int curOrder = cur != null ? cur.order : 0, best = 0;
foreach (var p in db.Promotion.rows)
{
if (p.order > curOrder) continue;
var list = db.Heroes.GearFor(h, p.grade);
if (list == null || list.Count == 0) continue;
if (p.order == curOrder && HeroRules.EquippedCount(hs) < list.Count) continue;
int o = int.MaxValue;
foreach (var gid in list)
{
var g = db.Gear.Get(gid);
o = Mathf.Min(o, g != null ? g.order : 0);
}
best = Mathf.Max(best, o);
}
return best;
}
/// <summary>열린 각성 칸 수 = awaken_slots 앞에서부터 「그 등급 장비 6칸을 다 채움」인 줄 수(s_gear_grade 빈 줄 = 안 열림).</summary>
public static int OpenSlots(OutGameData db, HeroState hs)
{
if (hs == null || db.Awaken == null || db.Heroes == null) return 0;
int filled = FilledGearOrder(db, db.Heroes.Get(hs.id), hs), n = 0;
foreach (var sl in db.Awaken.slots)
{
int o = sl.gearGrade.Length > 0 ? db.Gear.OrderOf(sl.gearGrade) : 0;
if (o <= 0 || o > filled) break;
n++;
}
return n;
}
/// <summary>각성 칸 수의 최댓값(awaken_slots 줄 수).</summary>
public static int MaxSlots(OutGameData db)
{
return db.Awaken != null ? db.Awaken.slots.Count : 0;
}
/// <summary>적용 · 표시하는 줄 수 = min(저장된 줄, 열린 칸) — 넘는 줄(1차 ★ 기준으로 열렸던 줄)은 보관만(§5-1-5).</summary>
public static int Shown(OutGameData db, HeroState hs)
{
return hs != null && hs.awaken != null ? Mathf.Min(hs.awaken.Count, db != null ? OpenSlots(db, hs) : hs.awaken.Count) : 0;
}
/// <summary>awaken_config lock_max 「open-n」 의 n(형식이 아니면 −1).</summary>
public static int LockOffset(string v)
{
int n;
if (v == null || !v.StartsWith("open-") || !int.TryParse(v.Substring(5), NumberStyles.Integer, CultureInfo.InvariantCulture, out n)) return -1;
return n;
}
public static int LockMax(OutGameData db, HeroState hs)
{
return Mathf.Max(0, OpenSlots(db, hs) - Mathf.Max(0, LockOffset(db.Awaken.Cfg("lock_max"))));
}
/// <summary>보이는 줄 가운데 잠근 수.</summary>
public static int Locks(OutGameData db, HeroState hs)
{
int n = 0, shown = Shown(db, hs);
for (int i = 0; i < shown; i++)
if (hs.awaken[i].locked) n++;
return n;
}
/// <summary>각성 1회 비용(잠금 수 → awaken_cost n_stone).</summary>
public static int Cost(OutGameData db, HeroState hs)
{
return db.Awaken.CostFor(Locks(db, hs));
}
/// <summary>열린 칸만큼 줄을 채운다(새 칸 = open_free_roll 만큼 무료 굴림) · 반환 = 새 줄.</summary>
public static List<AwakenLine> Sync(OutGameData db, HeroState hs, System.Random rng)
{
var added = new List<AwakenLine>();
if (hs == null || db.Awaken == null) return added;
if (hs.awaken == null) hs.awaken = new List<AwakenLine>();
int open = OpenSlots(db, hs);
bool free = AwakenDb.ToInt(db.Awaken.Cfg("open_free_roll")) > 0;
while (hs.awaken.Count < open)
{
var line = new AwakenLine();
hs.awaken.Add(line);
if (free) RollLine(db, hs, line, rng, null);
added.Add(line);
}
return added;
}
static float Pick(System.Random rng, float sum)
{
return (float)(rng.NextDouble() * sum);
}
/// <summary>한 줄 굴림 = ① 등급(가중치) ② 능력치(가중치 · used 와 겹치면 제외) ③ 값(그 등급 범위 균등 · 소수 1자리).</summary>
static void RollLine(OutGameData db, HeroState hs, AwakenLine line, System.Random rng, HashSet<string> used)
{
var aw = db.Awaken;
float sum = aw.GradeWeightSum, at = Pick(rng, sum);
AwakenDb.Grade grade = aw.grades[aw.grades.Count - 1];
foreach (var g in aw.grades)
{
if (at < g.weight)
{
grade = g;
break;
}
at -= g.weight;
}
if (used == null)
{
used = new HashSet<string>();
foreach (var l in hs.awaken)
if (l != line && !string.IsNullOrEmpty(l.stat)) used.Add(l.stat);
}
bool unique = AwakenDb.ToInt(aw.Cfg("unique_stat")) > 0;
var pool = new List<AwakenDb.Stat>();
float ws = 0f;
foreach (var s in aw.stats)
if (!unique || !used.Contains(s.stat))
{
pool.Add(s);
ws += s.weight;
}
if (pool.Count == 0) pool.AddRange(aw.stats);
AwakenDb.Stat stat = pool[pool.Count - 1];
at = Pick(rng, ws);
foreach (var s in pool)
{
if (at < s.weight)
{
stat = s;
break;
}
at -= s.weight;
}
int gi = Mathf.Clamp(grade.order - 1, 0, stat.min.Length - 1);
float v = Mathf.Lerp(stat.min[gi], stat.max[gi], (float)rng.NextDouble());
line.grade = grade.grade;
line.stat = stat.stat;
line.value = Mathf.Round(v * 10f) / 10f;
used.Add(stat.stat);
}
/// <summary>잠그지 않은 줄 가운데 warn_grade 이상(각성 전 경고 창 · 다시 묻지 않기 없음).</summary>
public static List<AwakenLine> Warn(OutGameData db, HeroState hs)
{
var res = new List<AwakenLine>();
var w = db.Awaken.GradeOf(db.Awaken.Cfg("warn_grade"));
if (w == null || hs == null) return res;
int shown = Shown(db, hs);
for (int i = 0; i < shown; i++)
{
var l = hs.awaken[i];
var g = db.Awaken.GradeOf(l.grade);
if (!l.locked && g != null && g.order >= w.order) res.Add(l);
}
return res;
}
public static string CanRoll(OutGameData db, SaveData d, HeroDb.Hero h, HeroState hs)
{
if (h == null || hs == null || h.isSoldier || db.Awaken == null) return "각성 없음";
int shown = Shown(db, hs);
if (shown == 0) return "열린 칸 없음";
if (Locks(db, hs) >= shown) return "잠그지 않은 줄이 없습니다";
int cost = Cost(db, hs);
if (cost < 0) return "잠금 비용 없음";
int have = Goods(d, db.Awaken.StoneKey);
if (have < cost) return StoneName(db) + " 부족 " + have + " / " + cost;
return null;
}
public static string StoneName(OutGameData db)
{
var g = db.Awaken.GoodOf(db.Awaken.StoneKey);
return g != null ? g.nameKo : db.Awaken.StoneKey;
}
/// <summary>각성 1회 — 보이는 줄 가운데 잠그지 않은 줄을 모두 다시 굴림(겹침 제외 = 잠근 줄 · 보관 줄) · 바로 적용(되돌리기 없음) · 실패 = false.</summary>
public static bool Roll(OutGameData db, SaveData d, HeroDb.Hero h, HeroState hs, System.Random rng)
{
if (CanRoll(db, d, h, hs) != null) return false;
AddGoods(d, db.Awaken.StoneKey, -Cost(db, hs));
int shown = Shown(db, hs);
var used = new HashSet<string>();
for (int i = 0; i < hs.awaken.Count; i++)
if (i >= shown || hs.awaken[i].locked) used.Add(hs.awaken[i].stat);
for (int i = 0; i < shown; i++)
if (!hs.awaken[i].locked) RollLine(db, hs, hs.awaken[i], rng, used);
return true;
}
/// <summary>잠금 켜고 끄기 — 잠금 상한(열린 칸 − 1)을 넘으면 사유(null = 됨).</summary>
public static string ToggleLock(OutGameData db, HeroState hs, int idx)
{
if (hs == null || idx < 0 || idx >= Shown(db, hs)) return "없는 줄";
var l = hs.awaken[idx];
if (!l.locked && Locks(db, hs) >= LockMax(db, hs)) return "lock_last";
l.locked = !l.locked;
return null;
}
/// <summary>그 능력치 합(보이는 줄 값 합).</summary>
public static float Total(OutGameData db, HeroState hs, string stat)
{
float s = 0f;
int shown = Shown(db, hs);
for (int i = 0; i < shown; i++)
if (hs.awaken[i].stat == stat) s += hs.awaken[i].value;
return s;
}
/// <summary>영웅 스탯 배율로 반영하는 능력치(Compute 의 hp · atk · def) → 각성 키.</summary>
public static string CoreKey(string stat)
{
switch (stat)
{
case "hp": return "hp_pct";
case "atk": return "atk_pct";
case "def": return "def_pct";
}
return "";
}
/// <summary>
/// 각성 능력치 → 유닛 추가 효과(SkillMods 키 · 값 단위 = 그 키의 처리 방식) — 공격 · 체력 · 방어 % 는 보물 세트 효과와 같은 영웅 스탯 배율(Compute)이라 여기 없음.
/// 「받는 ~ 피해 감소」(counter_taken_pct · dmg_taken_ranged_pct) = 값만큼 줄임 = 음수(기획 세션 확정 2026-11-20 · 요청서 §2-5).
/// </summary>
public static List<SkillEffect> Effects(OutGameData db, HeroState hs)
{
var res = new List<SkillEffect>();
if (hs == null || hs.awaken == null || hs.awaken.Count == 0) return res;
var sums = new Dictionary<string, float>();
int shown = Shown(db, hs); // db = null(임포트 검증) = 모든 줄
for (int i = 0; i < shown; i++)
{
var l = hs.awaken[i];
if (string.IsNullOrEmpty(l.stat)) continue;
float v;
sums.TryGetValue(l.stat, out v);
sums[l.stat] = v + l.value;
}
foreach (var kv in sums)
{
float p;
switch (kv.Key)
{
case SkillKeys.CritChance:
case SkillKeys.CritDmgPct:
case SkillKeys.SlingDistPct:
case SkillKeys.CounterDmgPct:
p = kv.Value / 100f; // 합산 키(0.2 = +20 %)
break;
case SkillKeys.PushMult:
p = 1f + kv.Value / 100f; // 곱 키(2 = ×2)
break;
case SkillKeys.CounterTakenPct:
case SkillKeys.DmgTakenRangedPct:
p = -kv.Value / 100f; // 받는 반격 · 원거리 피해 감소 = 음수(Π(1 + 값) · −0.5 = 반감)
break;
default:
continue;
}
res.Add(new SkillEffect { Key = kv.Key, P = p });
}
return res;
}
/// <summary>그 능력치를 전투 · 스탯에 반영하는 법을 코드가 아는가(임포터 검증 — 모르는 키가 표시만 되고 효과가 없는 일을 막는다).</summary>
public static bool Known(string stat)
{
if (stat == CoreKey("hp") || stat == CoreKey("atk") || stat == CoreKey("def")) return true;
var hs = new HeroState { awaken = new List<AwakenLine> { new AwakenLine { stat = stat, value = 1f } } };
return Effects(null, hs).Count > 0;
}
/// <summary>각성 몫 전투력 = 각성 포함 − 각성 뺀 전투력.</summary>
public static int Power(OutGameData db, BalanceConfig cfg, HeroDb.Hero h, HeroState hs, SaveData save)
{
if (h == null || hs == null) return 0;
int with = HeroRules.Compute(db, cfg, h, hs, save).power;
var keep = hs.awaken;
hs.awaken = new List<AwakenLine>();
int without = HeroRules.Compute(db, cfg, h, hs, save).power;
hs.awaken = keep;
return with - without;
}
// ---------- 비서 교환 ----------
public static string WeekKey(OutGameData db, DateTime nowUtc)
{
return "W" + MissionRules.WeekStartFor(db.Awaken.EvCfg("shop_reset"), nowUtc).ToString("yyyyMMdd", CultureInfo.InvariantCulture);
}
static void RollWeek(OutGameData db, SaveData d, DateTime nowUtc)
{
if (d.tomeShop == null) d.tomeShop = new TomeShopState();
var wk = WeekKey(db, nowUtc);
if (d.tomeShop.week == wk) return;
d.tomeShop = new TomeShopState { week = wk };
}
/// <summary>이번 주 남은 교환 수(조각 · 등용 포인트 공유).</summary>
public static int Left(OutGameData db, SaveData d, AwakenDb.Item it, DateTime nowUtc)
{
RollWeek(db, d, nowUtc);
return Mathf.Max(0, it.weekLimit - Counts.Get(d.tomeShop.bought, it.key));
}
/// <summary>
/// 앞으로 그 영웅에 쓸 조각(evolve_config spare_shards owned-need · 2차 §5-2-6) = 스킬 강화에 남은 조각(액티브 + 패시브 · 지금 레벨 → 최고 레벨 · skill_upgrade).
/// 미보유 영웅 조각(연의 전기 주역 등)은 교환에 쓰지 않는다(기획 세션 확정 2026-11-20) · 만능 조각은 교환에 쓰지 않는다.
/// </summary>
public static int NeedShards(OutGameData db, SaveData d, HeroDb.Hero h, HeroState hs)
{
int n = 0;
for (int i = 0; i < 2; i++) n += SkillRules.ShardsToMax(db, h, hs, i);
return n;
}
/// <summary>그 진영 보유 영웅 조각(남는 몫이 많은 순 · evolve_config auto_pick spare_first).</summary>
public static List<SpareShard> Spares(OutGameData db, SaveData d, string faction)
{
var res = new List<SpareShard>();
foreach (var h in db.Heroes.heroes)
{
if (h.isSoldier || h.faction != faction) continue;
var hs = d.Hero(h.id);
if (hs == null) continue;
res.Add(new SpareShard { h = h, s = hs, owned = hs.shards, need = NeedShards(db, d, h, hs) });
}
res.Sort((a, b) => b.Spare != a.Spare ? b.Spare.CompareTo(a.Spare) : b.owned.CompareTo(a.owned));
return res;
}
/// <summary>조각 자동 고르기 = 남는 몫만 · 많이 남은 영웅부터 → 모자라면 필요 몫에서(warn = true) · 다 해도 모자라면 null.</summary>
public static List<KeyValuePair<HeroState, int>> PickShards(OutGameData db, SaveData d, string faction, int amount, out bool warn)
{
warn = false;
var res = new List<KeyValuePair<HeroState, int>>();
var list = Spares(db, d, faction);
int left = amount;
foreach (var s in list)
{
if (left <= 0) break;
int take = Mathf.Min(left, s.Spare);
if (take > 0) res.Add(new KeyValuePair<HeroState, int>(s.s, take));
left -= take;
}
foreach (var s in list)
{
if (left <= 0) break;
int already = 0;
foreach (var kv in res)
if (kv.Key == s.s) already = kv.Value;
int take = Mathf.Min(left, s.owned - already);
if (take <= 0) continue;
warn = true;
res.RemoveAll(kv => kv.Key == s.s);
res.Add(new KeyValuePair<HeroState, int>(s.s, already + take));
left -= take;
}
return left > 0 ? null : res;
}
/// <summary>null = 교환 가능 · byPoint = 등용 포인트로.</summary>
public static string CanExchange(OutGameData db, SaveData d, AwakenDb.Item it, bool byPoint, DateTime nowUtc)
{
if (it == null) return "없는 비서";
if (Left(db, d, it, nowUtc) <= 0) return "이번 주 한도";
if (byPoint)
{
int have = Goods(d, db.Awaken.PointKey);
return have >= it.pricePoint ? null : "등용 포인트 " + have + " / " + it.pricePoint;
}
bool warn;
return PickShards(db, d, it.faction, it.priceShard, out warn) != null ? null : "조각 부족";
}
/// <summary>비서 1권 교환(조각 = 자동 고르기 · 등용 포인트) · 주간 한도 +1.</summary>
public static bool Exchange(OutGameData db, SaveData d, AwakenDb.Item it, bool byPoint, DateTime nowUtc)
{
if (CanExchange(db, d, it, byPoint, nowUtc) != null) return false;
if (byPoint) AddGoods(d, db.Awaken.PointKey, -it.pricePoint);
else
{
bool warn;
foreach (var kv in PickShards(db, d, it.faction, it.priceShard, out warn)) kv.Key.shards -= kv.Value;
}
AddGoods(d, it.key, 1);
Counts.Add(d.tomeShop.bought, it.key, 1);
return true;
}
/// <summary>명장 등용 n 회 → 등용 포인트(evolve_config recruit_point × n).</summary>
public static void AddRecruitPoints(OutGameData db, SaveData d, int pulls)
{
if (db.Awaken == null || pulls <= 0) return;
AddGoods(d, db.Awaken.PointKey, pulls * AwakenDb.ToInt(db.Awaken.EvCfg("recruit_point")));
}
}
}