748 lines
41 KiB
C#
748 lines
41 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;
|
||
|
||
namespace TKS.Tests
|
||
{
|
||
/// <summary>
|
||
/// 아웃게임 2차(PD #1093 C · 시스템 기획 §7~§9 · §12) — 임포터(C 표 10장 행 수·참조·확률 합·트리 선행 · 깨진 표) · 훈련 공식·랭크 · 순찰 누적·오프라인·광고·즉시 ·
|
||
/// 개발 선행·비용·도면·효과 적용·초기화 · 보물 상자 확률·중복 조각·강화·세트 단계·조건 카운터·스탯·전투 효과 · 탑 층·입장권 · 던전 요일·입장 · 투기장 메달·순위·시즌·상점 ·
|
||
/// 적장 주간 순환·누적 · 화면(내정·보물·연무장·거래 상자) · 연무장 모드 전투 → 결과 → 복귀 · 전투 이벤트 카운터.
|
||
/// 기대값은 전부 표(CSV·자산)에서 계산한다(C45 · 테스트에 수치 상수 없음).
|
||
/// </summary>
|
||
public class OutGameCTests
|
||
{
|
||
static readonly DateTime T0 = new DateTime(2026, 11, 5, 3, 0, 0, DateTimeKind.Utc);
|
||
|
||
static readonly string[] CFiles =
|
||
{
|
||
"training.csv", "training_ranks.csv", "patrol.csv", "dev_tree.csv", "treasures.csv", "treasure_sets.csv", "chests.csv", "tower.csv", "dungeons.csv", "arena.csv",
|
||
};
|
||
|
||
static string[] ReadTables()
|
||
{
|
||
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);
|
||
return texts;
|
||
}
|
||
|
||
static int CsvRows(string file)
|
||
{
|
||
int n = 0;
|
||
foreach (var l in File.ReadAllLines(Path.Combine(Application.dataPath, OutGameTables.Folder, file), System.Text.Encoding.UTF8))
|
||
if (l.Trim().Length > 0) n++;
|
||
return n - 1;
|
||
}
|
||
|
||
static OutGameData Db
|
||
{
|
||
get { return OutGameData.Default; }
|
||
}
|
||
|
||
static BalanceConfig Cfg
|
||
{
|
||
get { return Resources.Load<BalanceConfig>("BalanceConfig"); }
|
||
}
|
||
|
||
static SaveData NewSave()
|
||
{
|
||
var d = HeroRules.NewSave(Db, Cfg.playerSpawnPoints.Length, T0);
|
||
ArenaRules.RollDaily(Db, d, T0);
|
||
return d;
|
||
}
|
||
|
||
static DevTree.Node NodeWith(string key)
|
||
{
|
||
foreach (var n in Db.Dev.nodes)
|
||
if (Array.IndexOf(n.EffectKeys, key) >= 0) return n;
|
||
Assert.Fail("개발 노드에 " + key + " 없음");
|
||
return null;
|
||
}
|
||
|
||
// ---------- 임포터 ----------
|
||
|
||
[Test]
|
||
public void Import_CTables_RowsRefsProbs_AssetsMatch()
|
||
{
|
||
var r = OutGameTables.Parse(ReadTables());
|
||
try
|
||
{
|
||
Assert.AreEqual(0, r.errors.Count, string.Join("\n", r.errors.ToArray()));
|
||
foreach (var f in CFiles) Assert.AreEqual(CsvRows(f), r.rowCounts[f], f + " 행 수");
|
||
var d = r.data;
|
||
Assert.AreEqual(CsvRows("training.csv"), UnitTypeInfo.Count * TrainingTable.Stats.Length * d.Training.MaxLevel, "훈련 = 병종 × 3항목 × Lv");
|
||
Assert.AreEqual(CsvRows("training_ranks.csv"), d.Training.MaxRank);
|
||
Assert.AreEqual(CsvRows("dev_tree.csv"), d.Dev.nodes.Count);
|
||
Assert.AreEqual(CsvRows("treasures.csv"), d.Treasures.items.Count);
|
||
Assert.AreEqual(CsvRows("treasure_sets.csv"), d.TreasureSets.tiers.Count);
|
||
Assert.AreEqual(CsvRows("chests.csv"), d.Chests.chests.Count);
|
||
Assert.AreEqual(CsvRows("tower.csv"), d.Tower.Top);
|
||
Assert.AreEqual(CsvRows("dungeons.csv"), d.Dungeons.dungeons.Count);
|
||
foreach (var c in d.Chests.chests)
|
||
{
|
||
float sum = 0f;
|
||
foreach (var p in c.p) sum += p;
|
||
Assert.AreEqual(1f, sum, 1e-4f, c.id + " 확률 합 = 1");
|
||
}
|
||
var seen = new HashSet<string>();
|
||
foreach (var n in d.Dev.nodes)
|
||
{
|
||
foreach (var q in n.requires) Assert.IsTrue(seen.Contains(q.node), n.id + " 선행 = 앞 행 " + q.node);
|
||
seen.Add(n.id);
|
||
}
|
||
foreach (var f in d.Tower.floors) Assert.IsNotNull(ArenaRules.FindStage(Cfg, f.templateStage), f.floor + "층 템플릿 " + f.templateStage);
|
||
foreach (var g in d.Dungeons.dungeons) Assert.IsNotNull(ArenaRules.FindStage(Cfg, g.templateStage), g.id + " 템플릿 " + g.templateStage);
|
||
foreach (var t in d.TreasureSets.tiers)
|
||
foreach (var m in t.members) Assert.AreEqual(t.setId, d.Treasures.Get(m).setId, t.setId + " ↔ " + m);
|
||
|
||
Assert.IsTrue(Db.Complete, "Resources/OutGame 18 자산(TKS/Import OutGame Data)");
|
||
Assert.AreEqual(d.Training.rows.Count, Db.Training.rows.Count);
|
||
Assert.AreEqual(d.Dev.nodes.Count, Db.Dev.nodes.Count);
|
||
Assert.AreEqual(d.Treasures.items.Count, Db.Treasures.items.Count);
|
||
Assert.AreEqual(d.Tower.floors.Count, Db.Tower.floors.Count);
|
||
foreach (var e in d.Arena.values.entries) Assert.AreEqual(e.value, Db.Arena.values.S(e.key), e.key);
|
||
for (int i = 0; i < d.Chests.chests.Count; i++) Assert.AreEqual(d.Chests.chests[i].buyGem, Db.Chests.chests[i].buyGem, d.Chests.chests[i].id);
|
||
}
|
||
finally
|
||
{
|
||
OutGameTables.Destroy(r);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public void Import_CBroken_ReportsErrors_AssetsUnchanged()
|
||
{
|
||
var texts = ReadTables();
|
||
int ci = Array.IndexOf(OutGameTables.Files, "chests.csv");
|
||
texts[ci] = texts[ci].Replace("bronze,청동 상자,1,0.8,0.2", "bronze,청동 상자,1,0.9,0.2"); // 확률 합 ≠ 1
|
||
int di = Array.IndexOf(OutGameTables.Files, "dev_tree.csv");
|
||
texts[di] = texts[di].Replace("com_gold_gain:3", "com_nope:3"); // 없는 선행
|
||
int ti = Array.IndexOf(OutGameTables.Files, "treasures.csv");
|
||
int cut = texts[ti].IndexOf(",boss_kills,", StringComparison.Ordinal);
|
||
texts[ti] = texts[ti].Substring(0, cut) + ",nope_key," + texts[ti].Substring(cut + ",boss_kills,".Length); // 없는 카운터
|
||
int wi = Array.IndexOf(OutGameTables.Files, "tower.csv");
|
||
texts[wi] = texts[wi].Replace(",1-1,", ",1-x,"); // 템플릿 형식
|
||
var r = OutGameTables.Parse(texts);
|
||
var all = string.Join("\n", r.errors.ToArray());
|
||
OutGameTables.Destroy(r);
|
||
StringAssert.Contains("bronze", all);
|
||
StringAssert.Contains("com_nope", all);
|
||
StringAssert.Contains("nope_key", all);
|
||
StringAssert.Contains("1-x", all);
|
||
Assert.AreEqual(CsvRows("treasures.csv"), Db.Treasures.items.Count, "실패한 파싱은 자산을 건드리지 않음");
|
||
}
|
||
|
||
// ---------- 훈련 ----------
|
||
|
||
[Test]
|
||
public void Training_CostLevelRankPromote_StatFormula()
|
||
{
|
||
var d = NewSave();
|
||
var T = Db.Training;
|
||
var t = Db.Heroes.Get(Db.Economy.StartHeroes[0]).type;
|
||
d.gold = 100000000;
|
||
Assert.AreEqual(Mathf.RoundToInt(T.Get(t, "hp", 1).goldCost * T.RankOf(1).costMult), TrainingRules.Cost(Db, d, t, 0), "비용 = gold_cost × cost_mult");
|
||
int gold = d.gold, spent = 0;
|
||
for (int i = 0; i < T.MaxLevel; i++)
|
||
{
|
||
spent += TrainingRules.Cost(Db, d, t, 0);
|
||
Assert.IsNull(TrainingRules.Level(Db, d, t, 0), "HP Lv " + (i + 1));
|
||
}
|
||
Assert.AreEqual(gold - spent, d.gold);
|
||
Assert.AreEqual("Max", TrainingRules.CanLevel(Db, d, t, 0));
|
||
Assert.AreEqual(T.Get(t, "hp", T.MaxLevel).statPct + T.RankOf(1).rankPct, TrainingRules.Bonus(Db, d, t, "hp"), 1e-4f);
|
||
StringAssert.Contains("남은 레벨", TrainingRules.CanPromote(Db, d, t));
|
||
for (int s = 1; s < 3; s++)
|
||
for (int i = 0; i < T.MaxLevel; i++) TrainingRules.Level(Db, d, t, s);
|
||
Assert.AreEqual(0, TrainingRules.Remaining(Db, d, t));
|
||
int pc = TrainingRules.PromoteCost(Db, d, t);
|
||
Assert.AreEqual(T.RankOf(1).promoteGold, pc);
|
||
d.gold = pc - 1;
|
||
StringAssert.Contains("골드", TrainingRules.CanPromote(Db, d, t));
|
||
d.gold = pc;
|
||
Assert.IsNull(TrainingRules.Promote(Db, d, t));
|
||
Assert.AreEqual(0, d.gold);
|
||
Assert.AreEqual(2, TrainingRules.Rank(d, t));
|
||
Assert.AreEqual(T.MaxLevel * 3, TrainingRules.Remaining(Db, d, t), "레벨 리셋");
|
||
Assert.AreEqual(T.RankOf(2).rankPct, TrainingRules.Bonus(Db, d, t, "hp"), 1e-4f, "랭크 보너스 유지");
|
||
Assert.AreEqual(Mathf.RoundToInt(T.Get(t, "hp", 1).goldCost * T.RankOf(2).costMult), TrainingRules.Cost(Db, d, t, 0), "비용 × 1.6^(랭크−1)");
|
||
d.gold = 100000000;
|
||
for (int i = 0; i < 3; i++) TrainingRules.Level(Db, d, t, 1);
|
||
|
||
// §3-2: 그 병종 영웅·병사 전원 × (1 + train(항목)) · 다른 병종 = 0
|
||
HeroDb.Hero same = null, other = null;
|
||
foreach (var h in Db.Heroes.heroes)
|
||
{
|
||
if (h.isSoldier) continue;
|
||
if (h.type == t && same == null) same = h;
|
||
if (h.type != t && other == null) other = h;
|
||
}
|
||
var hs = new HeroState { id = same.id, lv = 1, grade = Db.Promotion.FirstGrade, star = 1 };
|
||
var st = HeroRules.Compute(Db, Cfg, same, hs, d);
|
||
var b = Cfg.GetStats(same.type);
|
||
Assert.AreEqual(b.maxHp * same.hpMult * st.Core * (1f + TrainingRules.Bonus(Db, d, t, "hp") / 100f), st.hp, 1e-3f);
|
||
Assert.AreEqual(b.atk * same.atkMult * st.Core * (1f + (T.RankOf(2).rankPct + T.Get(t, "atk", 3).statPct) / 100f), st.atk, 1e-3f);
|
||
var so = HeroRules.Compute(Db, Cfg, other, new HeroState { id = other.id, lv = 1, grade = Db.Promotion.FirstGrade, star = 1 }, d);
|
||
Assert.AreEqual(0f, so.trainHpPct + so.trainPct + so.trainDefPct, "다른 병종 = 훈련 없음");
|
||
d.Train(t).rank = T.MaxRank;
|
||
Assert.AreEqual("최종 랭크", TrainingRules.CanPromote(Db, d, t));
|
||
}
|
||
|
||
// ---------- 순찰 ----------
|
||
|
||
[Test]
|
||
public void Patrol_AccumulateOfflineCap_Harvest_Ad_Instant_DevCap()
|
||
{
|
||
var e = Db.Economy;
|
||
var d = NewSave();
|
||
d.chapterMax = 3;
|
||
var row = Db.Patrol.For(3);
|
||
Assert.AreEqual(3f, PatrolRules.Hours(Db, d, T0.AddHours(3)), 1e-3f);
|
||
Assert.AreEqual(e.PatrolCapHours, PatrolRules.Hours(Db, d, T0.AddHours(1000)), 1e-3f, "오프라인 = 상한에서 멈춤");
|
||
Assert.AreEqual(Mathf.RoundToInt(row.goldPerHour * 3f), PatrolRules.Preview(Db, d, 3f, 1f).gold);
|
||
|
||
var rng = new System.Random(4);
|
||
var ids = new List<string>(e.StartHeroes);
|
||
int gold = d.gold, exp = d.Hero(ids[0]).exp;
|
||
string why;
|
||
var y = PatrolRules.Harvest(Db, d, T0.AddHours(5), ids, false, rng, out why);
|
||
Assert.IsNull(why);
|
||
Assert.AreEqual(gold + Mathf.RoundToInt(row.goldPerHour * 5f), d.gold, "골드 = 시간당 × 시간");
|
||
Assert.AreEqual(exp + Mathf.RoundToInt(row.expPerHour * 5f), d.Hero(ids[0]).exp, "경험 = 출전 편성");
|
||
int chests = Mathf.FloorToInt(row.chestPerHour * 5f + 1e-4f);
|
||
Assert.AreEqual(chests, y.chests);
|
||
Assert.AreEqual(chests, TreasureRules.ChestCount(d, e.PatrolChest));
|
||
Assert.AreEqual(row.chestPerHour * 5f - chests, d.patrol.carryChest, 1e-3f, "소수점 이월");
|
||
Assert.AreEqual(Mathf.FloorToInt(e.PatrolGearPerHour * 5f + 1e-4f), y.gear);
|
||
Assert.AreEqual(1, TreasureRules.Counter(d, BattleEvents.Patrols), "순찰 카운터");
|
||
Assert.AreEqual(0f, PatrolRules.Hours(Db, d, T0.AddHours(5)), 1e-4f, "수확 = 타이머 리셋");
|
||
Assert.IsNull(PatrolRules.Harvest(Db, d, T0.AddHours(5), ids, false, rng, out why));
|
||
Assert.IsNotNull(why);
|
||
|
||
gold = d.gold;
|
||
var ad = PatrolRules.Harvest(Db, d, T0.AddHours(7), ids, true, rng, out why);
|
||
Assert.AreEqual(e.PatrolAdMult, ad.mult);
|
||
Assert.AreEqual(gold + Mathf.RoundToInt(row.goldPerHour * 2f * e.PatrolAdMult), d.gold, "광고 2배");
|
||
for (int i = 1; i < e.PatrolAdDaily; i++) PatrolRules.Harvest(Db, d, T0.AddHours(7 + i), ids, true, rng, out why);
|
||
Assert.IsNull(PatrolRules.Harvest(Db, d, T0.AddHours(9), ids, true, rng, out why), "광고 일일 상한");
|
||
|
||
var start = d.patrol.startAt;
|
||
d.gem = e.PatrolInstantGem;
|
||
var inst = PatrolRules.Instant(Db, d, ids, rng, out why);
|
||
Assert.IsNotNull(inst);
|
||
Assert.AreEqual(e.PatrolInstantHours, inst.hours, 1e-4f);
|
||
Assert.AreEqual(0, d.gem, "즉시 수확 = 보옥");
|
||
Assert.AreEqual(start, d.patrol.startAt, "즉시 수확은 타이머 그대로");
|
||
Assert.IsNull(PatrolRules.Instant(Db, d, ids, rng, out why), "보옥 부족");
|
||
|
||
var cap = NodeWith(DevRules.PatrolCap);
|
||
Counts.Set(d.dev.nodes, cap.id, 2);
|
||
Assert.AreEqual(e.PatrolCapHours + cap.pctPerLv * 2f / 60f, PatrolRules.CapHours(Db, d), 1e-4f, "농업 순찰 상한 + 분");
|
||
}
|
||
|
||
// ---------- 개발 ----------
|
||
|
||
[Test]
|
||
public void Dev_RequiresCostBlueprint_EffectsApplied_Reset()
|
||
{
|
||
var e = Db.Economy;
|
||
var d = NewSave();
|
||
d.gold = 100000000;
|
||
d.gem = e.DevResetGem;
|
||
d.inv.blueprint = 1000;
|
||
DevTree.Node root = null, child = null;
|
||
foreach (var n in Db.Dev.nodes)
|
||
{
|
||
if (root == null && n.requires.Count == 0) root = n;
|
||
else if (root != null && child == null && n.requires.Count == 1 && n.requires[0].node == root.id) child = n;
|
||
}
|
||
StringAssert.Contains("선행", DevRules.CanUpgrade(Db, d, child.id));
|
||
int g0, b0;
|
||
DevRules.NextCost(root, 0, out g0, out b0);
|
||
Assert.AreEqual(root.goldBase, g0, "Lv1 = gold_base");
|
||
int gold = d.gold, bp = d.inv.blueprint, bpSpent = 0;
|
||
for (int lv = 0; lv < root.lvMax; lv++)
|
||
{
|
||
int g, b;
|
||
DevRules.NextCost(root, lv, out g, out b);
|
||
Assert.AreEqual(Mathf.RoundToInt(root.goldBase * Mathf.Pow(root.goldGrowth, lv)), g);
|
||
Assert.AreEqual(lv + 1 >= root.blueprintFromLv ? root.blueprintPerLv : 0, b, "도면 = blueprint_from_lv 이상");
|
||
gold -= g;
|
||
bpSpent += b;
|
||
Assert.IsNull(DevRules.Upgrade(Db, d, root.id));
|
||
}
|
||
Assert.AreEqual(gold, d.gold);
|
||
Assert.AreEqual(bp - bpSpent, d.inv.blueprint);
|
||
Assert.AreEqual("최고 레벨", DevRules.CanUpgrade(Db, d, root.id));
|
||
Assert.IsNull(DevRules.CanUpgrade(Db, d, child.id), "선행 충족");
|
||
Assert.AreEqual(root.pctPerLv * root.lvMax, DevRules.Mod(Db, d, root.EffectKeys[0]), 1e-4f, "효과 = pct × Lv");
|
||
|
||
// 적용 지점: 군량 상한 · 군량 회복 · 스테이지 골드 · 상점 가격 · 무료 새로고침
|
||
var cap = NodeWith(DevRules.FoodCap);
|
||
Counts.Set(d.dev.nodes, cap.id, 3);
|
||
Assert.AreEqual(e.StaminaMax + Mathf.RoundToInt(cap.pctPerLv * 3), EconomyRules.StaminaMax(Db, d));
|
||
var regen = NodeWith(DevRules.FoodRegen);
|
||
Counts.Set(d.dev.nodes, regen.id, 2);
|
||
Assert.AreEqual(e.StaminaRegenSec - Mathf.RoundToInt(regen.pctPerLv * 2), EconomyRules.RegenSec(Db, d));
|
||
var gg = NodeWith(DevRules.GoldGain);
|
||
int ggLv = DevRules.Level(d, gg.id);
|
||
var stage = Cfg.stages[0];
|
||
var rw = Db.Rewards.For(stage.chapter);
|
||
var r = EconomyRules.Compute(Db, d, stage, true, true, 1, false, new System.Random(1));
|
||
Assert.AreEqual(Mathf.RoundToInt((rw.goldBase + stage.stage * e.GoldPerStage) * e.FirstClearGoldMult * (1f + gg.pctPerLv * ggLv / 100f)), r.gold, "골드 획득 %");
|
||
var disc = NodeWith(DevRules.TradeDiscount);
|
||
Counts.Set(d.dev.nodes, disc.id, 5);
|
||
EconomyRules.EnsureShop(Db, d, T0, new System.Random(2));
|
||
var it = Db.Gear.Get(d.shop.items[0].gearId);
|
||
Assert.AreEqual(Mathf.RoundToInt(it.sellGold * e.ShopPriceMult * (1f - disc.pctPerLv * 5 / 100f)), d.shop.items[0].price, "거래 할인");
|
||
var market = NodeWith(DevRules.TradeFreeRefresh);
|
||
Counts.Set(d.dev.nodes, market.id, 1);
|
||
int gem = d.gem;
|
||
Assert.AreEqual(Mathf.RoundToInt(market.pctPerLv), EconomyRules.FreeRefreshesLeft(Db, d));
|
||
Assert.IsNull(EconomyRules.RefreshShop(Db, d, new System.Random(3)));
|
||
Assert.AreEqual(gem, d.gem, "시장 개설 = 무료 새로고침");
|
||
|
||
d.dev.blueprintSpent = bpSpent;
|
||
bp = d.inv.blueprint;
|
||
Assert.IsNull(DevRules.Reset(Db, d));
|
||
Assert.AreEqual(gem - e.DevResetGem, d.gem, "초기화 = 보옥");
|
||
Assert.AreEqual(bp + bpSpent, d.inv.blueprint, "도면 환급");
|
||
Assert.AreEqual(0, DevRules.TotalLevels(d));
|
||
Assert.AreEqual(e.StaminaMax, EconomyRules.StaminaMax(Db, d));
|
||
}
|
||
|
||
// ---------- 보물 ----------
|
||
|
||
[Test]
|
||
public void Treasure_ChestProb_Duplicates_Enhance_Sets_Conditions_Effects()
|
||
{
|
||
var e = Db.Economy;
|
||
var d = NewSave();
|
||
var rng = new System.Random(1093);
|
||
var bronze = Db.Chests.Get(e.StageChest);
|
||
int n = 4000;
|
||
Counts.Set(d.inv.chests, bronze.id, n);
|
||
var freq = new int[ChestDb.ProbGrades.Length];
|
||
int shards = 0;
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
var r = TreasureRules.Open(Db, d, bronze.id, rng);
|
||
Assert.IsNotNull(r);
|
||
freq[Array.IndexOf(ChestDb.ProbGrades, r.grade)]++;
|
||
shards += r.shards;
|
||
Assert.That(r.gold, Is.InRange(bronze.goldMin, bronze.goldMax));
|
||
}
|
||
for (int g = 0; g < freq.Length; g++) Assert.AreEqual(bronze.p[g], freq[g] / (float)n, 0.03f, ChestDb.ProbGrades[g] + " 빈도 ≈ 확률");
|
||
Assert.Greater(shards, 0, "중복 = 조각");
|
||
Assert.AreEqual(0, TreasureRules.ChestCount(d, bronze.id));
|
||
Assert.AreEqual(n * bronze.points / e.ChestPointGoal, TreasureRules.ChestCount(d, e.ChestPointReward), "상자 포인트 → 명장 상자");
|
||
Assert.AreEqual(n * bronze.points % e.ChestPointGoal, d.inv.chestPoints);
|
||
var top = e.TreasureGrades[e.TreasureGrades.Count - 1].Key;
|
||
foreach (var t in d.inv.treasures) Assert.AreNotEqual(top, Db.Treasures.Get(t.id).grade, "천기 = 상자에서 안 나옴");
|
||
|
||
// 강화: 조각 shard_per_star × ★ + 운철 iron_per_star × ★ × 등급 배율 · 효과 = 기본 × (1 + star_pct × ★)
|
||
var st = d.inv.treasures[0];
|
||
var item = Db.Treasures.Get(st.id);
|
||
int ns, ni;
|
||
TreasureRules.EnhanceCost(Db, item, 1, out ns, out ni);
|
||
Assert.AreEqual(e.TreasureShardPerStar, ns);
|
||
Assert.AreEqual(Mathf.RoundToInt(e.TreasureIronPerStar * e.TreasureIronMult(item.grade)), ni);
|
||
st.star = 0;
|
||
st.shards = ns;
|
||
d.inv.iron = ni - 1;
|
||
StringAssert.Contains("운철", TreasureRules.CanEnhance(Db, d, st.id));
|
||
d.inv.iron = ni;
|
||
Assert.IsNull(TreasureRules.Enhance(Db, d, st.id));
|
||
Assert.AreEqual(1, st.star);
|
||
Assert.AreEqual(0, st.shards);
|
||
Assert.AreEqual(0, d.inv.iron);
|
||
Assert.AreEqual(item.basePct * (1f + e.TreasureStarPct), TreasureRules.Value(Db, d, item), 1e-4f);
|
||
|
||
// 조건 효과 = 카운터 cond_every 마다 cond_pct · 최대 cond_max
|
||
TreasureRules.AddCount(d, item.condKey, item.condEvery * 2);
|
||
Assert.AreEqual(item.basePct * (1f + e.TreasureStarPct) + 2 * item.condPct, TreasureRules.Value(Db, d, item), 1e-4f);
|
||
TreasureRules.AddCount(d, item.condKey, item.condEvery * (item.condMax + 5));
|
||
Assert.AreEqual(item.condMax, TreasureRules.CondStacks(d, item), "최대 cond_max");
|
||
|
||
// 세트: 전원 보유 = [세트] · 전원 ★N = [N성] · 가장 높은 단계 1개
|
||
var sd = NewSave();
|
||
var setId = Db.TreasureSets.SetIds[0];
|
||
var tiers = Db.TreasureSets.TiersOf(setId);
|
||
Assert.IsNull(TreasureRules.SetTier(Db, sd, setId));
|
||
int dummy;
|
||
foreach (var m in tiers[0].members) TreasureRules.Grant(sd, Db.Treasures.Get(m), out dummy);
|
||
Assert.AreEqual(tiers[0], TreasureRules.SetTier(Db, sd, setId));
|
||
foreach (var m in tiers[0].members) sd.inv.Treasure(m).star = tiers[1].stars;
|
||
Assert.AreEqual(tiers[1], TreasureRules.SetTier(Db, sd, setId));
|
||
string stat = tiers[1].effectKey.Replace("_pct", "");
|
||
float expect = tiers[1].pct;
|
||
foreach (var it in Db.Treasures.items)
|
||
if (it.baseStat == stat && sd.inv.Treasure(it.id) != null) expect += TreasureRules.Value(Db, sd, it);
|
||
Assert.AreEqual(expect, TreasureRules.StatPct(Db, sd, stat), 1e-4f, "스탯 % = 보물 + 세트");
|
||
|
||
// §3-2 공식 = × (1 + 보물(항목)) · 전투 진영 효과(crit·range·splash)
|
||
var h = Db.Heroes.Get(e.StartHeroes[0]);
|
||
var hs = sd.Hero(h.id);
|
||
var s1 = HeroRules.Compute(Db, Cfg, h, hs, sd);
|
||
var b = Cfg.GetStats(h.type);
|
||
float hpPct = TreasureRules.StatPct(Db, sd, "hp"), atkPct = TreasureRules.StatPct(Db, sd, "atk");
|
||
Assert.AreEqual(b.maxHp * h.hpMult * s1.Core * (1f + hpPct / 100f), s1.hp, 1e-3f);
|
||
Assert.AreEqual(b.atk * h.atkMult * s1.Core * (1f + atkPct / 100f), s1.atk, 1e-3f);
|
||
foreach (var it in Db.Treasures.items)
|
||
if (sd.inv.Treasure(it.id) == null) TreasureRules.Grant(sd, it, out dummy);
|
||
var fx = TreasureRules.BattleEffects(Db, sd);
|
||
var keys = new Dictionary<string, float>();
|
||
foreach (var x in fx) keys[x.Key] = x.P;
|
||
Assert.AreEqual(TreasureRules.StatPct(Db, sd, "crit") / 100f, keys[SkillMods.SideCritPct], 1e-5f);
|
||
Assert.AreEqual(1f + TreasureRules.StatPct(Db, sd, "range") / 100f, keys[SkillKeys.RangeMult], 1e-5f);
|
||
Assert.AreEqual(1f + TreasureRules.StatPct(Db, sd, "splash") / 100f, keys[SkillKeys.SplashRadiusMult], 1e-5f);
|
||
|
||
// 스테이지 청동 상자 stage_chest_pct · 거래 구매(보옥 · 포인트)
|
||
int got = 0, m2 = 2000;
|
||
var rs = new System.Random(9);
|
||
for (int i = 0; i < m2; i++)
|
||
if (EconomyRules.Compute(Db, d, Cfg.stages[0], true, true, 1, false, rs).chest == e.StageChest) got++;
|
||
Assert.AreEqual(e.StageChestPct, got / (float)m2, 0.03f, "스테이지 상자 확률");
|
||
ChestDb.Chest gemBuy = null;
|
||
foreach (var c in Db.Chests.chests)
|
||
if (c.buyGem > 0 && c.buyPoints > 0) gemBuy = c;
|
||
int before = TreasureRules.ChestCount(d, gemBuy.id);
|
||
d.gem = gemBuy.buyGem;
|
||
Assert.IsNull(TreasureRules.Buy(Db, d, gemBuy.id, "gem"));
|
||
Assert.AreEqual(0, d.gem);
|
||
d.inv.chestPoints = gemBuy.buyPoints;
|
||
Assert.IsNull(TreasureRules.Buy(Db, d, gemBuy.id, "points"));
|
||
Assert.AreEqual(0, d.inv.chestPoints);
|
||
Assert.AreEqual(before + 2, TreasureRules.ChestCount(d, gemBuy.id));
|
||
Assert.IsNotNull(TreasureRules.Buy(Db, d, gemBuy.id, "gem"), "보옥 부족");
|
||
}
|
||
|
||
// ---------- 연무장 ----------
|
||
|
||
[Test]
|
||
public void Tower_TicketsFloorRewards_Ad_Daily()
|
||
{
|
||
var e = Db.Economy;
|
||
var d = NewSave();
|
||
Assert.AreEqual(e.TowerTicketsDaily, d.arena.towerTickets, "하루 입장권");
|
||
Assert.AreEqual(1, ArenaRules.TowerNext(Db, d));
|
||
var f1 = Db.Tower.Get(1);
|
||
var src = ArenaRules.FindStage(Cfg, f1.templateStage);
|
||
var st = ArenaRules.TowerStage(Db, Cfg, 1);
|
||
Assert.AreEqual(src.enemies.Count, st.enemies.Count);
|
||
Assert.AreEqual(src.enemies[0].hpMult * f1.hpMult, st.enemies[0].hpMult, 1e-4f, "층 hp 배율");
|
||
Assert.AreEqual(src.enemies[0].atkMult * f1.atkMult, st.enemies[0].atkMult, 1e-4f);
|
||
Assert.IsNull(ArenaRules.EnterTower(Db, d, T0));
|
||
Assert.AreEqual(e.TowerTicketsDaily - 1, d.arena.towerTickets, "입장 = 1장");
|
||
ArenaRules.TowerResult(Db, d, 1, false, new System.Random(1));
|
||
Assert.AreEqual(0, d.arena.towerFloor, "패배 = 층 유지");
|
||
int gem = d.gem, bp = d.inv.blueprint;
|
||
ArenaRules.TowerResult(Db, d, 1, true, new System.Random(1));
|
||
Assert.AreEqual(1, d.arena.towerFloor);
|
||
Assert.AreEqual(gem + f1.rewardGem, d.gem);
|
||
Assert.AreEqual(bp + f1.rewardBlueprint, d.inv.blueprint);
|
||
TowerTable.Floor chestFloor = null;
|
||
foreach (var f in Db.Tower.floors)
|
||
if (chestFloor == null && f.chest.Length > 0) chestFloor = f;
|
||
d.arena.towerFloor = chestFloor.floor - 1;
|
||
ArenaRules.TowerResult(Db, d, chestFloor.floor, true, new System.Random(1));
|
||
Assert.AreEqual(1, TreasureRules.ChestCount(d, chestFloor.chest), chestFloor.floor + "층 상자");
|
||
d.arena.towerTickets = 0;
|
||
Assert.IsNotNull(ArenaRules.CanTower(Db, d, T0), "입장권 없음");
|
||
Assert.IsNull(ArenaRules.TowerAd(Db, d, T0));
|
||
Assert.AreEqual(e.TowerAdTickets, d.arena.towerTickets);
|
||
Assert.IsNotNull(ArenaRules.TowerAd(Db, d, T0), "광고 하루 1");
|
||
ArenaRules.RollDaily(Db, d, T0.AddDays(1));
|
||
Assert.AreEqual(Mathf.Max(e.TowerAdTickets, e.TowerTicketsDaily), d.arena.towerTickets, "다음 날 채움");
|
||
d.arena.towerFloor = Db.Tower.Top;
|
||
Assert.IsNotNull(ArenaRules.CanTower(Db, d, T0.AddDays(1)), "정복 완료");
|
||
}
|
||
|
||
[Test]
|
||
public void Dungeon_WeekdayEntries_Rewards()
|
||
{
|
||
foreach (var dg in Db.Dungeons.dungeons)
|
||
{
|
||
var d = NewSave();
|
||
DateTime open = DateTime.MinValue, closed = DateTime.MinValue;
|
||
for (int k = 0; k < 7; k++)
|
||
{
|
||
var t = T0.AddDays(k);
|
||
if (ArenaRules.OpenToday(dg, t)) { if (open == DateTime.MinValue) open = t; }
|
||
else if (closed == DateTime.MinValue) closed = t;
|
||
}
|
||
Assert.AreNotEqual(DateTime.MinValue, open, dg.id + " 열리는 요일");
|
||
if (closed != DateTime.MinValue) StringAssert.Contains("닫힘", ArenaRules.CanDungeon(Db, d, dg.id, closed));
|
||
Assert.AreEqual(dg.entriesPerDay, ArenaRules.DungeonLeft(Db, d, dg, open));
|
||
Assert.AreEqual(ArenaRules.FindStage(Cfg, dg.templateStage).enemies[0].hpMult * dg.hpMult, ArenaRules.DungeonStage(Db, Cfg, dg.id).enemies[0].hpMult, 1e-4f, "hp_mult");
|
||
ArenaRules.DungeonResult(Db, d, dg.id, false, open, new System.Random(1));
|
||
Assert.AreEqual(dg.entriesPerDay, ArenaRules.DungeonLeft(Db, d, dg, open), "패배 = 횟수 유지");
|
||
int gold = d.gold, iron = d.inv.iron, books = d.inv.books.skill, shards = 0, gear = 0;
|
||
foreach (var h in d.heroes) shards += h.shards;
|
||
foreach (var c in d.inv.gear) gear += c.n;
|
||
ArenaRules.DungeonResult(Db, d, dg.id, true, open, new System.Random(1));
|
||
Assert.AreEqual(dg.entriesPerDay - 1, ArenaRules.DungeonLeft(Db, d, dg, open));
|
||
int shards2 = 0, gear2 = 0;
|
||
foreach (var h in d.heroes) shards2 += h.shards;
|
||
foreach (var c in d.inv.gear) gear2 += c.n;
|
||
Assert.AreEqual(gold + dg.Amount("gold"), d.gold, dg.id + " 골드");
|
||
Assert.AreEqual(iron + dg.Amount("iron"), d.inv.iron, dg.id + " 운철");
|
||
Assert.AreEqual(books + dg.Amount("skill_book"), d.inv.books.skill, dg.id + " 스킬서");
|
||
Assert.AreEqual(shards + dg.Amount("shards"), shards2, dg.id + " 조각");
|
||
Assert.AreEqual(gear + dg.Amount("gear"), gear2, dg.id + " 장비");
|
||
for (int i = 1; i < dg.entriesPerDay; i++) ArenaRules.DungeonResult(Db, d, dg.id, true, open, new System.Random(1));
|
||
StringAssert.Contains("완료", ArenaRules.CanDungeon(Db, d, dg.id, open));
|
||
Assert.IsNull(ArenaRules.CanDungeon(Db, d, dg.id, open.AddDays(7)), "다음 주 같은 요일 = 다시");
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public void Arena_SamplesMedalsRankSeason_Shop()
|
||
{
|
||
var A = Db.Arena;
|
||
var d = NewSave();
|
||
var rng = new System.Random(5);
|
||
ArenaRules.EnsureSeason(Db, d, T0, rng);
|
||
Assert.AreEqual(A.SampleLineups, d.arena.samples.Count, "샘플 상대");
|
||
foreach (var s in d.arena.samples)
|
||
{
|
||
Assert.AreEqual(Cfg.playerSpawnPoints.Length, s.heroes.Count);
|
||
foreach (var id in s.heroes) Assert.IsFalse(Db.Heroes.Get(id).isSoldier);
|
||
}
|
||
var st = ArenaRules.ArenaStage(Db, Cfg, d.arena.samples[0]);
|
||
Assert.AreEqual(Cfg.playerSpawnPoints.Length, st.enemies.Count);
|
||
for (int i = 0; i < st.enemies.Count; i++)
|
||
{
|
||
Assert.AreEqual(-Cfg.playerSpawnPoints[i].y, st.enemies[i].position.y, 1e-4f, "자리 = 위아래 반전");
|
||
Assert.IsTrue(st.enemies[i].isGeneral);
|
||
}
|
||
Assert.AreEqual(d.arena.samples.Count + 1, ArenaRules.Rank(d), "점수 0 = 꼴찌");
|
||
ArenaRules.ArenaResult(Db, d, 0, true, T0);
|
||
ArenaRules.ArenaResult(Db, d, 1, false, T0);
|
||
Assert.AreEqual(A.MedalWin + A.MedalLose, d.arena.medals);
|
||
Assert.AreEqual(1, d.arena.wins);
|
||
Assert.AreEqual(1, d.arena.losses);
|
||
for (int i = 2; i < A.EntriesPerDay; i++) ArenaRules.ArenaResult(Db, d, 0, true, T0);
|
||
Assert.IsNotNull(ArenaRules.CanArena(Db, d, 0, T0), "하루 상한");
|
||
Assert.IsNull(ArenaRules.CanArena(Db, d, 0, T0.AddDays(1)), "다음 날");
|
||
int topScore = 0;
|
||
foreach (var s in d.arena.samples) topScore = Mathf.Max(topScore, s.score);
|
||
d.arena.seasonScore = topScore + 1;
|
||
Assert.AreEqual(1, ArenaRules.Rank(d));
|
||
int gem = d.gem;
|
||
ArenaRules.EnsureSeason(Db, d, T0.AddDays(A.SeasonDays), rng);
|
||
Assert.AreEqual(gem + A.RewardTop10Gem, d.gem, "시즌 1위 보상");
|
||
Assert.AreEqual(0, d.arena.seasonScore, "새 시즌");
|
||
Assert.AreEqual(A.SampleLineups, d.arena.samples.Count);
|
||
|
||
var hid = d.heroes[0].id;
|
||
int sh = d.heroes[0].shards;
|
||
d.arena.medals = A.ShopPrice;
|
||
Assert.IsNull(ArenaRules.BuyShards(Db, d, hid, T0.AddDays(A.SeasonDays)));
|
||
Assert.AreEqual(sh + A.ShopShards, d.Hero(hid).shards, "메달 → 조각");
|
||
Assert.AreEqual(0, d.arena.medals);
|
||
StringAssert.Contains("메달", ArenaRules.BuyShards(Db, d, hid, T0.AddDays(A.SeasonDays)));
|
||
}
|
||
|
||
[Test]
|
||
public void Raid_WeeklyBoss_Accumulate_Daily()
|
||
{
|
||
var e = Db.Economy;
|
||
var d = NewSave();
|
||
var boss = ArenaRules.RaidBoss(Db, d, T0);
|
||
Assert.Contains(boss, e.RaidBosses);
|
||
if (e.RaidBosses.Length > 1) Assert.AreNotEqual(boss, ArenaRules.RaidBoss(Db, NewSave(), T0.AddDays(7)), "주간 순환");
|
||
var h = Db.Heroes.Get(boss);
|
||
var st = ArenaRules.RaidStage(Db, Cfg, boss);
|
||
BalanceConfig.EnemySpawn b = null, srcB = null;
|
||
foreach (var x in st.enemies)
|
||
if (x.isBoss && x.art == h.art) b = x;
|
||
Assert.IsNotNull(b, "보스 = 그 영웅 아트");
|
||
foreach (var s in Cfg.stages)
|
||
foreach (var x in s.enemies)
|
||
if (srcB == null && x.isBoss && x.art == h.art) srcB = x;
|
||
if (srcB != null) Assert.AreEqual(srcB.hpMult * e.RaidHpMult, b.hpMult, 1e-4f, "보스 hp × raid_hp_mult");
|
||
ArenaRules.RaidResult(Db, d, boss, 500, false, T0, new System.Random(1));
|
||
Assert.AreEqual(500, d.arena.raidDamage);
|
||
Assert.AreEqual(1, TreasureRules.ChestCount(d, e.RaidChest), "명장 상자");
|
||
Assert.IsNotNull(ArenaRules.CanRaid(Db, d, T0), "하루 상한");
|
||
var sameWeek = T0;
|
||
for (int k = 1; k < 7; k++)
|
||
if (ArenaRules.WeekKey(T0.AddDays(k)) == ArenaRules.WeekKey(T0)) sameWeek = T0.AddDays(k);
|
||
if (sameWeek != T0)
|
||
{
|
||
Assert.IsNull(ArenaRules.CanRaid(Db, d, sameWeek));
|
||
ArenaRules.RaidResult(Db, d, boss, 300, false, sameWeek, new System.Random(1));
|
||
Assert.AreEqual(800, d.arena.raidDamage, "같은 주 누적");
|
||
}
|
||
ArenaRules.RaidBoss(Db, d, T0.AddDays(7));
|
||
Assert.AreEqual(0, d.arena.raidDamage, "주가 바뀌면 초기화");
|
||
}
|
||
|
||
// ---------- 씬(화면 · 모드 전투) ----------
|
||
|
||
OutGameRoot og;
|
||
BattleManager bm;
|
||
|
||
IEnumerator Boot()
|
||
{
|
||
WorldProgress.Reset();
|
||
SaveStore.UseMemory(true);
|
||
SceneManager.LoadScene("Battle");
|
||
yield return null;
|
||
yield return null;
|
||
og = OutGameRoot.Instance;
|
||
bm = BattleManager.Instance;
|
||
Assert.IsNotNull(og);
|
||
og.ShowLobby();
|
||
}
|
||
|
||
[UnityTest]
|
||
public IEnumerator Screens_Domestic_Treasure_Arena_TradeChest()
|
||
{
|
||
yield return Boot();
|
||
var s = og.Session;
|
||
og.OnTab(2);
|
||
Assert.AreEqual(og.Domestic, og.Current);
|
||
for (int p = 0; p < DomesticScreen.PageNames.Length; p++)
|
||
{
|
||
og.Domestic.SetPage(p);
|
||
yield return null;
|
||
}
|
||
Assert.AreEqual(s.Db.Dev.InBranch(og.Domestic.Branch).Count, og.Domestic.NodeCount, "개발 트리 노드");
|
||
og.Domestic.SetBranch(1);
|
||
yield return null;
|
||
Assert.AreEqual(s.Db.Dev.InBranch(s.Db.Dev.Branches[1]).Count, og.Domestic.NodeCount, "갈래 ▶");
|
||
og.Domestic.NodePopup(s.Db.Dev.InBranch(og.Domestic.Branch)[0].id);
|
||
Assert.IsTrue(og.ModalVisible, "노드 탭 = 강화 팝업");
|
||
og.CloseModal();
|
||
|
||
og.OnTab(1);
|
||
Assert.AreEqual(og.Treasures, og.Current);
|
||
og.Treasures.SetPage(0);
|
||
yield return null;
|
||
Assert.AreEqual(s.Db.Treasures.items.Count, og.Treasures.GridCount, "보물 칸 = 전체(미보유 회색)");
|
||
og.Treasures.SetPage(1);
|
||
yield return null;
|
||
Assert.AreEqual(s.Db.TreasureSets.SetIds.Count, og.Treasures.SetCount, "세트 묶음");
|
||
Counts.Set(s.Save.inv.chests, s.Db.Economy.StageChest, 1);
|
||
og.Treasures.SetPage(2);
|
||
og.Treasures.SelectChest(s.Db.Economy.StageChest);
|
||
yield return null;
|
||
og.Treasures.DoOpen(s.Db.Economy.StageChest);
|
||
Assert.IsNotNull(og.Treasures.LastOpen, "열기");
|
||
Assert.AreEqual(1, s.Save.inv.treasures.Count, "첫 보물");
|
||
og.CloseModal();
|
||
|
||
og.OnTab(4);
|
||
og.Trade.SetPage(1);
|
||
yield return null;
|
||
Assert.AreEqual(s.Db.Chests.chests.Count, og.Trade.ChestRowCount, "거래 > 상자");
|
||
|
||
og.ShowLobby();
|
||
og.Arena.SetPage(0);
|
||
og.Show(og.Arena);
|
||
yield return null;
|
||
Assert.AreEqual(og.Arena, og.Current);
|
||
Assert.AreEqual(s.Db.Arena.SampleLineups, s.Save.arena.samples.Count, "연무장 진입 = 시즌·샘플");
|
||
for (int p = 1; p <= 4; p++)
|
||
{
|
||
og.Arena.SetPage(p);
|
||
yield return null;
|
||
}
|
||
og.Back();
|
||
Assert.AreEqual(0, og.Arena.Page, "모드 ◀ = 카드");
|
||
og.Back();
|
||
Assert.IsTrue(og.LobbyVisible);
|
||
}
|
||
|
||
[UnityTest]
|
||
public IEnumerator ModeBattle_Tower_Raid_Result_Return_Counters_SideEffects()
|
||
{
|
||
yield return Boot();
|
||
var s = og.Session;
|
||
Time.timeScale = 20f;
|
||
try
|
||
{
|
||
// 탑 1층: 입장권 1장 → 모드 전투(층 배율 적) → 적 전멸 = 승리 → 결과 패널 → 탭 = 연무장 탑 페이지
|
||
Assert.IsNull(s.Do(() => ArenaRules.EnterTower(s.Db, s.Save, s.Now)));
|
||
var stage = ArenaRules.TowerStage(s.Db, bm.Config, 1);
|
||
og.StartMode(ArenaRules.Tower, "", 1, stage, 0, 1);
|
||
yield return null;
|
||
Assert.IsNotNull(bm.Mode);
|
||
Assert.AreEqual(BattlePhase.PlayerTurn, bm.Phase);
|
||
Assert.AreEqual(stage.enemies.Count, bm.AliveCount(Faction.Enemy));
|
||
Assert.Greater(bm.AliveCount(Faction.Player), 0, "아군 = 출전 편성");
|
||
|
||
// 전투 이벤트 카운터: 아군만 센다
|
||
var p0 = bm.AliveUnits(Faction.Player)[0];
|
||
int au = TreasureRules.Counter(s.Save, BattleEvents.ActiveUses);
|
||
BattleEvents.Raise(BattleEvents.ActiveUses, p0);
|
||
BattleEvents.Raise(BattleEvents.ActiveUses, bm.AliveUnits(Faction.Enemy)[0]);
|
||
Assert.AreEqual(au + 1, TreasureRules.Counter(s.Save, BattleEvents.ActiveUses), "적 행동은 세지 않음");
|
||
|
||
int battles = TreasureRules.Counter(s.Save, BattleEvents.Battles);
|
||
foreach (var u in bm.AliveUnits(Faction.Enemy)) u.TakeDamage(u.Hp);
|
||
bm.CheckBattleEnd();
|
||
yield return null;
|
||
Assert.AreEqual(BattlePhase.StageClear, bm.Phase);
|
||
Assert.IsTrue(og.ResultVisible, "결과 패널");
|
||
Assert.AreEqual(1, s.Save.arena.towerFloor, "탑 1층 클리어");
|
||
Assert.IsTrue(s.LastMode.win);
|
||
Assert.AreEqual(battles + 1, TreasureRules.Counter(s.Save, BattleEvents.Battles), "전투 카운터");
|
||
bm.ContinueAfterResult();
|
||
yield return null;
|
||
Assert.IsNull(bm.Mode);
|
||
Assert.AreEqual(BattlePhase.Setup, bm.Phase);
|
||
Assert.AreEqual(og.Arena, og.Current, "탭 = 연무장");
|
||
Assert.AreEqual(1, og.Arena.Page, "탑 페이지로");
|
||
|
||
// 적장 토벌: 제한 1턴 → 적 턴을 마치면 끝 · 보스에게 준 피해 누적
|
||
var boss = ArenaRules.RaidBoss(s.Db, s.Save, s.Now);
|
||
og.StartMode(ArenaRules.Raid, boss, 0, ArenaRules.RaidStage(s.Db, bm.Config, boss), 1, 4);
|
||
yield return null;
|
||
Unit bu = null;
|
||
foreach (var u in bm.AliveUnits(Faction.Enemy))
|
||
if (u.IsBoss) bu = u;
|
||
Assert.IsNotNull(bu);
|
||
bu.TakeDamage(100);
|
||
yield return bm.RunEnemyTurn();
|
||
Assert.AreEqual(BattlePhase.Defeat, bm.Phase, "제한 턴 = 끝");
|
||
yield return null;
|
||
int dealt = 0;
|
||
foreach (var u in bm.Units)
|
||
if (u != null && u.Faction == Faction.Enemy && u.IsBoss) dealt += u.MaxHp - u.Hp;
|
||
Assert.GreaterOrEqual(dealt, 100);
|
||
Assert.AreEqual(dealt, s.Save.arena.raidDamage, "보스 피해 누적");
|
||
Assert.GreaterOrEqual(TreasureRules.ChestCount(s.Save, s.Db.Economy.RaidChest), 1, "명장 상자");
|
||
bm.ContinueAfterResult();
|
||
yield return null;
|
||
Assert.AreEqual(4, og.Arena.Page);
|
||
|
||
// 보물 crit = 진영 상시 효과 → 크리 배율
|
||
TreasureDb.Item crit = null;
|
||
foreach (var it in s.Db.Treasures.items)
|
||
if (crit == null && it.baseStat == "crit") crit = it;
|
||
int dummy;
|
||
TreasureRules.Grant(s.Save, crit, out dummy);
|
||
bm.StartStage(0);
|
||
yield return null;
|
||
var pu = bm.AliveUnits(Faction.Player)[0];
|
||
Assert.AreEqual(bm.Config.critMultiplier * (1f + TreasureRules.StatPct(s.Db, s.Save, "crit") / 100f), SkillMods.CritMult(pu, bm.Config), 1e-4f, "보물 크리");
|
||
Assert.AreEqual(bm.Config.critMultiplier, SkillMods.CritMult(bm.AliveUnits(Faction.Enemy)[0], bm.Config), 1e-4f, "적 = 미적용");
|
||
}
|
||
finally
|
||
{
|
||
Time.timeScale = 1f;
|
||
}
|
||
}
|
||
}
|
||
}
|