874 lines
48 KiB
C#
874 lines
48 KiB
C#
// WL813i2_Probe.cs — #813i2(보스 연타 대비 피격 후 무적 창 · 보스 예고 중 자동 회피 스텝) 에디트 모드 검증 프로브
|
||
// 에디트 모드 전용 · Play 불필요 · 로그인 0 · 씬/에셋 무수정(임시 GameObject·임시 SO 클론은 즉시 파괴)
|
||
//
|
||
// 상주 에디터: unity command run_script --project-path <wt> --file AgentScripts/WL813i2_Probe.cs --entry WL813i2_Probe.RunAll --timeout 300
|
||
// 결과: Console + AgentScripts/WL813i2_PROBE.txt (RESULT PASS / RESULT FAIL n)
|
||
//
|
||
// 검사 (발주서 WL-813i2 §1-4)
|
||
// ⓐ 에셋·SOT: WLSurvivalSettings 신규 6필드 + autoPotionHpRatio 0.55 · WLRunGuideSettings 신규 9필드
|
||
// ⓑ 🔴 가짜 보스 5연타(0.52 s 등간격 · Q10 §6 실측 재현) → 실제로 들어간 타수 · HP 궤적
|
||
// ⓒ 무적 창 ms 실측(열림 → 경계 직전 → 경계 직후)
|
||
// ⓓ 잡몹 5연타 → 무적 0(mobHitInvincible=0) · 옵션을 켜면 창이 열린다
|
||
// ⓔ 최소 실피해 게이트(hitInvincibleMinHpLoss) · 부활 창 우선순위 · 런 경계에서 창이 닫힌다
|
||
// ⓕ 예고 감지: 실제 Anubis 컨트롤러의 상태 이름 대조 + Animator 상태 판정 + 안전 폴백(null·컨트롤러 없음)
|
||
// ⓖ 회피 스텝 판정 6분기 + 「예고 1건에 1회」(쿨다운) · NavMesh 밖 = 스텝 0
|
||
// ⓗ GC 0 (TakeDamage ×200k · IsHitInvincible ×200k · DodgeDecision ×200k)
|
||
// ⓘ C8: bossHitInvincibleSeconds=0 → 원래(5연타 5타 전부) · dodgeStepEnabled=0 → 스텝 판정 kDodgeOff
|
||
// ⓙ 정리(임시 오브젝트 0 · MyPC 원복 · 에셋 캐시 원복 · 씬 dirty 불변)
|
||
//
|
||
// 에디트 모드 한계(완료보고 「미확인」)
|
||
// · NavMesh 가 없어 NavMeshAgent.Move 실이동(3 m)은 못 잰다 → SampleStep 이 실패해 DodgeFailedNavMesh 로 떨어진다.
|
||
// 스텝 「판정」과 「1회만」은 순수 함수(DodgeDecision)로, 방향 계산은 별도 산술로 검증한다.
|
||
// · 보스 차징 코루틴은 Play 에서만 돌아 「예고 → 발동 ms」는 인게임 QA 몫이다.
|
||
|
||
using System;
|
||
using System.IO;
|
||
using System.Reflection;
|
||
using System.Text;
|
||
using UnityEngine;
|
||
using WL.Combat.Run;
|
||
using WL.Combat.Survival;
|
||
|
||
public static class WL813i2_Probe
|
||
{
|
||
const string OutDir = "Screenshots_WL/WL813i2";
|
||
const string OutCommit = "AgentScripts/WL813i2_PROBE.txt";
|
||
const BindingFlags NP = BindingFlags.NonPublic | BindingFlags.Instance;
|
||
const BindingFlags NS = BindingFlags.NonPublic | BindingFlags.Static;
|
||
|
||
// Q10 §6 실측 = 0.52 s 등간격 5연타 · 원 피해 222(death_200823_6.txt 14~16행)
|
||
const float ComboInterval = 0.52f;
|
||
const double BossRawDamage = 222d;
|
||
const double PcMaxHp = 310d;
|
||
|
||
const string AnubisController =
|
||
"Assets/ResWork/Suriyun/Monster Pack Pyramid/Animations/Anubis/Anubis_Animations_Check.controller";
|
||
|
||
static WLSurvivalSettings s_clone;
|
||
static WLRunGuideSettings s_rgClone;
|
||
|
||
public static object RunAll()
|
||
{
|
||
var sb = new StringBuilder();
|
||
sb.AppendLine("# WL813i2 Probe " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " (edit mode · Play 0 · 로그인 0)");
|
||
sb.AppendLine("playMode=" + Application.isPlaying);
|
||
int fail = 0;
|
||
var pc0 = MyValue.MyPC;
|
||
bool dirty0 = UnityEngine.SceneManagement.SceneManager.GetActiveScene().isDirty;
|
||
|
||
try { fail += Asset(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓐ 예외 " + ex); }
|
||
try { fail += BossCombo(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓑ 예외 " + ex); }
|
||
try { fail += WindowMs(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓒ 예외 " + ex); }
|
||
try { fail += MobCombo(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓓ 예외 " + ex); }
|
||
try { fail += Gates(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓔ 예외 " + ex); }
|
||
try { fail += Telegraph(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓕ 예외 " + ex); }
|
||
try { fail += DodgeLogic(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓖ 예외 " + ex); }
|
||
try { fail += Gc(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓗ 예외 " + ex); }
|
||
try { fail += C8(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓘ 예외 " + ex); }
|
||
|
||
RestoreAssets();
|
||
MyValue.MyPC = pc0;
|
||
Survival.ResetDiagnostics();
|
||
try { fail += Cleanup(sb, dirty0); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⓙ 예외 " + ex); }
|
||
|
||
string result = fail == 0 ? "RESULT PASS" : ("RESULT FAIL " + fail);
|
||
sb.AppendLine(); sb.AppendLine(result);
|
||
string body = sb.ToString();
|
||
Write(body);
|
||
Debug.Log(body);
|
||
return result;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓐ 에셋 (디스크 값 실측)
|
||
static int Asset(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓐ 에셋 실측 (디스크 값 · 클론 아님)");
|
||
|
||
var st = WLSurvivalSettings.Instance;
|
||
bool a1 = st != null;
|
||
sb.AppendLine(P(a1) + " WLSurvivalSettings 로드 " + (a1 ? "OK" : "null")); if (!a1) return f + 1;
|
||
|
||
bool a2 = st.hitInvincibleEnabled && Math.Abs(st.bossHitInvincibleSeconds - 0.6f) < 1e-4
|
||
&& !st.mobHitInvincible && Math.Abs(st.mobHitInvincibleSeconds - 0.2f) < 1e-4
|
||
&& Math.Abs(st.hitInvincibleMinHpLoss - 1f) < 1e-4 && !st.hitInvincibleLog;
|
||
sb.AppendLine(P(a2) + " 신규 6필드 hitInv=" + st.hitInvincibleEnabled
|
||
+ " boss=" + st.bossHitInvincibleSeconds + "s mob=" + st.mobHitInvincible + "/" + st.mobHitInvincibleSeconds
|
||
+ "s minLoss=" + st.hitInvincibleMinHpLoss + " log=" + st.hitInvincibleLog); if (!a2) f++;
|
||
|
||
bool a3 = Math.Abs(st.autoPotionHpRatio - 0.55f) < 1e-4;
|
||
sb.AppendLine(P(a3) + " §1-3 값 autoPotionHpRatio = " + st.autoPotionHpRatio + " (0.45 → 0.55)"); if (!a3) f++;
|
||
|
||
// 813m2 §4 병목 근거 — 회복량과 임계의 합이 1 을 넘으면 그만큼 회복이 낭비된다(값 판단은 Lead).
|
||
float waste = st.autoPotionHpRatio + st.potionHealRate - 1f;
|
||
sb.AppendLine(" · 참고: 임계 " + st.autoPotionHpRatio + " + 회복 " + st.potionHealRate
|
||
+ " = " + (st.autoPotionHpRatio + st.potionHealRate).ToString("F2")
|
||
+ (waste > 0f ? " → 만충 초과 " + (waste * 100f).ToString("F0") + " % 낭비(실측)" : " → 낭비 0"));
|
||
|
||
bool a4 = Math.Abs(st.bossDamageMultiplier - 0.1f) < 1e-4 && Math.Abs(st.mobDamageMultiplier - 0.1f) < 1e-4;
|
||
sb.AppendLine(P(a4) + " 기존 배율(F-17) boss=" + st.bossDamageMultiplier + " mob=" + st.mobDamageMultiplier); if (!a4) f++;
|
||
|
||
var cfg = WLRunGuideSettings.Instance;
|
||
bool a5 = cfg != null;
|
||
sb.AppendLine(P(a5) + " WLRunGuideSettings 로드 " + (a5 ? "OK" : "null")); if (!a5) return f + 1;
|
||
|
||
var names = cfg.dodgeTelegraphStates;
|
||
bool a6 = cfg.dodgeStepEnabled && names != null && names.Length == 2
|
||
&& names[0] == "boss_skill1charging" && names[1] == "boss_skill2charging"
|
||
&& Math.Abs(cfg.dodgeStepDistance - 3f) < 1e-4 && Math.Abs(cfg.dodgeStepSeconds - 0.3f) < 1e-4
|
||
&& Math.Abs(cfg.dodgeStepSideBias) < 1e-4 && Math.Abs(cfg.dodgeStepBossRadius - 14f) < 1e-4
|
||
&& Math.Abs(cfg.dodgeStepCooldownSeconds - 1.5f) < 1e-4
|
||
&& Math.Abs(cfg.dodgeStepNavSampleRadius - 2f) < 1e-4 && cfg.dodgeStepLog;
|
||
sb.AppendLine(P(a6) + " 신규 9필드 dodge=" + cfg.dodgeStepEnabled
|
||
+ " states=" + (names == null ? "null" : string.Join("|", names))
|
||
+ " dist=" + cfg.dodgeStepDistance + "m/" + cfg.dodgeStepSeconds + "s side=" + cfg.dodgeStepSideBias
|
||
+ " radius=" + cfg.dodgeStepBossRadius + " cool=" + cfg.dodgeStepCooldownSeconds
|
||
+ " nav=" + cfg.dodgeStepNavSampleRadius + " log=" + cfg.dodgeStepLog); if (!a6) f++;
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓑ 🔴 보스 5연타(0.52 s) 재현
|
||
static int BossCombo(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓑ 🔴 보스 5연타 0.52 s (Q10 §6 재현 · 원 피해 " + BossRawDamage + " ×0.10)");
|
||
var st = UseClone(); if (st == null) return f + 1;
|
||
st.enabled = true; WLSurvivalSettings.RuntimeOverride = 1;
|
||
st.takeMobDamage = true; st.takeBossDamage = true;
|
||
st.mobDamageMultiplier = 0.1f; st.bossDamageMultiplier = 0.1f;
|
||
st.unscaledDamageGuardEnabled = false; st.deathDiagEnabled = true;
|
||
st.hitInvincibleEnabled = true; st.bossHitInvincibleSeconds = 0.6f;
|
||
st.mobHitInvincible = false; st.hitInvincibleMinHpLoss = 1f;
|
||
|
||
var pc = MakePC("i2_pc", PcMaxHp, PcMaxHp);
|
||
var boss = MakeBeater("i2_boss", eSubRol.Boss);
|
||
var pc0 = MyValue.MyPC; MyValue.MyPC = pc;
|
||
try
|
||
{
|
||
Survival.ResetDiagnostics(); DeathDiag.ResetDiagnostics();
|
||
sb.AppendLine("| # | t(s) | 원 피해 | 결과 | HP after | via |");
|
||
sb.AppendLine("|---|---|---|---|---|---|");
|
||
|
||
int landed = 0;
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
float t = i * ComboInterval;
|
||
Survival.Tick(t);
|
||
double before = pc.Get_HP();
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc));
|
||
double after = pc.Get_HP();
|
||
bool hit = before - after > 1e-6;
|
||
if (hit) landed++;
|
||
var rec = DeathDiag.Get(i);
|
||
sb.AppendLine("| " + (i + 1) + " | " + t.ToString("F2") + " | " + BossRawDamage.ToString("F0")
|
||
+ " | " + (hit ? "🔴 피격 −" + (before - after).ToString("F1") : "무적(흘림)")
|
||
+ " | " + after.ToString("F0") + "/" + PcMaxHp.ToString("F0")
|
||
+ " | " + rec.via + " |");
|
||
}
|
||
|
||
double hpEnd = pc.Get_HP();
|
||
bool b1 = landed < 5 && landed >= 1;
|
||
sb.AppendLine(P(b1) + " 🔴 5연타 중 **실제 피격 " + landed + "타** (창 " + st.bossHitInvincibleSeconds
|
||
+ "s · 발주서 §1-1 목표 「1~2타」 · 아래 스윕 표 참조)"); if (!b1) f++;
|
||
|
||
bool b2 = Survival.BlockedHitInvincible == 5 - landed;
|
||
sb.AppendLine(P(b2) + " 무적이 막은 타수 = " + Survival.BlockedHitInvincible + " (5 − 피격 " + landed + ")"); if (!b2) f++;
|
||
|
||
bool b3 = Survival.HitInvincibleOpened == landed && Survival.HitInvincibleOpenedByBoss == landed;
|
||
sb.AppendLine(P(b3) + " 창 연 횟수 " + Survival.HitInvincibleOpened
|
||
+ "(보스 " + Survival.HitInvincibleOpenedByBoss + ") = 피격 타수"); if (!b3) f++;
|
||
|
||
bool b4 = hpEnd > 0d;
|
||
sb.AppendLine(P(b4) + " 🔴 5연타 후 생존 HP = " + hpEnd.ToString("F0") + "/" + PcMaxHp.ToString("F0")
|
||
+ " (Q10 실측 = 5대에 사망)"); if (!b4) f++;
|
||
|
||
// 대조군 — 무적 창을 끄면 5타 전부 들어간다(= Q10 실측 상황)
|
||
st.hitInvincibleEnabled = false;
|
||
var pcB = MakePC("i2_pcB", PcMaxHp, PcMaxHp);
|
||
MyValue.MyPC = pcB;
|
||
Survival.ResetDiagnostics();
|
||
int landedOff = 0;
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
Survival.Tick(i * ComboInterval);
|
||
double before = pcB.Get_HP();
|
||
Survival.TakeDamage(pcB, Dmg(boss, BossRawDamage), ApplyToPc(pcB));
|
||
if (before - pcB.Get_HP() > 1e-6) landedOff++;
|
||
}
|
||
bool b5 = landedOff == 5;
|
||
sb.AppendLine(P(b5) + " 대조군(창 off) = " + landedOff + "타 전부 피격 · HP " + pcB.Get_HP().ToString("F0")
|
||
+ "/" + PcMaxHp.ToString("F0") + " → 창이 만든 차이 " + (landedOff - landed) + "타"); if (!b5) f++;
|
||
Kill(pcB);
|
||
st.hitInvincibleEnabled = true;
|
||
|
||
// 🔴 값 스윕 — 「1~2타」를 만드는 창 길이가 얼마인가(값 결정은 Lead · 여기서는 실측만).
|
||
// 간격 0.52 s 등차 5타에서 창 W 는 W/0.52 타를 흘린다 → 필요한 W 는 0.52 의 배수 경계에 걸린다.
|
||
sb.AppendLine();
|
||
sb.AppendLine("| 창(초) | 피격 타수 | 5연타 후 HP | 흘린 타 |");
|
||
sb.AppendLine("|---|---|---|---|");
|
||
float[] sweep = { 0f, 0.30f, 0.53f, 0.60f, 0.80f, 1.05f, 1.30f, 1.60f, 2.10f };
|
||
for (int k = 0; k < sweep.Length; k++)
|
||
{
|
||
st.hitInvincibleEnabled = sweep[k] > 0f;
|
||
st.bossHitInvincibleSeconds = sweep[k];
|
||
var pcS = MakePC("i2_sw" + k, PcMaxHp, PcMaxHp);
|
||
MyValue.MyPC = pcS;
|
||
Survival.ResetDiagnostics();
|
||
int L = 0;
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
Survival.Tick(i * ComboInterval);
|
||
double before = pcS.Get_HP();
|
||
Survival.TakeDamage(pcS, Dmg(boss, BossRawDamage), ApplyToPc(pcS));
|
||
if (before - pcS.Get_HP() > 1e-6) L++;
|
||
}
|
||
sb.AppendLine("| " + sweep[k].ToString("F2") + " | " + L + " | " + pcS.Get_HP().ToString("F0")
|
||
+ "/310 | " + Survival.BlockedHitInvincible + " |"
|
||
+ (L >= 1 && L <= 2 ? " ← 발주서 목표 1~2타" : ""));
|
||
Kill(pcS);
|
||
}
|
||
st.hitInvincibleEnabled = true; st.bossHitInvincibleSeconds = 0.6f;
|
||
sb.AppendLine(" · 🔴 에셋 값은 발주서 제안대로 **0.6 s** 로 두었다. 목표(1~2타)를 만드는 최소 창은 위 표의 실측값이다 — **값 결정은 Lead**(C3).");
|
||
}
|
||
finally { MyValue.MyPC = pc0; Kill(pc, boss); }
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓒ 무적 창 ms 실측
|
||
static int WindowMs(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓒ 무적 창 ms 실측");
|
||
var st = UseClone(); if (st == null) return f + 1;
|
||
st.enabled = true; WLSurvivalSettings.RuntimeOverride = 1;
|
||
st.takeBossDamage = true; st.bossDamageMultiplier = 0.1f;
|
||
st.hitInvincibleEnabled = true; st.bossHitInvincibleSeconds = 0.6f; st.hitInvincibleMinHpLoss = 1f;
|
||
st.unscaledDamageGuardEnabled = false;
|
||
|
||
var pc = MakePC("i2_w_pc", PcMaxHp, PcMaxHp);
|
||
var boss = MakeBeater("i2_w_boss", eSubRol.Boss);
|
||
var pc0 = MyValue.MyPC; MyValue.MyPC = pc;
|
||
try
|
||
{
|
||
Survival.ResetDiagnostics();
|
||
Survival.Tick(100f);
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc));
|
||
|
||
float until = Survival.HitInvincibleUntil;
|
||
bool c1 = Math.Abs(until - 100.6f) < 1e-3 && Math.Abs(Survival.LastHitInvincibleSeconds - 0.6f) < 1e-4;
|
||
sb.AppendLine(P(c1) + " 창 열림 t=100.000 → until=" + until.ToString("F3")
|
||
+ " · 길이 " + (Survival.LastHitInvincibleSeconds * 1000f).ToString("F0") + " ms"); if (!c1) f++;
|
||
|
||
Survival.Tick(100.599f);
|
||
bool c2 = Survival.IsHitInvincible(pc) && Survival.HitInvincibleRemaining > 0f;
|
||
sb.AppendLine(P(c2) + " 경계 직전 t=100.599(+599 ms) → 무적 " + c2
|
||
+ " · 잔여 " + (Survival.HitInvincibleRemaining * 1000f).ToString("F1") + " ms"); if (!c2) f++;
|
||
double h1 = pc.Get_HP();
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc));
|
||
bool c3 = Math.Abs(pc.Get_HP() - h1) < 1e-6;
|
||
sb.AppendLine(P(c3) + " 경계 직전 피격 = 피해 0 (HP " + pc.Get_HP().ToString("F0") + " 유지)"); if (!c3) f++;
|
||
|
||
Survival.Tick(100.601f);
|
||
bool c4 = !Survival.IsHitInvincible(pc) && Survival.HitInvincibleRemaining <= 0f;
|
||
sb.AppendLine(P(c4) + " 경계 직후 t=100.601(+601 ms) → 무적 " + Survival.IsHitInvincible(pc)); if (!c4) f++;
|
||
double h2 = pc.Get_HP();
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc));
|
||
double lost = h2 - pc.Get_HP();
|
||
bool c5 = Math.Abs(lost - BossRawDamage * 0.1d) < 1e-3;
|
||
sb.AppendLine(P(c5) + " 경계 직후 피격 = 정상 피해 −" + lost.ToString("F1")
|
||
+ " (원 " + BossRawDamage + " ×0.10)"); if (!c5) f++;
|
||
|
||
// 창 안에서 다시 맞아도 창이 연장되지 않는다(창은 실피해로만 열린다)
|
||
Survival.Tick(100.700f);
|
||
float untilB = Survival.HitInvincibleUntil;
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc));
|
||
bool c6 = Math.Abs(Survival.HitInvincibleUntil - untilB) < 1e-4;
|
||
sb.AppendLine(P(c6) + " 창 안 피격은 창을 연장하지 않는다 until=" + Survival.HitInvincibleUntil.ToString("F3")); if (!c6) f++;
|
||
}
|
||
finally { MyValue.MyPC = pc0; Kill(pc, boss); }
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓓ 잡몹 = 무적 0
|
||
static int MobCombo(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓓ 잡몹 피해 무적 0 (mobHitInvincible=0)");
|
||
var st = UseClone(); if (st == null) return f + 1;
|
||
st.enabled = true; WLSurvivalSettings.RuntimeOverride = 1;
|
||
st.takeMobDamage = true; st.mobDamageMultiplier = 0.1f;
|
||
st.hitInvincibleEnabled = true; st.bossHitInvincibleSeconds = 0.6f;
|
||
st.mobHitInvincible = false; st.mobHitInvincibleSeconds = 0.2f; st.hitInvincibleMinHpLoss = 1f;
|
||
st.unscaledDamageGuardEnabled = false;
|
||
|
||
var pc = MakePC("i2_m_pc", PcMaxHp, PcMaxHp);
|
||
var mob = MakeBeater("i2_m_mob", eSubRol.None);
|
||
var pc0 = MyValue.MyPC; MyValue.MyPC = pc;
|
||
try
|
||
{
|
||
Survival.ResetDiagnostics();
|
||
int landed = 0;
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
Survival.Tick(i * ComboInterval);
|
||
double before = pc.Get_HP();
|
||
Survival.TakeDamage(pc, Dmg(mob, 120d), ApplyToPc(pc));
|
||
if (before - pc.Get_HP() > 1e-6) landed++;
|
||
}
|
||
bool d1 = landed == 5 && Survival.BlockedHitInvincible == 0 && Survival.HitInvincibleOpened == 0;
|
||
sb.AppendLine(P(d1) + " 잡몹 5연타 = " + landed + "타 전부 피격 · 막은타 " + Survival.BlockedHitInvincible
|
||
+ " · 연 창 " + Survival.HitInvincibleOpened + " (실측상 잡몹은 한 방에 0.3~0.4 %)"); if (!d1) f++;
|
||
|
||
// 옵션을 켜면 잡몹도 창이 열린다(SO 하나로 뒤집힌다 = C45)
|
||
st.mobHitInvincible = true;
|
||
var pcB = MakePC("i2_m_pcB", PcMaxHp, PcMaxHp);
|
||
MyValue.MyPC = pcB;
|
||
Survival.ResetDiagnostics();
|
||
int landedOn = 0;
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
Survival.Tick(i * 0.1f); // 0.2 s 창보다 촘촘하게
|
||
double before = pcB.Get_HP();
|
||
Survival.TakeDamage(pcB, Dmg(mob, 120d), ApplyToPc(pcB));
|
||
if (before - pcB.Get_HP() > 1e-6) landedOn++;
|
||
}
|
||
bool d2 = landedOn < 5 && Survival.HitInvincibleOpened == landedOn;
|
||
sb.AppendLine(P(d2) + " mobHitInvincible=1 로 뒤집으면 0.1 s 간격 5타 중 " + landedOn
|
||
+ "타만 피격(창 0.2 s)"); if (!d2) f++;
|
||
Kill(pcB);
|
||
st.mobHitInvincible = false;
|
||
}
|
||
finally { MyValue.MyPC = pc0; Kill(pc, mob); }
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓔ 게이트·우선순위·런 경계
|
||
static int Gates(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓔ 최소 피해 게이트 · 부활 창 우선 · 런 경계");
|
||
var st = UseClone(); if (st == null) return f + 1;
|
||
st.enabled = true; WLSurvivalSettings.RuntimeOverride = 1;
|
||
st.takeBossDamage = true; st.bossDamageMultiplier = 0.1f;
|
||
st.hitInvincibleEnabled = true; st.bossHitInvincibleSeconds = 0.6f; st.hitInvincibleMinHpLoss = 1f;
|
||
st.unscaledDamageGuardEnabled = false;
|
||
|
||
var pc = MakePC("i2_g_pc", PcMaxHp, PcMaxHp);
|
||
var boss = MakeBeater("i2_g_boss", eSubRol.Boss);
|
||
var pc0 = MyValue.MyPC; MyValue.MyPC = pc;
|
||
try
|
||
{
|
||
// ① 순수 함수 판정표 (Actor 접근 0 · C8 증거)
|
||
sb.AppendLine("| 입력(boss · hpLost) | 창(초) |");
|
||
sb.AppendLine("|---|---|");
|
||
float[] w = new float[5];
|
||
w[0] = Survival.HitInvincibleWindow(st, true, 30d);
|
||
w[1] = Survival.HitInvincibleWindow(st, true, 0.5d);
|
||
w[2] = Survival.HitInvincibleWindow(st, false, 30d);
|
||
st.mobHitInvincible = true;
|
||
w[3] = Survival.HitInvincibleWindow(st, false, 30d);
|
||
st.mobHitInvincible = false;
|
||
w[4] = Survival.HitInvincibleWindow(null, true, 30d);
|
||
sb.AppendLine("| boss · 30 HP | " + w[0] + " |");
|
||
sb.AppendLine("| boss · 0.5 HP(<minLoss 1) | " + w[1] + " |");
|
||
sb.AppendLine("| mob · 30 HP (mobHitInv=0) | " + w[2] + " |");
|
||
sb.AppendLine("| mob · 30 HP (mobHitInv=1) | " + w[3] + " |");
|
||
sb.AppendLine("| SO null | " + w[4] + " |");
|
||
bool e1 = Math.Abs(w[0] - 0.6f) < 1e-4 && w[1] == 0f && w[2] == 0f
|
||
&& Math.Abs(w[3] - 0.2f) < 1e-4 && w[4] == 0f;
|
||
sb.AppendLine(P(e1) + " HitInvincibleWindow 5분기 전부 기대값"); if (!e1) f++;
|
||
|
||
// ② 스침 타격(실피해 0)은 창을 열지 않는다 — 방어로 0 이 된 타격
|
||
Survival.ResetDiagnostics();
|
||
Survival.Tick(0f);
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), NoDamage()); // base 가 HP 를 안 깎는다
|
||
bool e2 = Survival.HitInvincibleOpened == 0 && !Survival.IsHitInvincible(pc);
|
||
sb.AppendLine(P(e2) + " 실피해 0 인 타격은 창을 열지 않는다(연 창 " + Survival.HitInvincibleOpened + ")"); if (!e2) f++;
|
||
|
||
// ③ 부활 창이 우선(via=ReviveInv) — 두 창이 겹쳐도 진단이 섞이지 않는다
|
||
Survival.ResetDiagnostics(); DeathDiag.ResetDiagnostics();
|
||
Survival.Tick(10f);
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc)); // 창 열림
|
||
Survival.SetReviveInvincible(pc, 5f); // 부활 = 피격 창도 닫는다
|
||
bool e3 = !Survival.IsHitInvincible(pc) && Survival.IsReviveInvincible(pc);
|
||
sb.AppendLine(P(e3) + " 부활 창이 열리면 피격 창은 닫힌다(hitInv=" + Survival.IsHitInvincible(pc)
|
||
+ " reviveInv=" + Survival.IsReviveInvincible(pc) + ")"); if (!e3) f++;
|
||
int n0 = DeathDiag.RecordCount;
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), NoDamage());
|
||
var r = DeathDiag.Get(n0);
|
||
bool e4 = r.via == DamageVia.ReviveInv && Survival.BlockedReviveInvincible == 1 && Survival.BlockedHitInvincible == 0;
|
||
sb.AppendLine(P(e4) + " 겹칠 때 via=" + r.via + " (부활 " + Survival.BlockedReviveInvincible
|
||
+ " / 피격 " + Survival.BlockedHitInvincible + ")"); if (!e4) f++;
|
||
Survival.SetReviveInvincible(null, 0f);
|
||
|
||
// ④ via=HitInv 가 사망 파일에 남는다
|
||
Survival.ResetDiagnostics(); DeathDiag.ResetDiagnostics();
|
||
Survival.Tick(20f);
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc));
|
||
Survival.Tick(20.2f);
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), NoDamage());
|
||
var r2 = DeathDiag.Get(1);
|
||
bool e5 = r2.via == DamageVia.HitInv && Survival.BlockedHitInvincible == 1;
|
||
sb.AppendLine(P(e5) + " 흘린 타의 진단 via=" + r2.via + " (새 값 HitInv=5)"); if (!e5) f++;
|
||
|
||
// ⑤ 런 경계(OnRunStart → SetReviveInvincible(null,0))가 창을 닫는다
|
||
Survival.SetHitInvincible(pc, 5f);
|
||
Survival.SetReviveInvincible(null, 0f);
|
||
bool e6 = !Survival.IsHitInvincible(pc);
|
||
sb.AppendLine(P(e6) + " 런 경계에서 피격 창이 닫힌다"); if (!e6) f++;
|
||
}
|
||
finally { MyValue.MyPC = pc0; Kill(pc, boss); }
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓕ 예고 감지
|
||
static int Telegraph(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓕ 예고(차징) 감지 — 공개 경로 = Actor.m_animation");
|
||
var cfg = UseRgClone(); if (cfg == null) return f + 1;
|
||
cfg.enabled = true; WLRunGuideSettings.RuntimeDisabled = false;
|
||
cfg.dodgeStepEnabled = true;
|
||
|
||
// ① SO 의 상태 이름이 **실제 컨트롤러에 있는가**(813b/813h 실측 대조)
|
||
var rac = UnityEditor.AssetDatabase.LoadAssetAtPath<RuntimeAnimatorController>(AnubisController);
|
||
bool t1 = rac != null;
|
||
sb.AppendLine(P(t1) + " Anubis 컨트롤러 로드 " + (t1 ? rac.name : "null") + " (" + AnubisController + ")");
|
||
if (!t1) return f + 1;
|
||
|
||
var go = new GameObject("__WL813i2_boss");
|
||
var actor = go.AddComponent<Actor>();
|
||
actor.m_Role = eRole.Mob; actor.m_SubRole = eSubRol.Boss;
|
||
var anim = go.AddComponent<Animator>();
|
||
anim.runtimeAnimatorController = rac;
|
||
actor.m_animation = anim;
|
||
try
|
||
{
|
||
var names = cfg.dodgeTelegraphStates;
|
||
sb.AppendLine(" · 컨트롤러 레이어 수 = " + anim.layerCount);
|
||
bool t2 = true;
|
||
for (int i = 0; i < names.Length; i++)
|
||
{
|
||
int hash = Animator.StringToHash(names[i]);
|
||
int found = -1;
|
||
for (int L = 0; L < anim.layerCount; L++)
|
||
if (anim.HasState(L, hash)) { found = L; break; }
|
||
sb.AppendLine(" · \"" + names[i] + "\" → 레이어 " + (found < 0 ? "없음" : found.ToString())
|
||
+ " (" + (found < 0 ? "❌" : anim.GetLayerName(found)) + ")");
|
||
if (found < 0) t2 = false;
|
||
}
|
||
sb.AppendLine(P(t2) + " 🔴 SO 상태 이름 " + string.Join(" · ", names)
|
||
+ " 가 실제 Anubis 컨트롤러에 **존재**(Animator.HasState · 전 레이어)"); if (!t2) f++;
|
||
|
||
// ② 그 상태로 재생하면 IsBossTelegraphing 이 true 인가(에디트 모드 Animator 평가)
|
||
anim.Play(names[0], -1, 0f);
|
||
anim.Update(0f);
|
||
bool onCharging = RunGuide.IsBossTelegraphing(cfg, actor);
|
||
anim.Play("idle", -1, 0f);
|
||
anim.Update(0f);
|
||
bool onIdle = RunGuide.IsBossTelegraphing(cfg, actor);
|
||
bool t3 = onCharging && !onIdle;
|
||
sb.AppendLine((t3 ? "[PASS]" : "[WARN]") + " Animator 상태 판정: charging=" + onCharging + " idle=" + onIdle
|
||
+ (t3 ? "" : " ← 에디트 모드 Animator 평가 한계 가능(인게임 QA 로 확인 · 「미확인」)"));
|
||
|
||
// ②-b GC 0 — 예고 판정은 매 프레임 돈다(실제 Animator 로 잰다)
|
||
anim.Play(names[0], -1, 0f); anim.Update(0f);
|
||
for (int i = 0; i < 1000; i++) RunGuide.IsBossTelegraphing(cfg, actor);
|
||
GC.Collect(); long g0 = GC.GetTotalMemory(true);
|
||
for (int i = 0; i < 200000; i++) RunGuide.IsBossTelegraphing(cfg, actor);
|
||
long g1 = GC.GetTotalMemory(false);
|
||
bool tg = g1 - g0 == 0;
|
||
sb.AppendLine(P(tg) + " IsBossTelegraphing ×200,000(실 Animator · 전 레이어) = " + (g1 - g0) + " byte"); if (!tg) f++;
|
||
|
||
// ③ 안전 폴백 — 이 셋은 어떤 경우에도 예외 없이 false 여야 한다
|
||
bool t4 = !RunGuide.IsBossTelegraphing(cfg, null);
|
||
var bare = new GameObject("__WL813i2_bare");
|
||
var bareActor = bare.AddComponent<Actor>();
|
||
bool t5 = !RunGuide.IsBossTelegraphing(cfg, bareActor); // m_animation = null
|
||
var noCtrlGo = new GameObject("__WL813i2_noctrl");
|
||
var noCtrlActor = noCtrlGo.AddComponent<Actor>();
|
||
noCtrlActor.m_animation = noCtrlGo.AddComponent<Animator>(); // 컨트롤러 없음
|
||
bool t6 = !RunGuide.IsBossTelegraphing(cfg, noCtrlActor);
|
||
var empty = cfg.dodgeTelegraphStates;
|
||
cfg.dodgeTelegraphStates = new string[0];
|
||
anim.Play(names[0], -1, 0f); anim.Update(0f);
|
||
bool t7 = !RunGuide.IsBossTelegraphing(cfg, actor); // 목록이 비면 언제나 false(C8)
|
||
cfg.dodgeTelegraphStates = empty;
|
||
bool tOk = t4 && t5 && t6 && t7;
|
||
sb.AppendLine(P(tOk) + " 안전 폴백 null=" + t4 + " 애니메이터 없음=" + t5
|
||
+ " 컨트롤러 없음=" + t6 + " 이름목록 빔=" + t7); if (!tOk) f++;
|
||
Kill(bare, noCtrlGo);
|
||
|
||
// ④ 12보스 컨트롤러 전수 — 어느 보스에 예고 상태가 있는가(값 판단은 Lead · 여기서는 실측만)
|
||
sb.AppendLine();
|
||
sb.AppendLine("| 컨트롤러 | boss_skill1charging | boss_skill2charging |");
|
||
sb.AppendLine("|---|---|---|");
|
||
var guids = UnityEditor.AssetDatabase.FindAssets("t:AnimatorController", new[] { "Assets/ResWork" });
|
||
int withAny = 0, total = 0;
|
||
for (int i = 0; i < guids.Length; i++)
|
||
{
|
||
string path = UnityEditor.AssetDatabase.GUIDToAssetPath(guids[i]);
|
||
var c = UnityEditor.AssetDatabase.LoadAssetAtPath<RuntimeAnimatorController>(path);
|
||
if (c == null) continue;
|
||
var probeGo = new GameObject("__WL813i2_scan");
|
||
var pa = probeGo.AddComponent<Animator>();
|
||
pa.runtimeAnimatorController = c;
|
||
bool h1 = false, h2 = false;
|
||
for (int L = 0; L < pa.layerCount; L++)
|
||
{
|
||
if (pa.HasState(L, Animator.StringToHash("boss_skill1charging"))) h1 = true;
|
||
if (pa.HasState(L, Animator.StringToHash("boss_skill2charging"))) h2 = true;
|
||
}
|
||
Kill(probeGo);
|
||
if (!h1 && !h2) continue;
|
||
total++; withAny++;
|
||
sb.AppendLine("| " + c.name + " | " + (h1 ? "✅" : "—") + " | " + (h2 ? "✅" : "—") + " |");
|
||
}
|
||
sb.AppendLine(" · 예고 상태를 가진 컨트롤러 " + withAny + "종 · Anubis(10006 · Q10 사망 14/14 의 보스)는 2종 다 보유");
|
||
}
|
||
finally { Kill(go); }
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓖ 회피 스텝 판정
|
||
static int DodgeLogic(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓖ 회피 스텝 판정 (순수 함수 · 「예고 1건에 1회」)");
|
||
var cfg = UseRgClone(); if (cfg == null) return f + 1;
|
||
cfg.enabled = true; WLRunGuideSettings.RuntimeDisabled = false;
|
||
cfg.dodgeStepEnabled = true; cfg.dodgeStepDistance = 3f; cfg.dodgeStepSeconds = 0.3f;
|
||
cfg.dodgeStepCooldownSeconds = 1.5f;
|
||
|
||
sb.AppendLine("| 입력(보스반경 · 예고 · PC준비 · 마지막스텝후) | 판정 |");
|
||
sb.AppendLine("|---|---|");
|
||
int g0 = RunGuide.DodgeDecision(cfg, true, true, true, 99f);
|
||
int g1 = RunGuide.DodgeDecision(cfg, true, true, true, 0.5f);
|
||
int g2 = RunGuide.DodgeDecision(cfg, false, true, true, 99f);
|
||
int g3 = RunGuide.DodgeDecision(cfg, true, false, true, 99f);
|
||
int g4 = RunGuide.DodgeDecision(cfg, true, true, false, 99f);
|
||
cfg.dodgeStepEnabled = false;
|
||
int g5 = RunGuide.DodgeDecision(cfg, true, true, true, 99f);
|
||
cfg.dodgeStepEnabled = true;
|
||
int g6 = RunGuide.DodgeDecision(null, true, true, true, 99f);
|
||
sb.AppendLine("| 안 · 예고 · 준비 · 99 s | " + Name(g0) + " |");
|
||
sb.AppendLine("| 안 · 예고 · 준비 · 0.5 s(<쿨 1.5) | " + Name(g1) + " |");
|
||
sb.AppendLine("| 밖 · 예고 · 준비 · 99 s | " + Name(g2) + " |");
|
||
sb.AppendLine("| 안 · 예고아님 · 준비 · 99 s | " + Name(g3) + " |");
|
||
sb.AppendLine("| 안 · 예고 · PC바쁨 · 99 s | " + Name(g4) + " |");
|
||
sb.AppendLine("| dodgeStepEnabled=0 | " + Name(g5) + " |");
|
||
sb.AppendLine("| cfg=null | " + Name(g6) + " |");
|
||
bool ok = g0 == RunGuide.kDodgeGo && g1 == RunGuide.kDodgeCooldown && g2 == RunGuide.kDodgeNoBoss
|
||
&& g3 == RunGuide.kDodgeNoTelegraph && g4 == RunGuide.kDodgePcBusy
|
||
&& g5 == RunGuide.kDodgeOff && g6 == RunGuide.kDodgeOff;
|
||
sb.AppendLine(P(ok) + " 판정 7분기 전부 기대값"); if (!ok) f++;
|
||
|
||
// 「예고 1건에 1회」 — 실측 차징 1.2 s(813h JSON) < 쿨 1.5 s 이므로 한 예고 안에서는 1회뿐이다
|
||
bool g7 = cfg.dodgeStepCooldownSeconds > 1.2f;
|
||
sb.AppendLine(P(g7) + " 🔴 쿨 " + cfg.dodgeStepCooldownSeconds + "s > 실측 차징 1.2 s → **예고 1건에 스텝 1회**"); if (!g7) f++;
|
||
int within = RunGuide.DodgeDecision(cfg, true, true, true, 1.2f);
|
||
bool g8 = within == RunGuide.kDodgeCooldown;
|
||
sb.AppendLine(P(g8) + " 같은 예고 안(1.2 s 경과)의 두 번째 요청 = " + Name(within)); if (!g8) f++;
|
||
|
||
// 방향 산술 — 「예고 방향과 반대」(보스→PC 의 반대쪽) · sideBias 0/1 을 직접 계산해 대조
|
||
Vector3 bossPos = new Vector3(10f, 0f, 0f), pcPos = new Vector3(13f, 0f, 0f);
|
||
Vector3 away = (pcPos - bossPos).normalized;
|
||
Vector3 side = Vector3.Cross(Vector3.up, away);
|
||
bool g9 = Mathf.Abs(away.x - 1f) < 1e-4 && Mathf.Abs(Vector3.Dot(away, side)) < 1e-4;
|
||
sb.AppendLine(P(g9) + " 방향: away=" + away.ToString("F2") + " (보스 반대) · side=" + side.ToString("F2")
|
||
+ " (직교 · dot=" + Vector3.Dot(away, side).ToString("F3") + ") · 스텝 지점 = PC + away×"
|
||
+ cfg.dodgeStepDistance + "m = " + (pcPos + away * cfg.dodgeStepDistance).ToString("F1")); if (!g9) f++;
|
||
sb.AppendLine(" · 계획 속도 = " + cfg.dodgeStepDistance + "m / " + cfg.dodgeStepSeconds + "s = "
|
||
+ (cfg.dodgeStepDistance / cfg.dodgeStepSeconds).ToString("F1") + " m/s (NavMeshAgent.Move 등속)");
|
||
|
||
// NavMesh 없음 = 스텝 0(지형 뚫기 방지) — 에디트 모드에서 실제로 확인되는 값
|
||
RunGuide.ResetDiagnostics();
|
||
RunGuide.ResetDodgeStateForProbe();
|
||
bool moved = RunGuide.ForceDodgeTick(1000f, 0.016f);
|
||
bool g10 = !moved && !RunGuide.Dodging && RunGuide.DodgeSteps == 0;
|
||
sb.AppendLine(P(g10) + " NavMesh/PC 없음 → 스텝 0(Dodging=" + RunGuide.Dodging
|
||
+ " DodgeSteps=" + RunGuide.DodgeSteps + ") · 실이동 3 m 는 인게임 QA 몫(「미확인」)"); if (!g10) f++;
|
||
return f;
|
||
}
|
||
|
||
static string Name(int d)
|
||
{
|
||
if (d == RunGuide.kDodgeGo) return "kDodgeGo";
|
||
if (d == RunGuide.kDodgeOff) return "kDodgeOff";
|
||
if (d == RunGuide.kDodgeCooldown) return "kDodgeCooldown";
|
||
if (d == RunGuide.kDodgeNoBoss) return "kDodgeNoBoss";
|
||
if (d == RunGuide.kDodgeNoTelegraph) return "kDodgeNoTelegraph";
|
||
return "kDodgePcBusy";
|
||
}
|
||
|
||
// ───────────────────────────────── ⓗ GC 0
|
||
static int Gc(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓗ GC 0 (핫 경로)");
|
||
var st = UseClone(); if (st == null) return f + 1;
|
||
st.enabled = true; WLSurvivalSettings.RuntimeOverride = 1;
|
||
st.takeBossDamage = true; st.bossDamageMultiplier = 0.1f;
|
||
st.hitInvincibleEnabled = true; st.bossHitInvincibleSeconds = 0.6f;
|
||
st.unscaledDamageGuardEnabled = false; st.deathDiagEnabled = true; st.hitInvincibleLog = false;
|
||
var cfg = UseRgClone(); if (cfg == null) return f + 1;
|
||
|
||
var pc = MakePC("i2_gc_pc", 1e12, 1e12);
|
||
var boss = MakeBeater("i2_gc_boss", eSubRol.Boss);
|
||
var pc0 = MyValue.MyPC; MyValue.MyPC = pc;
|
||
var apply = ApplyToPc(pc);
|
||
var dinfo = Dmg(boss, 10d);
|
||
try
|
||
{
|
||
Survival.ResetDiagnostics();
|
||
Survival.Tick(0f);
|
||
// 예열
|
||
for (int i = 0; i < 1000; i++) { dinfo.Damage = 10d; Survival.TakeDamage(pc, dinfo, apply); }
|
||
for (int i = 0; i < 1000; i++) Survival.IsHitInvincible(pc);
|
||
for (int i = 0; i < 1000; i++) RunGuide.DodgeDecision(cfg, true, true, true, 99f);
|
||
|
||
GC.Collect(); long m0 = GC.GetTotalMemory(true);
|
||
for (int i = 0; i < 200000; i++) { dinfo.Damage = 10d; Survival.TakeDamage(pc, dinfo, apply); }
|
||
long m1 = GC.GetTotalMemory(false);
|
||
for (int i = 0; i < 200000; i++) Survival.IsHitInvincible(pc);
|
||
long m2 = GC.GetTotalMemory(false);
|
||
for (int i = 0; i < 200000; i++) RunGuide.DodgeDecision(cfg, true, true, true, 99f);
|
||
long m3 = GC.GetTotalMemory(false);
|
||
|
||
bool h1 = m1 - m0 == 0;
|
||
bool h2 = m2 - m1 == 0;
|
||
bool h3 = m3 - m2 == 0;
|
||
sb.AppendLine(P(h1) + " TakeDamage(무적 창 경로 포함) ×200,000 = " + (m1 - m0) + " byte"); if (!h1) f++;
|
||
sb.AppendLine(P(h2) + " IsHitInvincible ×200,000 = " + (m2 - m1) + " byte"); if (!h2) f++;
|
||
sb.AppendLine(P(h3) + " DodgeDecision ×200,000 = " + (m3 - m2) + " byte"); if (!h3) f++;
|
||
|
||
// 대조군 — 의도적 할당이 잡히는지(계측 자체의 신뢰성)
|
||
long m4 = GC.GetTotalMemory(false);
|
||
var junk = new byte[65536];
|
||
junk[0] = 1;
|
||
long m5 = GC.GetTotalMemory(false);
|
||
bool h4 = m5 - m4 > 0;
|
||
sb.AppendLine(P(h4) + " 대조군(64 KB 의도 할당) = " + (m5 - m4) + " byte(> 0 이어야 계측이 유효하다)"); if (!h4) f++;
|
||
}
|
||
finally { MyValue.MyPC = pc0; Kill(pc, boss); }
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓘ C8
|
||
static int C8(StringBuilder sb)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓘ C8 롤백");
|
||
var st = UseClone(); if (st == null) return f + 1;
|
||
st.enabled = true; WLSurvivalSettings.RuntimeOverride = 1;
|
||
st.takeBossDamage = true; st.bossDamageMultiplier = 0.1f;
|
||
st.unscaledDamageGuardEnabled = false;
|
||
|
||
var pc = MakePC("i2_c8_pc", PcMaxHp, PcMaxHp);
|
||
var boss = MakeBeater("i2_c8_boss", eSubRol.Boss);
|
||
var pc0 = MyValue.MyPC; MyValue.MyPC = pc;
|
||
try
|
||
{
|
||
// ① bossHitInvincibleSeconds = 0 → 813i 동작 100 %(5연타 5타 전부)
|
||
st.hitInvincibleEnabled = true; st.bossHitInvincibleSeconds = 0f;
|
||
Survival.ResetDiagnostics();
|
||
int landed = 0;
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
Survival.Tick(i * ComboInterval);
|
||
double before = pc.Get_HP();
|
||
Survival.TakeDamage(pc, Dmg(boss, BossRawDamage), ApplyToPc(pc));
|
||
if (before - pc.Get_HP() > 1e-6) landed++;
|
||
}
|
||
bool i1 = landed == 5 && Survival.HitInvincibleOpened == 0 && Survival.BlockedHitInvincible == 0;
|
||
sb.AppendLine(P(i1) + " bossHitInvincibleSeconds=0 → 5연타 " + landed + "타 전부 피격 · 창 0 = 813i 동작"); if (!i1) f++;
|
||
|
||
// ② hitInvincibleEnabled = 0 → 같은 결과
|
||
st.bossHitInvincibleSeconds = 0.6f; st.hitInvincibleEnabled = false;
|
||
var pcB = MakePC("i2_c8_pcB", PcMaxHp, PcMaxHp);
|
||
MyValue.MyPC = pcB;
|
||
Survival.ResetDiagnostics();
|
||
int landedB = 0;
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
Survival.Tick(i * ComboInterval);
|
||
double before = pcB.Get_HP();
|
||
Survival.TakeDamage(pcB, Dmg(boss, BossRawDamage), ApplyToPc(pcB));
|
||
if (before - pcB.Get_HP() > 1e-6) landedB++;
|
||
}
|
||
bool i2 = landedB == 5 && Survival.HitInvincibleOpened == 0;
|
||
sb.AppendLine(P(i2) + " hitInvincibleEnabled=0 → " + landedB + "타 전부 피격 · 창 0"); if (!i2) f++;
|
||
Kill(pcB);
|
||
|
||
// ③ 전체 스위치 off → 원본 100 %(배율조차 없다)
|
||
WLSurvivalSettings.RuntimeOverride = -1;
|
||
var pcC = MakePC("i2_c8_pcC", PcMaxHp, PcMaxHp);
|
||
MyValue.MyPC = pcC;
|
||
Survival.ResetDiagnostics();
|
||
Survival.Tick(0f);
|
||
double h0 = pcC.Get_HP();
|
||
Survival.TakeDamage(pcC, Dmg(boss, 100d), ApplyAlways(pcC)); // SO off = 훅 무동작 → base 그대로 통과했는지만 본다
|
||
bool i3 = Math.Abs(h0 - pcC.Get_HP() - 100d) < 1e-6 && Survival.PassDisabled == 1
|
||
&& Survival.HitInvincibleOpened == 0;
|
||
sb.AppendLine(P(i3) + " SO off → 배율·창 전부 무동작(원 피해 100 그대로 · PassDisabled="
|
||
+ Survival.PassDisabled + ")"); if (!i3) f++;
|
||
Kill(pcC);
|
||
WLSurvivalSettings.RuntimeOverride = 1;
|
||
|
||
// ④ dodgeStepEnabled = 0 → 판정 자체가 kDodgeOff
|
||
var cfg = UseRgClone(); if (cfg == null) return f + 1;
|
||
cfg.dodgeStepEnabled = false;
|
||
int d = RunGuide.DodgeDecision(cfg, true, true, true, 99f);
|
||
RunGuide.ResetDodgeStateForProbe();
|
||
bool i4 = d == RunGuide.kDodgeOff && !RunGuide.ForceDodgeTick(2000f, 0.016f) && RunGuide.DodgeSteps == 0;
|
||
sb.AppendLine(P(i4) + " dodgeStepEnabled=0 → 판정 " + Name(d) + " · 스텝 " + RunGuide.DodgeSteps); if (!i4) f++;
|
||
cfg.dodgeStepEnabled = true;
|
||
}
|
||
finally { MyValue.MyPC = pc0; Kill(pc, boss); }
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── ⓙ 정리
|
||
static int Cleanup(StringBuilder sb, bool dirty0)
|
||
{
|
||
int f = 0;
|
||
sb.AppendLine(); sb.AppendLine("## ⓙ 정리");
|
||
int leftovers = 0;
|
||
var all = UnityEngine.Object.FindObjectsByType<GameObject>(FindObjectsInactive.Include, FindObjectsSortMode.None);
|
||
for (int i = 0; i < all.Length; i++)
|
||
if (all[i] != null && all[i].name.StartsWith("__WL813i2")) leftovers++;
|
||
|
||
var st = WLSurvivalSettings.Instance;
|
||
bool assetBack = st != null && Math.Abs(st.bossHitInvincibleSeconds - 0.6f) < 1e-4
|
||
&& Math.Abs(st.autoPotionHpRatio - 0.55f) < 1e-4 && st.hitInvincibleEnabled;
|
||
var cfg = WLRunGuideSettings.Instance;
|
||
bool cfgBack = cfg != null && cfg.dodgeStepEnabled && Math.Abs(cfg.dodgeStepDistance - 3f) < 1e-4;
|
||
bool dirty = UnityEngine.SceneManagement.SceneManager.GetActiveScene().isDirty;
|
||
|
||
bool ok = leftovers == 0 && assetBack && cfgBack && MyValue.MyPC == null && dirty == dirty0
|
||
&& WLSurvivalSettings.RuntimeOverride == 0 && !WLRunGuideSettings.RuntimeDisabled;
|
||
sb.AppendLine(P(ok) + " 임시 오브젝트 " + leftovers + " · 에셋 원복(Survival " + assetBack + " · RunGuide " + cfgBack
|
||
+ ") · MyPC=null " + (MyValue.MyPC == null) + " · 씬 dirty " + dirty + "(시작 " + dirty0 + ")"
|
||
+ " · Override " + WLSurvivalSettings.RuntimeOverride);
|
||
if (!ok) f++;
|
||
return f;
|
||
}
|
||
|
||
// ───────────────────────────────── 유틸
|
||
static string P(bool ok) { return ok ? "[PASS]" : "[FAIL]"; }
|
||
|
||
static WLSurvivalSettings UseClone()
|
||
{
|
||
var orig = WLSurvivalSettings.Instance;
|
||
if (orig == null) return null;
|
||
if (s_clone == null)
|
||
{
|
||
s_clone = UnityEngine.Object.Instantiate(orig);
|
||
s_clone.hideFlags = HideFlags.HideAndDontSave; s_clone.name = "WLSurvivalSettings(probe clone)";
|
||
}
|
||
typeof(WLSurvivalSettings).GetField("s_cached", NS).SetValue(null, s_clone);
|
||
typeof(WLSurvivalSettings).GetField("s_lookupDone", NS).SetValue(null, true);
|
||
return s_clone;
|
||
}
|
||
|
||
static WLRunGuideSettings UseRgClone()
|
||
{
|
||
var orig = WLRunGuideSettings.Instance;
|
||
if (orig == null) return null;
|
||
if (s_rgClone == null)
|
||
{
|
||
s_rgClone = UnityEngine.Object.Instantiate(orig);
|
||
s_rgClone.hideFlags = HideFlags.HideAndDontSave; s_rgClone.name = "WLRunGuideSettings(probe clone)";
|
||
}
|
||
typeof(WLRunGuideSettings).GetField("s_cached", NS).SetValue(null, s_rgClone);
|
||
typeof(WLRunGuideSettings).GetField("s_lookupDone", NS).SetValue(null, true);
|
||
return s_rgClone;
|
||
}
|
||
|
||
static void RestoreAssets()
|
||
{
|
||
WLSurvivalSettings.ClearCache(); WLSurvivalSettings.RuntimeOverride = 0;
|
||
WLRunGuideSettings.ClearCache(); WLRunGuideSettings.RuntimeDisabled = false;
|
||
RunGuide.ResetDodgeStateForProbe();
|
||
RunGuide.ResetDiagnostics();
|
||
if (s_clone != null) { UnityEngine.Object.DestroyImmediate(s_clone); s_clone = null; }
|
||
if (s_rgClone != null) { UnityEngine.Object.DestroyImmediate(s_rgClone); s_rgClone = null; }
|
||
}
|
||
|
||
static PCActor MakePC(string name, double maxHp, double hp)
|
||
{
|
||
var go = new GameObject("__WL813i2_" + name);
|
||
var pc = go.AddComponent<PCActor>();
|
||
pc.m_Role = eRole.PC; pc.m_SubRole = eSubRol.None;
|
||
var stat = new ActorStatInfo(eRole.PC);
|
||
stat.Set_Stat(eStat.MaxHP, maxHp); stat.Set_Stat(eStat.HP, hp);
|
||
typeof(Actor).GetField("m_Stat", NP).SetValue(pc, stat);
|
||
typeof(Actor).GetField("m_Enemy", NP).SetValue(pc, false);
|
||
return pc;
|
||
}
|
||
|
||
static Actor MakeBeater(string name, eSubRol sub)
|
||
{
|
||
var go = new GameObject("__WL813i2_" + name);
|
||
var a = go.AddComponent<Actor>();
|
||
a.m_Role = eRole.Mob; a.m_SubRole = sub;
|
||
typeof(Actor).GetField("m_Enemy", NP).SetValue(a, true);
|
||
return a;
|
||
}
|
||
|
||
static DamageInfo Dmg(Actor beater, double dmg)
|
||
{
|
||
var d = new DamageInfo();
|
||
d.Beater = beater; d.Damage = dmg;
|
||
return d;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 가짜 base.Get_Damage = **원본 MyActor.Get_Damage(:301-309) 그대로**.
|
||
/// `wlInvincible = IsRole(PC) && WLGameplaySettings.PlayerInvincible` 이면 base 를 건너뛰고(피해 0)
|
||
/// 아니면 넘어온(배율 적용된) 피해만큼 PC HP 를 깎는다.
|
||
/// 🔴 이 재현이 없으면 무적 창 경로를 검증할 수 없다 — 훅은 「플래그를 세운 채 base 를 부르는」 방식이라
|
||
/// base 를 모사한 쪽이 그 플래그를 안 보면 무적이 무적이 아니게 된다(1차 프로브에서 실제로 잡혔다).
|
||
/// </summary>
|
||
static Action<DamageInfo> ApplyToPc(PCActor pc)
|
||
{
|
||
return d =>
|
||
{
|
||
if (WL.Settings.WLGameplaySettings.PlayerInvincible) return; // 원본 무적 경로 = 피해 0
|
||
if (d != null) pc.Get_StatInfo().Set_Stat(false, eStat.HP, d.Damage);
|
||
};
|
||
}
|
||
|
||
/// <summary>플래그를 보지 않고 무조건 깎는다(플래그 자체를 검증하지 않는 절에서만 쓴다).</summary>
|
||
static Action<DamageInfo> ApplyAlways(PCActor pc)
|
||
{
|
||
return d => { if (d != null) pc.Get_StatInfo().Set_Stat(false, eStat.HP, d.Damage); };
|
||
}
|
||
|
||
/// <summary>가짜 base.Get_Damage — 원본 무적 경로(피해 0).</summary>
|
||
static Action<DamageInfo> NoDamage() { return d => { }; }
|
||
|
||
static void Kill(params UnityEngine.Object[] objs)
|
||
{
|
||
foreach (var o in objs)
|
||
{
|
||
if (o == null) continue;
|
||
var c = o as Component;
|
||
UnityEngine.Object.DestroyImmediate(c != null ? c.gameObject : o);
|
||
}
|
||
}
|
||
|
||
static void Write(string body)
|
||
{
|
||
try
|
||
{
|
||
string root = Path.GetDirectoryName(Application.dataPath);
|
||
string dir = Path.Combine(root, OutDir);
|
||
Directory.CreateDirectory(dir);
|
||
File.WriteAllText(Path.Combine(dir, "probe_" + DateTime.Now.ToString("HHmmss") + ".txt"), body);
|
||
File.WriteAllText(Path.Combine(root, OutCommit), body);
|
||
}
|
||
catch (Exception ex) { Debug.Log("[WL813i2] probe 파일 기록 실패: " + ex.Message); }
|
||
}
|
||
}
|