ThreeKingdomsSlingshot/Assets/Tests/PlayMode/AwakenTests.cs

641 lines
36 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;
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
{
/// <summary>
/// 영웅 각성 · 진화(2026-11-20 요청서 §2 · §5 2차) — ① 표 임포트(evolve_stars → EvolveTable · AwakenDb) ② 진화(★ 최대 레벨 상한 · 조건 · 재료 · 각성 칸과 무관 · 병사 제외)
/// ③ 비서 교환(조각 자동 고르기 · 남는 몫 = 스킬 강화에 남은 조각 제외 · 등용 포인트 · 주간 한도 · 초기화) ④ 각성(굴리기 · 겹침 금지 · 잠금 · 상한 · 비용 · 경고 · 스탯 반영)
/// ⑤ 각성 칸 = 승급 장비 등급 ⑥ 스킬 강화 = 영웅 조각 + 만능 조각 ⑦ 창(각성 · ◀ ▶ · 경고 · 진화 → 완료 · 비서 교환 · 칸 열림 · 스킬 강화 · 만능 조각 팝업). 기대값은 표에서 읽는다(C45).
/// </summary>
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>("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);
}
/// <summary>각성 칸 k 개가 열리게 승급 등급 + 장비(그 칸 등급 장비 6칸)를 맞춘다 · k = 0 = 첫 등급 · 빈 장비 · 게임 hero_gear 에 그 등급 줄이 없으면 false.</summary>
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;
}
/// <summary>액티브 · 패시브 스킬이 다 있는 영웅(희귀도 순).</summary>
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<HeroState>();
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<string>();
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<string>();
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<AwakenLine>();
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);
}
/// <summary>2차 §5-1: 각성 칸 = 승급 장비 6칸을 모두 그 등급으로 채우면 1칸 · 승급 뒤 유지 · 무료 1회 · 빈 키 줄 안 열림 · 넘는 저장 줄 보관.</summary>
[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, "지우지 않고 보관");
}
/// <summary>2차 §5-2: 스킬 강화 = 그 영웅 조각 → 모자란 몫만 만능 조각(확인 먼저) · 만능도 모자람 · 영웅 레벨 상한 · ★ 액티브 보정 · Lv 최고 끝 · 남는 조각 · 전투 배율.</summary>
[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<Button>(true);
Button arrow = null;
foreach (var b in next)
if (b.name == "Next") arrow = b;
Assert.IsNotNull(arrow, "▶");
arrow.onClick.Invoke();
Assert.AreEqual("awaken", AwakenWindows.Last);
Assert.AreEqual(owned[1].id, AwakenWindows.HeroId, "다음 보유 영웅");
Assert.AreEqual(owned[1].id, og.HeroDetail.HeroId, "뒤 화면도 같이");
// 경고: 잠그지 않은 줄에 높은 등급 → 각성 버튼 = 경고 창
var hs = d.Hero(owned[1].id);
hs.awaken[0].grade = s.Db.Awaken.Cfg("warn_grade");
AwakenRules.AddGoods(d, s.Db.Awaken.StoneKey, 500);
AwakenWindows.OpenAwaken(og, owned[1].id);
Button roll = null;
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Roll") roll = b;
roll.onClick.Invoke();
Assert.AreEqual("warn", AwakenWindows.Last, "높은 등급 경고");
int stone = AwakenRules.Goods(d, s.Db.Awaken.StoneKey);
Button go = null;
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Go") go = b;
go.onClick.Invoke();
Assert.AreEqual("awaken", AwakenWindows.Last);
Assert.Less(AwakenRules.Goods(d, s.Db.Awaken.StoneKey), stone, "바꾸기 = 각성");
// 진화 창 → 진화 → 완료 창
og.HeroDetail.OnMenu(1);
Assert.AreEqual("evolve", AwakenWindows.Last);
var eh = s.Def(AwakenWindows.HeroId);
var ehs = d.Hero(eh.id);
if (AwakenRules.NextRow(s.Db, ehs) != null)
{
ehs.lv = AwakenRules.StarMaxLv(s.Db, ehs.star);
d.gold += AwakenRules.NextRow(s.Db, ehs).gold;
AwakenRules.AddGoods(d, AwakenRules.EvolveItem(s.Db, eh, ehs).key, AwakenRules.NextRow(s.Db, ehs).item);
int star = ehs.star;
AwakenWindows.OpenEvolve(og, eh.id);
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Go") go = b;
go.onClick.Invoke();
Assert.AreEqual(star + 1, ehs.star, "진화");
Assert.AreEqual("done", AwakenWindows.Last, "진화 완료 창");
}
// 비서 교환 = 진영 탭 첫 값 = 그 영웅 진영
AwakenWindows.OpenShop(og, eh.id, null);
Assert.AreEqual("shop", AwakenWindows.Last);
bool tabOn = false;
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Tab_" + eh.faction) tabOn = true;
Assert.IsTrue(tabOn, "영웅 진영 탭");
// 2차: 6칸째 장착(영웅 정보 장비 칸) = 각성 칸 열림 창 · 새 칸 무료 1회
og.CloseModal();
var oh = owned[0];
var ohs = d.Hero(oh.id);
Assert.IsTrue(OpenTo(s.Db, oh, ohs, 1));
ohs.awaken.Clear();
var gl = s.Db.Heroes.GearFor(oh, ohs.grade);
ohs.gear[gl.Count - 1] = "";
d.inv.AddGear(gl[gl.Count - 1], 1);
og.ShowHero(oh.id);
yield return null;
typeof(HeroDetailScreen).GetMethod("OnSlot", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Invoke(og.HeroDetail, new object[] { gl.Count - 1 });
Assert.AreEqual("slot_open", AwakenWindows.Last, "각성 칸 열림 창");
Assert.AreEqual(1, ohs.awaken.Count, "새 칸 무료 1회");
Assert.IsFalse(string.IsNullOrEmpty(ohs.awaken[0].stat));
// 2차: 스킬 행 = 스킬 강화 창 → 영웅 조각 모자람 = 만능 조각 팝업 → 강화
og.CloseModal();
ohs.lv = s.Db.Levels.MaxLevel;
ohs.skillLv = new[] { 1, 1 };
ohs.shards = 0;
var aw = s.Db.Awaken;
AwakenRules.AddGoods(d, aw.UnivKey, aw.StepTo(2).shard + 2 - AwakenRules.Goods(d, aw.UnivKey));
og.HeroDetail.OnSkillRow(1);
Assert.AreEqual("skill", AwakenWindows.Last, "스킬 강화 창");
Assert.AreEqual(oh.id, AwakenWindows.HeroId);
Button sk = null;
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Go" && b.transform.parent.name == "Skill1") sk = b;
Assert.IsNotNull(sk, "패시브 강화 버튼");
sk.onClick.Invoke();
Assert.AreEqual("skill_univ", AwakenWindows.Last, "영웅 조각 모자람 = 만능 조각 팝업");
Assert.AreEqual(1, SkillRules.Level(ohs, 1), "묻기 전엔 안 올림");
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Go") sk = b;
sk.onClick.Invoke();
Assert.AreEqual("skill", AwakenWindows.Last, "강화 뒤 강화 창");
Assert.AreEqual(2, SkillRules.Level(ohs, 1), "강화");
Assert.AreEqual(2, AwakenRules.Goods(d, aw.UnivKey), "모자란 몫만 만능 조각");
og.CloseModal();
}
/// <summary>목업 대조 캡처(1080×1920 · Logs/awaken_capture/ · 목업 이름 · 직접 실행).</summary>
[UnityTest, Explicit]
public IEnumerator Capture_AwakenScreens()
{
yield return Boot();
string dir = Path.Combine(Path.GetDirectoryName(Application.dataPath), "Logs", "awaken_capture");
Directory.CreateDirectory(dir);
var og = OutGameRoot.Instance;
var s = og.Session;
var d = s.Save;
var aw = s.Db.Awaken;
var cam = og.Cam != null ? og.Cam : Camera.main;
Func<string, IEnumerator> shot = name => CaptureUtil.Capture(cam, 1080, 1920, Path.Combine(dir, name + ".png"));
// 목업 상황 = 관우(있으면) ★4 · 최대 레벨 · 승급 장비로 열 수 있는 최고 칸(게임 hero_gear = 에픽 3칸 · 목업 = 전설 4칸) · 2줄 잠금 · 각성석 · 비서 1/2
HeroDb.Hero h = s.Def("guanyu");
if (h == null || d.Hero(h.id) == null) h = s.Owned(false)[0];
var hs = d.Hero(h.id);
d.chapterMax = 99;
hs.star = Mathf.Min(4, s.Db.Evolve.MaxStar - 1);
hs.lv = AwakenRules.StarMaxLv(s.Db, hs.star);
int k = 1;
while (k < aw.slots.Count && OpenTo(s.Db, h, hs, k + 1)) k++;
OpenTo(s.Db, h, hs, k);
hs.awaken.Clear();
AwakenRules.Sync(s.Db, hs, new System.Random(5));
string[] g = { "SS", "S", "A", "S", "B" };
string[] st = { "atk_pct", "crit_dmg_pct", "push_mult", "counter_dmg_pct", "hp_pct" };
float[] v = { 8.4f, 11.2f, 3.1f, 9.0f, 1.6f };
for (int i = 0; i < hs.awaken.Count && i < g.Length; i++)
{
if (aw.GradeOf(g[i]) != null) hs.awaken[i].grade = g[i];
if (aw.StatOf(st[i]) != null) hs.awaken[i].stat = st[i];
hs.awaken[i].value = v[i];
hs.awaken[i].locked = i < 2;
}
AwakenRules.AddGoods(d, aw.StoneKey, 1240);
AwakenRules.AddGoods(d, aw.PointKey, 260);
var it = AwakenRules.EvolveItem(s.Db, h, hs);
if (it != null) AwakenRules.AddGoods(d, it.key, 1);
foreach (var o in s.Owned(false))
if (o.faction == h.faction) d.Hero(o.id).shards = 40 + o.rarity * 20;
s.Commit();
og.ShowHero(h.id);
yield return null;
AwakenWindows.OpenAwaken(og, h.id);
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("01_aw_main");
AwakenWindows.OpenProb(og, h.id);
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("02_aw_prob");
// 경고 = 잠그지 않은 S 줄
hs.awaken[Mathf.Min(3, hs.awaken.Count - 1)].grade = aw.Cfg("warn_grade"); // 게임 = 3칸(목업 = 4칸)
AwakenWindows.OpenAwaken(og, h.id);
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Roll") b.onClick.Invoke();
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("03_aw_warn");
AwakenWindows.OpenEvolve(og, h.id);
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("04_ev_main");
AwakenWindows.OpenShop(og, h.id, null);
var it3 = aw.ItemOf(h.faction, 3);
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "ByShard" && it3 != null && b.transform.parent.name == "Item_" + it3.key) b.onClick.Invoke();
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("05_ev_shop");
// 진화 완료 = 재료를 채워 진화
var nx = AwakenRules.NextRow(s.Db, hs);
if (nx != null && it != null)
{
AwakenRules.AddGoods(d, it.key, nx.item);
d.gold += nx.gold;
AwakenWindows.OpenEvolve(og, h.id);
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Go") b.onClick.Invoke();
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("06_ev_done");
}
// 07 각성 칸 열림 = 열 수 있는 최고 칸의 6칸째 장비를 영웅 정보 장비 칸에서 끼움(새 칸 무료 1회)
og.CloseModal();
OpenTo(s.Db, h, hs, k);
var gl = s.Db.Heroes.GearFor(h, hs.grade);
hs.gear[gl.Count - 1] = "";
d.inv.AddGear(gl[gl.Count - 1], 1);
while (hs.awaken.Count >= k) hs.awaken.RemoveAt(hs.awaken.Count - 1);
og.ShowHero(h.id);
yield return null;
typeof(HeroDetailScreen).GetMethod("OnSlot", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Invoke(og.HeroDetail, new object[] { gl.Count - 1 });
if (hs.awaken.Count >= k)
{
var l = hs.awaken[k - 1];
if (aw.GradeOf("S") != null) l.grade = "S";
if (aw.StatOf("counter_dmg_pct") != null) l.stat = "counter_dmg_pct";
l.value = 9.0f;
AwakenWindows.OpenSlotOpen(og, h.id, k - 1, true);
}
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("07_aw_open");
// 08 스킬 강화 = Lv50 ★4 · 액티브 Lv6(3개 필요 · 관우 조각 2 → 만능 1) · 패시브 Lv4(2개 필요 = 충분) · 만능 14
og.CloseModal();
hs.star = Mathf.Min(4, s.Db.Evolve.MaxStar - 1);
hs.lv = AwakenRules.StarMaxLv(s.Db, hs.star);
hs.skillLv = new[] { 6, 4 };
hs.shards = 2;
AwakenRules.AddGoods(d, aw.UnivKey, 14 - AwakenRules.Goods(d, aw.UnivKey));
s.Commit();
og.ShowHero(h.id);
yield return null;
og.HeroDetail.OnSkillRow(0);
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("08_sk_main");
foreach (var b in og.TopRoot.GetComponentsInChildren<Button>(true))
if (b.name == "Go" && b.transform.parent.name == "Skill0") b.onClick.Invoke();
yield return new WaitForSecondsRealtime(0.3f);
yield return shot("09_sk_univ");
og.CloseModal();
Debug.Log("[TKS] 각성·진화 캡처 → " + dir);
}
}
}