518 lines
24 KiB
C#
518 lines
24 KiB
C#
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")));
|
||
}
|
||
}
|
||
}
|