641 lines
36 KiB
C#
641 lines
36 KiB
C#
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);
|
||
}
|
||
}
|
||
}
|