using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using NUnit.Framework;
using TKS.OutGame;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.TestTools;
using UnityEngine.UI;
namespace TKS.Tests
{
///
/// 영웅 각성 · 진화(2026-11-20 요청서 §2 · §5 2차) — ① 표 임포트(evolve_stars → EvolveTable · AwakenDb) ② 진화(★ 최대 레벨 상한 · 조건 · 재료 · 각성 칸과 무관 · 병사 제외)
/// ③ 비서 교환(조각 자동 고르기 · 남는 몫 = 스킬 강화에 남은 조각 제외 · 등용 포인트 · 주간 한도 · 초기화) ④ 각성(굴리기 · 겹침 금지 · 잠금 · 상한 · 비용 · 경고 · 스탯 반영)
/// ⑤ 각성 칸 = 승급 장비 등급 ⑥ 스킬 강화 = 영웅 조각 + 만능 조각 ⑦ 창(각성 · ◀ ▶ · 경고 · 진화 → 완료 · 비서 교환 · 칸 열림 · 스킬 강화 · 만능 조각 팝업). 기대값은 표에서 읽는다(C45).
///
public class AwakenTests
{
static readonly DateTime T0 = new DateTime(2026, 11, 18, 3, 0, 0, DateTimeKind.Utc); // 수요일
[TearDown]
public void TearDown()
{
SaveStore.UseMemory(false);
}
static OutGameData Db
{
get { return OutGameData.Default; }
}
static BalanceConfig Cfg
{
get { return Resources.Load("BalanceConfig"); }
}
static HeroDb.Hero HeroOf(int rarity)
{
foreach (var x in Db.Heroes.heroes)
if (!x.isSoldier && x.rarity == rarity) return x;
return null;
}
static HeroState Own(SaveData d, HeroDb.Hero h)
{
if (d.Hero(h.id) == null) HeroRules.Grant(Db, d, h, HeroRules.GearSlotCount(Db));
return d.Hero(h.id);
}
/// 각성 칸 k 개가 열리게 승급 등급 + 장비(그 칸 등급 장비 6칸)를 맞춘다 · k = 0 = 첫 등급 · 빈 장비 · 게임 hero_gear 에 그 등급 줄이 없으면 false.
static bool OpenTo(OutGameData db, HeroDb.Hero h, HeroState hs, int k)
{
for (int i = 0; i < hs.gear.Count; i++) hs.gear[i] = "";
hs.grade = db.Promotion.FirstGrade;
if (k <= 0) return true;
string gg = db.Awaken.slots[k - 1].gearGrade;
foreach (var p in db.Promotion.rows)
{
var list = db.Heroes.GearFor(h, p.grade);
if (list == null || list.Count == 0) continue;
var g = db.Gear.Get(list[0]);
if (g == null || g.grade != gg) continue;
hs.grade = p.grade;
for (int i = 0; i < list.Count && i < hs.gear.Count; i++) hs.gear[i] = list[i];
return true;
}
return false;
}
/// 액티브 · 패시브 스킬이 다 있는 영웅(희귀도 순).
static HeroDb.Hero SkillHero()
{
for (int r = 1; r <= 3; r++)
foreach (var x in Db.Heroes.heroes)
if (!x.isSoldier && x.rarity == r && SkillRules.Skill(Db, x, 0) != null && SkillRules.Skill(Db, x, 1) != null) return x;
return null;
}
[Test]
public void Tables_Import_EvolveStarsAndAwaken()
{
var dir = Path.Combine(Application.dataPath, OutGameTables.Folder);
var texts = new string[OutGameTables.Files.Length];
for (int i = 0; i < texts.Length; i++) texts[i] = File.ReadAllText(Path.Combine(dir, OutGameTables.Files[i]), System.Text.Encoding.UTF8);
var r = OutGameTables.Parse(texts);
Assert.AreEqual(0, r.errors.Count, string.Join("\n", r.errors.ToArray()));
Assert.IsNotNull(Db.Awaken, "Resources/OutGame/AwakenDb.asset 없음 — TKS/Import Awaken · Evolve");
Assert.AreEqual(r.data.Evolve.rows.Count, Db.Evolve.rows.Count);
for (int i = 0; i < r.data.Evolve.rows.Count; i++)
{
Assert.AreEqual(r.data.Evolve.rows[i].maxLv, Db.Evolve.rows[i].maxLv, "★ 최대 레벨 = evolve_stars");
Assert.AreEqual(r.data.Evolve.rows[i].starPct, Db.Evolve.rows[i].starPct, "성급 % = evolve_stars");
}
// 2차: 각성 칸 = awaken_slots · 스킬 강화 = skill_upgrade · skill_config · 만능 조각 재화
Assert.AreEqual(r.data.Awaken.slots.Count, Db.Awaken.slots.Count, "각성 칸 = awaken_slots");
for (int i = 0; i < r.data.Awaken.slots.Count; i++) Assert.AreEqual(r.data.Awaken.slots[i].gearGrade, Db.Awaken.slots[i].gearGrade);
Assert.AreEqual(r.data.Awaken.skillSteps.Count, Db.Awaken.skillSteps.Count, "스킬 단계 = skill_upgrade");
Assert.AreEqual(r.data.Awaken.SkCfg("max_lv_active"), Db.Awaken.SkCfg("max_lv_active"));
Assert.IsNotNull(Db.Awaken.GoodOf(Db.Awaken.UnivKey), "만능 조각 재화");
Assert.AreEqual(r.data.Awaken.stats.Count, Db.Awaken.stats.Count);
foreach (var st in Db.Awaken.stats) Assert.IsTrue(AwakenRules.Known(st.stat), st.stat + " = 반영 안 되는 능력치");
Assert.AreEqual(r.data.Evolve.rows[r.data.Evolve.rows.Count - 1].starPct, Db.Evolve.Get(Db.Evolve.MaxStar).starPct, "성급 % = evolve_stars(기획 확정 0·5·10·15·20)");
Assert.AreEqual(r.data.Awaken.items.Count, Db.Awaken.items.Count);
OutGameTables.Destroy(r);
}
[Test]
public void Evolve_StarCap_Condition_Materials_NoSlot()
{
var d = HeroRules.NewSave(Db, 5, T0);
var h = HeroOf(1) ?? HeroOf(2);
var hs = Own(d, h);
int star = hs.star, cap = AwakenRules.StarMaxLv(Db, star);
// 레벨 상한 = min(★ 최대 레벨, 챕터 상한)
d.chapterMax = 99;
Assert.AreEqual(Mathf.Min(cap, HeroRules.LevelCap(Db, d)), AwakenRules.HeroLevelCap(Db, d, hs));
hs.lv = cap;
hs.exp = 1000000;
d.gold = 100000000;
if (cap < HeroRules.LevelCap(Db, d)) StringAssert.Contains("★" + star, HeroRules.CanLevelUp(Db, d, hs), "★ 최대 레벨에서 멈춤");
// 조건: 최대 레벨 미달 → 불가
hs.lv = cap - 1;
Assert.IsNotNull(AwakenRules.CanEvolve(Db, d, h, hs), "최대 레벨 미달");
hs.lv = cap;
var next = AwakenRules.NextRow(Db, hs);
var it = AwakenRules.EvolveItem(Db, h, hs);
Assert.AreEqual(h.faction, it.faction, "재료 = 영웅 진영 비서");
Assert.AreEqual(next.tier, it.tier);
Assert.IsNotNull(AwakenRules.CanEvolve(Db, d, h, hs), "비서 없음");
AwakenRules.AddGoods(d, it.key, next.item);
int slots = AwakenRules.OpenSlots(Db, hs), lines = hs.awaken.Count;
int gold = d.gold;
Assert.IsTrue(AwakenRules.Evolve(Db, d, h, hs), "진화 성공");
Assert.AreEqual(star + 1, hs.star);
Assert.AreEqual(gold - next.gold, d.gold, "골드");
Assert.AreEqual(0, AwakenRules.Goods(d, it.key), "비서");
Assert.AreEqual(slots, AwakenRules.OpenSlots(Db, hs), "진화는 각성 칸과 상관없음(2차)");
Assert.AreEqual(lines, hs.awaken.Count, "진화로 줄이 생기지 않음");
Assert.AreEqual(Mathf.Min(next.maxLv, HeroRules.LevelCap(Db, d)), AwakenRules.HeroLevelCap(Db, d, hs), "진화하면 상한이 오른다");
// 병사 = 진화·각성 없음
HeroDb.Hero sol = null;
foreach (var x in Db.Heroes.heroes)
if (x.isSoldier) sol = x;
if (sol != null) Assert.IsNotNull(AwakenRules.CanEvolve(Db, d, sol, new HeroState { id = sol.id, star = 1 }));
}
[Test]
public void TomeExchange_Shards_Points_WeeklyLimit_Reset()
{
var aw = Db.Awaken;
var d = HeroRules.NewSave(Db, 5, T0);
string fac = null;
foreach (var h in Db.Heroes.heroes)
if (!h.isSoldier && d.Hero(h.id) != null) fac = fac ?? h.faction;
Assert.IsNotNull(fac);
var it = aw.ItemOf(fac, 1);
// 조각: 같은 진영 보유 영웅에서 많이 남은 순
var mine = new List();
foreach (var h in Db.Heroes.heroes)
if (!h.isSoldier && h.faction == fac && d.Hero(h.id) != null) mine.Add(d.Hero(h.id));
// 남는 몫 = 보유 − 스킬 강화에 남은 조각(2차 §5-2-6)
int need0 = AwakenRules.NeedShards(Db, d, Db.Heroes.Get(mine[0].id), mine[0]);
Assert.AreEqual(SkillRules.ShardsToMax(Db, Db.Heroes.Get(mine[0].id), mine[0], 0) + SkillRules.ShardsToMax(Db, Db.Heroes.Get(mine[0].id), mine[0], 1), need0);
mine[0].shards = need0 + it.priceShard * 3;
if (mine.Count > 1) mine[1].shards = 1;
int before = mine[0].shards;
bool warn;
AwakenRules.PickShards(Db, d, fac, it.priceShard, out warn);
Assert.IsFalse(warn, "남는 몫으로 충분 = 경고 없음");
Assert.IsNull(AwakenRules.CanExchange(Db, d, it, false, T0));
Assert.IsTrue(AwakenRules.Exchange(Db, d, it, false, T0));
Assert.AreEqual(before - it.priceShard, mine[0].shards, "가장 많이 남은 영웅부터");
Assert.AreEqual(1, AwakenRules.Goods(d, it.key));
// 등용 포인트: 명장 등용 1회 = recruit_point
AwakenRules.AddRecruitPoints(Db, d, 10);
Assert.AreEqual(10 * AwakenDb.ToInt(aw.EvCfg("recruit_point")), AwakenRules.Goods(d, aw.PointKey), "등용 10회");
AwakenRules.AddGoods(d, aw.PointKey, it.pricePoint * it.weekLimit * 2);
int left = AwakenRules.Left(Db, d, it, T0);
Assert.AreEqual(it.weekLimit - 1, left, "조각 · 포인트 한도 공유");
for (int i = 0; i < left; i++) Assert.IsTrue(AwakenRules.Exchange(Db, d, it, true, T0));
Assert.AreEqual("이번 주 한도", AwakenRules.CanExchange(Db, d, it, true, T0));
// 다른 등급은 따로
var it2 = aw.ItemOf(fac, 2);
if (it2 != null) Assert.AreEqual(it2.weekLimit, AwakenRules.Left(Db, d, it2, T0), "진영 · 등급마다 한도");
// 다음 주 = 초기화
Assert.AreEqual(it.weekLimit, AwakenRules.Left(Db, d, it, T0.AddDays(7)), "주간 초기화");
Assert.AreEqual(it.weekLimit, AwakenRules.Left(Db, d, it, T0.AddDays(7)));
// 남는 몫이 모자라면 교환 불가
foreach (var s in mine) s.shards = 0;
Assert.AreEqual("조각 부족", AwakenRules.CanExchange(Db, d, it, false, T0.AddDays(7)));
}
[Test]
public void Awaken_Roll_Lock_Cost_Warn_Stats()
{
var aw = Db.Awaken;
var d = HeroRules.NewSave(Db, 5, T0);
var h = HeroOf(3) ?? HeroOf(2);
var hs = Own(d, h);
int k = 1;
while (k < aw.slots.Count && OpenTo(Db, h, hs, k + 1)) k++;
Assert.IsTrue(OpenTo(Db, h, hs, k));
var rng = new System.Random(11);
AwakenRules.Sync(Db, hs, rng);
int open = AwakenRules.OpenSlots(Db, hs);
Assert.AreEqual(k, open, "승급 장비 등급만큼 칸");
Assert.GreaterOrEqual(open, 2, "시험에 2칸 이상");
Assert.AreEqual(open, hs.awaken.Count, "열린 칸 = 줄 수(새 칸 무료 굴림)");
var seen = new HashSet();
foreach (var l in hs.awaken)
{
var g = aw.GradeOf(l.grade);
var st = aw.StatOf(l.stat);
Assert.IsNotNull(g, "등급");
Assert.IsNotNull(st, "능력치");
Assert.IsTrue(seen.Add(l.stat), "같은 능력치 겹침 금지");
Assert.GreaterOrEqual(l.value, st.min[g.order - 1] - 0.051f, "범위 안");
Assert.LessOrEqual(l.value, st.max[g.order - 1] + 0.051f, "범위 안");
}
// 잠금 상한 = 열린 칸 − 1
int lockMax = AwakenRules.LockMax(Db, hs);
Assert.AreEqual(open - AwakenRules.LockOffset(aw.Cfg("lock_max")), lockMax);
for (int i = 0; i < lockMax; i++) Assert.IsNull(AwakenRules.ToggleLock(Db, hs, i));
Assert.AreEqual("lock_last", AwakenRules.ToggleLock(Db, hs, lockMax), "마지막 줄은 잠글 수 없음");
Assert.AreEqual(aw.CostFor(lockMax), AwakenRules.Cost(Db, hs), "비용 = 잠금 수");
// 비용 부족 → 불가 · 있으면 잠근 줄 그대로 · 각성석 차감
Assert.IsNotNull(AwakenRules.CanRoll(Db, d, h, hs));
AwakenRules.AddGoods(d, aw.StoneKey, 1000);
var keep = new List();
for (int i = 0; i < lockMax; i++) keep.Add(hs.awaken[i].grade + hs.awaken[i].stat + hs.awaken[i].value);
int stone = AwakenRules.Goods(d, aw.StoneKey);
bool changed = false;
for (int n = 0; n < 6; n++)
{
string before = hs.awaken[lockMax].stat + hs.awaken[lockMax].value;
Assert.IsTrue(AwakenRules.Roll(Db, d, h, hs, rng));
changed |= before != hs.awaken[lockMax].stat + hs.awaken[lockMax].value;
}
Assert.IsTrue(changed, "잠그지 않은 줄 = 다시 굴림");
for (int i = 0; i < lockMax; i++) Assert.AreEqual(keep[i], hs.awaken[i].grade + hs.awaken[i].stat + hs.awaken[i].value, "잠근 줄 그대로");
Assert.AreEqual(stone - 6 * aw.CostFor(lockMax), AwakenRules.Goods(d, aw.StoneKey), "각성석 차감");
// 경고 = 잠그지 않은 줄에 warn_grade 이상
var w = aw.GradeOf(aw.Cfg("warn_grade"));
hs.awaken[lockMax].grade = w.grade;
Assert.AreEqual(1, AwakenRules.Warn(Db, hs).Count, "경고 줄");
hs.awaken[lockMax].grade = aw.grades[0].grade;
Assert.AreEqual(0, AwakenRules.Warn(Db, hs).Count);
// 스탯 반영: 공격 % = Compute 배율 · 치명타 확률 = 유닛 효과(%p → 0~1)
foreach (var l in hs.awaken) l.locked = false;
hs.awaken[0].stat = "atk_pct";
hs.awaken[0].value = 10f;
hs.awaken[1].stat = "crit_chance";
hs.awaken[1].value = 5f;
var st0 = HeroRules.Compute(Db, Cfg, h, hs, d);
Assert.AreEqual(AwakenRules.Total(Db, hs, "atk_pct"), st0.awakenAtkPct, 0.001f);
var keep2 = hs.awaken;
hs.awaken = new List();
var stNo = HeroRules.Compute(Db, Cfg, h, hs, d);
hs.awaken = keep2;
Assert.Greater(st0.atk, stNo.atk, "공격 % 반영");
Assert.Greater(AwakenRules.Power(Db, Cfg, h, hs, d), 0, "각성 몫 전투력");
SkillEffect crit = null;
foreach (var e in AwakenRules.Effects(Db, hs))
if (e.Key == SkillKeys.CritChance) crit = e;
Assert.IsNotNull(crit, "치명타 확률 = 유닛 효과");
Assert.AreEqual(AwakenRules.Total(Db, hs, "crit_chance") / 100f, crit.P, 0.0001f);
}
/// 2차 §5-1: 각성 칸 = 승급 장비 6칸을 모두 그 등급으로 채우면 1칸 · 승급 뒤 유지 · 무료 1회 · 빈 키 줄 안 열림 · 넘는 저장 줄 보관.
[Test]
public void AwakenSlots_GearGrade_Promote_FreeRoll_Kept()
{
var aw = Db.Awaken;
var d = HeroRules.NewSave(Db, 5, T0);
var h = HeroOf(2) ?? HeroOf(1);
var hs = Own(d, h);
var rng = new System.Random(7);
Assert.IsTrue(OpenTo(Db, h, hs, 0));
Assert.AreEqual(0, AwakenRules.OpenSlots(Db, hs), "첫 등급 · 빈 장비 = 0칸");
// 1칸 등급 장비를 요구하는 단계 — 5칸 = 닫힘 · 6칸째 장착 = 열림
Assert.IsTrue(OpenTo(Db, h, hs, 1));
var list = Db.Heroes.GearFor(h, hs.grade);
int lastSlot = list.Count - 1;
hs.gear[lastSlot] = "";
Assert.AreEqual(0, AwakenRules.OpenSlots(Db, hs), "5칸 = 아직 닫힘");
d.inv.AddGear(list[lastSlot], 1);
Assert.IsTrue(HeroRules.Equip(Db, d, h, hs, lastSlot));
Assert.AreEqual(1, AwakenRules.OpenSlots(Db, hs), "6칸 = " + aw.slots[0].nameKo + " 1칸");
var fresh = AwakenRules.Sync(Db, hs, rng);
Assert.AreEqual(1, fresh.Count, "새 칸 무료 1회");
Assert.IsFalse(string.IsNullOrEmpty(fresh[0].stat));
// 승급 = 장비를 비워도 열린 채 · 진화(★)와 상관없음
Assert.IsNull(HeroRules.CanPromote(Db, h, hs));
Assert.IsTrue(HeroRules.Promote(Db, h, hs));
Assert.AreEqual(0, HeroRules.EquippedCount(hs));
Assert.AreEqual(1, AwakenRules.OpenSlots(Db, hs), "승급 뒤 유지");
hs.star = Db.Evolve.MaxStar;
Assert.AreEqual(1, AwakenRules.OpenSlots(Db, hs), "★ 와 상관없음");
// 채울 수 있는 최고 등급까지 · 빈 s_gear_grade 줄 = 안 열림
int k = 1;
while (k < aw.slots.Count && OpenTo(Db, h, hs, k + 1)) k++;
Assert.IsTrue(OpenTo(Db, h, hs, k));
Assert.AreEqual(k, AwakenRules.OpenSlots(Db, hs), "열 수 있는 최고 칸");
int firstEmpty = aw.slots.FindIndex(x => x.gearGrade.Length == 0);
if (firstEmpty >= 0) Assert.LessOrEqual(AwakenRules.OpenSlots(Db, hs), firstEmpty, "빈 줄 = 안 열림");
Assert.AreEqual(aw.slots.Count, AwakenRules.MaxSlots(Db));
// 열린 칸보다 많은 저장 줄(1차 ★ 기준) = 보관 · 적용 · 잠금 수에서 빠짐
Assert.IsTrue(OpenTo(Db, h, hs, 1));
hs.awaken.Clear();
for (int i = 0; i < 3; i++) hs.awaken.Add(new AwakenLine { grade = aw.grades[0].grade, stat = "atk_pct", value = 10f, locked = i == 2 });
Assert.AreEqual(1, AwakenRules.Shown(Db, hs));
Assert.AreEqual(10f, AwakenRules.Total(Db, hs, "atk_pct"), 0.001f, "보이는 줄만 적용");
Assert.AreEqual(0, AwakenRules.Locks(Db, hs), "보관 줄 잠금은 세지 않음");
Assert.AreEqual(0, AwakenRules.Sync(Db, hs, rng).Count, "보관 줄이 있으면 새로 굴리지 않음");
Assert.AreEqual(3, hs.awaken.Count, "지우지 않고 보관");
}
/// 2차 §5-2: 스킬 강화 = 그 영웅 조각 → 모자란 몫만 만능 조각(확인 먼저) · 만능도 모자람 · 영웅 레벨 상한 · ★ 액티브 보정 · Lv 최고 끝 · 남는 조각 · 전투 배율.
[Test]
public void SkillUp_HeroShards_Univ_HeroLvCap_Max_Spare()
{
var aw = Db.Awaken;
var d = HeroRules.NewSave(Db, 5, T0);
var h = SkillHero();
Assert.IsNotNull(h, "스킬 2개 영웅");
var hs = Own(d, h);
hs.star = 1;
hs.skillLv = new[] { 1, 1 };
int maxP = SkillRules.MaxLv(Db, h, 1);
Assert.AreEqual(AwakenDb.ToInt(aw.SkCfg("max_lv_passive")), maxP, "최고 레벨 = skill_config");
Assert.AreEqual(AwakenDb.ToInt(aw.SkCfg("max_lv_active")), SkillRules.MaxLv(Db, h, 0));
// 상한 = 영웅 레벨(n_need_hero_lv)
var st2 = aw.StepTo(2);
hs.lv = st2.needHeroLv - 1;
Assert.AreEqual(1, SkillRules.Cap(Db, h, hs, 1));
Assert.AreEqual("영웅 Lv " + st2.needHeroLv + " 필요", SkillRules.CanLevelUp(Db, d, h, hs, 1));
var st3 = aw.StepTo(3);
hs.lv = st3.needHeroLv - 1;
Assert.AreEqual(2, SkillRules.Cap(Db, h, hs, 1), "경계 아래(예 Lv29) = 스킬 2 까지");
hs.lv = st3.needHeroLv;
Assert.AreEqual(3, SkillRules.Cap(Db, h, hs, 1), "경계(예 Lv30) = 스킬 3");
hs.lv = Db.Levels.MaxLevel;
Assert.AreEqual(maxP, SkillRules.Cap(Db, h, hs, 1), "최고 영웅 레벨 = 최고 스킬 레벨");
Assert.AreEqual(Db.Evolve.Get(Db.Evolve.MaxStar).maxLv, Db.Levels.MaxLevel, "★5 최대 레벨 = 영웅 레벨 표 끝(hero_levels)");
// 조각 충분 = 바로 강화(그 영웅 조각만)
AwakenRules.AddGoods(d, aw.UnivKey, -AwakenRules.Goods(d, aw.UnivKey));
hs.shards = st2.shard;
Assert.IsNull(SkillRules.LevelUp(Db, d, h, hs, 1, false));
Assert.AreEqual(2, SkillRules.Level(hs, 1));
Assert.AreEqual(0, hs.shards);
// 모자람 + 만능 0 = 조각 부족 · 만능 있음 = 확인 먼저(NeedUniv) → 영웅 조각 전부 + 모자란 수만 만능
AwakenDb.SkillStep big = null;
foreach (var st in aw.skillSteps)
if (st.shard >= 2)
{
big = st;
break;
}
Assert.IsNotNull(big, "조각 2개 이상 단계");
hs.skillLv[1] = big.from;
hs.shards = big.shard - 1;
StringAssert.StartsWith("조각 부족", SkillRules.CanLevelUp(Db, d, h, hs, 1), "만능 조각까지 모자람");
AwakenRules.AddGoods(d, aw.UnivKey, 5);
Assert.AreEqual(SkillRules.NeedUniv, SkillRules.LevelUp(Db, d, h, hs, 1, false), "팝업 먼저");
Assert.AreEqual(big.from, SkillRules.Level(hs, 1), "묻기 전엔 안 올림");
Assert.IsNull(SkillRules.LevelUp(Db, d, h, hs, 1, true));
Assert.AreEqual(big.to, SkillRules.Level(hs, 1));
Assert.AreEqual(0, hs.shards, "영웅 조각 먼저 전부");
Assert.AreEqual(4, AwakenRules.Goods(d, aw.UnivKey), "모자란 1개만 만능");
// Lv 최고 = 끝
hs.skillLv[1] = maxP;
Assert.AreEqual("최고 레벨", SkillRules.CanLevelUp(Db, d, h, hs, 1));
// 액티브 = ★ 보정(evolve_stars active_lv+n)만큼 더 · 최고를 넘지 않음
hs.lv = st2.needHeroLv;
hs.star = Db.Evolve.MaxStar;
Assert.AreEqual(Mathf.Min(SkillRules.Cap(Db, h, hs, 1) + SkillRules.ActiveCapBonus(Db, hs.star), SkillRules.MaxLv(Db, h, 0)), SkillRules.Cap(Db, h, hs, 0));
// 남는 조각 = 보유 − 스킬 강화에 남은 조각(액티브 + 패시브 · skill_upgrade 합)
hs.skillLv = new[] { 1, 1 };
int want = 0;
for (int i = 0; i < 2; i++)
foreach (var st in aw.skillSteps)
if (st.to <= SkillRules.MaxLv(Db, h, i)) want += st.shard;
Assert.AreEqual(want, AwakenRules.NeedShards(Db, d, h, hs), "Lv1 → 최고 = 조각 합(액티브 + 패시브)");
hs.shards = want + 7;
SpareShard mineRow = null;
foreach (var sp in AwakenRules.Spares(Db, d, h.faction))
if (sp.s == hs) mineRow = sp;
Assert.AreEqual(7, mineRow.Spare, "남는 몫");
hs.skillLv = new[] { SkillRules.MaxLv(Db, h, 0), maxP };
Assert.AreEqual(0, AwakenRules.NeedShards(Db, d, h, hs), "최고 = 전부 남는 몫");
// 전투 = 최고 레벨까지 효과 배율(1 + lv_scale × (Lv − 1))
var def = SkillCatalog.Get(SkillRules.Skill(Db, h, 1).id);
Assert.AreEqual(maxP, def.LvMax);
Assert.AreEqual(1f + def.LvScale * (maxP - 1), def.LevelFactor(maxP), 0.0001f);
}
static IEnumerator Boot()
{
WorldProgress.Reset();
SaveStore.UseMemory(true);
SceneManager.LoadScene("Battle");
yield return null;
yield return null;
}
[UnityTest]
public IEnumerator Windows_Menu_Arrows_Warn_Evolve_Shop()
{
yield return Boot();
var og = OutGameRoot.Instance;
var s = og.Session;
var d = s.Save;
var owned = s.Owned(false);
Assert.Greater(owned.Count, 1, "보유 영웅 2명 이상");
var h = owned[0];
for (int i = 0; i < 2; i++) Assert.IsTrue(OpenTo(s.Db, owned[i], d.Hero(owned[i].id), 2), "각성 칸 2개 열기(승급 장비)");
s.Commit();
og.ShowHero(h.id);
yield return null;
og.HeroDetail.OnMenu(2);
Assert.AreEqual("awaken", AwakenWindows.Last, "메뉴 각성 = 각성 창");
Assert.AreEqual(h.id, AwakenWindows.HeroId);
Assert.IsTrue(og.ModalVisible);
Assert.AreEqual(2, AwakenRules.Shown(s.Db, d.Hero(h.id)), "창을 열면 열린 칸이 채워짐");
// ▶ = 영웅 정보 화면 순서 다음 영웅(창 그대로)
var next = og.TopRoot.GetComponentsInChildren