3048 lines
105 KiB
C#
3048 lines
105 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using NeoModLoader.services;
|
|
using UnityEngine;
|
|
|
|
namespace IdleSpectator;
|
|
|
|
/// <summary>
|
|
/// Agent-driven in-game command bus. Drop JSON lines into <c>.harness/commands.jsonl</c>
|
|
/// (or a scenario via <c>{"action":"scenario","value":"smoke"}</c>). Results go to
|
|
/// <c>.harness/results.jsonl</c> and <c>.harness/last-result.json</c>.
|
|
/// </summary>
|
|
public static class AgentHarness
|
|
{
|
|
private static long _offset;
|
|
private static float _waitUntil = -1f;
|
|
private static bool _readyLogged;
|
|
private static int _assertPass;
|
|
private static int _assertFail;
|
|
private static int _cmdOk;
|
|
private static int _cmdFail;
|
|
private static string _lastBatchId = "";
|
|
private static readonly Queue<HarnessCommand> Queue = new Queue<HarnessCommand>();
|
|
private static Actor _lastSpawned;
|
|
private static string _lastSpawnedAssetId = "";
|
|
private static bool _directorRunActive;
|
|
private static string _rememberedFocusKey = "";
|
|
private static string LastScreenshotPath = "";
|
|
private static readonly string[] PreferredSpawnAssets =
|
|
{
|
|
"sheep", "cow", "pig", "chicken", "dog", "cat", "rabbit", "monkey", "fox", "crab"
|
|
};
|
|
|
|
[Serializable]
|
|
private class LastResult
|
|
{
|
|
public string batch_id = "";
|
|
public string status = "";
|
|
public int ok;
|
|
public int fail;
|
|
public int assert_pass;
|
|
public int assert_fail;
|
|
public string idle = "";
|
|
public string focus = "";
|
|
public string power_bar = "";
|
|
public string unit = "";
|
|
public string tip = "";
|
|
public string detail = "";
|
|
public string updated_at = "";
|
|
}
|
|
|
|
public static bool Busy => Queue.Count > 0 || _waitUntil > 0f;
|
|
|
|
/// <summary>
|
|
/// When true, InterestDirector / SpeciesDiscovery stay frozen during harness commands.
|
|
/// <c>director_run</c> temporarily clears this so dwell/interrupt/discovery can execute.
|
|
/// </summary>
|
|
public static bool FreezeDirector => Busy && !_directorRunActive;
|
|
|
|
public static void Update()
|
|
{
|
|
EnsureDirs();
|
|
CheckExternalReset();
|
|
IngestNewCommands();
|
|
|
|
// Welcome Back / other ScrollWindows block world start until closed.
|
|
if (ShouldAutoDismissUi())
|
|
{
|
|
TryDismissBlockingWindows();
|
|
}
|
|
|
|
if (_waitUntil > 0f)
|
|
{
|
|
if (Time.unscaledTime < _waitUntil)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_waitUntil = -1f;
|
|
_directorRunActive = false;
|
|
}
|
|
|
|
if (Queue.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
HarnessCommand cmd = Queue.Dequeue();
|
|
try
|
|
{
|
|
Execute(cmd);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "exception: " + ex.Message);
|
|
WriteLastResult("error", "exception: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static void Execute(HarnessCommand cmd)
|
|
{
|
|
string action = (cmd.action ?? "").Trim().ToLowerInvariant();
|
|
if (string.IsNullOrEmpty(action))
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "missing action");
|
|
return;
|
|
}
|
|
|
|
switch (action)
|
|
{
|
|
case "wait_world":
|
|
TryDismissBlockingWindows();
|
|
if (!WorldReady() || IsBlockingWindowOpen() || !HasAnyAliveUnit())
|
|
{
|
|
RequeueFront(cmd);
|
|
_waitUntil = Time.unscaledTime + 0.35f;
|
|
if (!_readyLogged)
|
|
{
|
|
_readyLogged = true;
|
|
LogService.LogInfo("[IdleSpectator][HARNESS] waiting for world load (will auto-close Welcome Back)");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: "world_ready");
|
|
break;
|
|
|
|
case "dismiss_windows":
|
|
case "dismiss_ui":
|
|
{
|
|
bool closed = TryDismissBlockingWindows(forceAll: ParseBool(cmd.value, defaultValue: false));
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: closed ? "dismissed" : "none_open");
|
|
break;
|
|
}
|
|
|
|
case "wait":
|
|
{
|
|
float seconds = cmd.wait > 0f ? cmd.wait : ParseFloat(cmd.value, 1f);
|
|
_directorRunActive = false;
|
|
_waitUntil = Time.unscaledTime + Mathf.Max(0.05f, seconds);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"wait={seconds:0.##}s");
|
|
break;
|
|
}
|
|
|
|
case "director_run":
|
|
{
|
|
float seconds = cmd.wait > 0f ? cmd.wait : ParseFloat(cmd.value, 1f);
|
|
seconds = Mathf.Max(0.1f, seconds);
|
|
_directorRunActive = true;
|
|
_waitUntil = Time.unscaledTime + seconds;
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"director_run={seconds:0.##}s");
|
|
break;
|
|
}
|
|
|
|
case "fast_timing":
|
|
{
|
|
bool on = ParseBool(cmd.value, defaultValue: true);
|
|
InterestDirector.SetHarnessFastTiming(on);
|
|
SpeciesDiscovery.SetHarnessFastTiming(on);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"fast_timing={on}");
|
|
break;
|
|
}
|
|
|
|
case "age_current":
|
|
{
|
|
float seconds = cmd.wait > 0f ? cmd.wait : ParseFloat(cmd.value, 2f);
|
|
InterestDirector.HarnessAgeCurrent(seconds);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"aged={seconds:0.##}s tier={InterestDirector.CurrentTierName}");
|
|
break;
|
|
}
|
|
|
|
case "expire_grace":
|
|
{
|
|
InterestDirector.HarnessExpireInputGrace();
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"in_grace={InterestDirector.InInputGrace}");
|
|
break;
|
|
}
|
|
|
|
case "remember_focus":
|
|
{
|
|
_rememberedFocusKey = FocusKey();
|
|
bool ok = !string.IsNullOrEmpty(_rememberedFocusKey) && _rememberedFocusKey != "-";
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail: $"focus={_rememberedFocusKey}");
|
|
break;
|
|
}
|
|
|
|
case "spectator":
|
|
{
|
|
bool on = ParseBool(cmd.value, defaultValue: true);
|
|
string expect = (cmd.expect ?? "").Trim().ToLowerInvariant();
|
|
SpectatorMode.SetActive(on);
|
|
bool ok;
|
|
string detail;
|
|
if (expect == "blocked")
|
|
{
|
|
ok = on && !SpectatorMode.Active;
|
|
detail = $"blocked idle={SpectatorMode.Active} enabled={ModSettings.Enabled}";
|
|
}
|
|
else
|
|
{
|
|
ok = SpectatorMode.Active == on;
|
|
detail = $"idle={SpectatorMode.Active}";
|
|
}
|
|
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail);
|
|
break;
|
|
}
|
|
|
|
case "simulate_input":
|
|
{
|
|
string mode = (cmd.value ?? "drag").Trim().ToLowerInvariant();
|
|
string expect = (cmd.expect ?? "").Trim().ToLowerInvariant();
|
|
bool honorGrace = expect == "grace" || expect == "blocked" || mode == "grace";
|
|
// Only camera-drag is reliably injectable without OS input.
|
|
bool exited = InterestDirector.SimulateManualInputExit(honorGrace: honorGrace);
|
|
bool ok;
|
|
string detail;
|
|
if (honorGrace)
|
|
{
|
|
ok = !exited && SpectatorMode.Active;
|
|
detail = $"grace_hold idle={SpectatorMode.Active} in_grace={InterestDirector.InInputGrace}";
|
|
}
|
|
else
|
|
{
|
|
ok = exited && !SpectatorMode.Active;
|
|
detail = $"exited idle={SpectatorMode.Active}";
|
|
}
|
|
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail);
|
|
break;
|
|
}
|
|
|
|
case "discovery_reset":
|
|
{
|
|
SpeciesDiscovery.HarnessResetTracking();
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: "discovery_tracking_cleared");
|
|
break;
|
|
}
|
|
|
|
case "discovery_note":
|
|
DoDiscoveryNote(cmd);
|
|
break;
|
|
|
|
case "discovery_mark":
|
|
case "discovery_mark_presented":
|
|
{
|
|
string assetId = ResolveAssetId(cmd);
|
|
SpeciesDiscovery.MarkPresented(assetId);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"presented={assetId} pending={SpeciesDiscovery.PendingCount}");
|
|
break;
|
|
}
|
|
|
|
case "discovery_drain":
|
|
{
|
|
bool drained = SpeciesDiscovery.HarnessForceDrainOnce();
|
|
if (drained)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, drained, detail:
|
|
$"drained={drained} pending={SpeciesDiscovery.PendingCount} session={SpeciesDiscovery.DrainedThisSession}");
|
|
break;
|
|
}
|
|
|
|
case "watch_ghost":
|
|
DoWatchGhost(cmd);
|
|
break;
|
|
|
|
case "chronicle_force":
|
|
case "chronicle_note":
|
|
{
|
|
int n = Math.Max(1, cmd.count);
|
|
string baseLabel = string.IsNullOrEmpty(cmd.label) ? "Killed" : cmd.label;
|
|
int okN = 0;
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
string label = n > 1 ? $"{baseLabel} #{i + 1}" : baseLabel;
|
|
if (Chronicle.ForceNoteCurrentFocus(label))
|
|
{
|
|
okN++;
|
|
}
|
|
}
|
|
|
|
bool ok = okN == n;
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail:
|
|
$"forced={okN}/{n} history={Chronicle.HistoryCountFor(Chronicle.CurrentHistorySubjectId())} caption={WatchCaption.LastHeadline}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_clear":
|
|
{
|
|
Chronicle.ClearSession();
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: "chronicle_cleared");
|
|
break;
|
|
}
|
|
|
|
case "activity_probe":
|
|
{
|
|
Actor focus = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
string probe = ActivityInterestTable.DumpFocusProbe(focus);
|
|
long id = 0;
|
|
try
|
|
{
|
|
if (focus != null)
|
|
{
|
|
id = focus.getID();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
id = 0;
|
|
}
|
|
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"{probe} activity_count={ActivityLog.CountFor(id)}");
|
|
break;
|
|
}
|
|
|
|
case "activity_force":
|
|
{
|
|
long id = WatchCaption.CurrentUnitId;
|
|
if (id == 0 && MoveCamera.hasFocusUnit() && MoveCamera._focus_unit != null)
|
|
{
|
|
try
|
|
{
|
|
id = MoveCamera._focus_unit.getID();
|
|
}
|
|
catch
|
|
{
|
|
id = 0;
|
|
}
|
|
}
|
|
|
|
string key = !string.IsNullOrEmpty(cmd.asset)
|
|
? cmd.asset
|
|
: (!string.IsNullOrEmpty(cmd.value) ? cmd.value : "farm");
|
|
string line = !string.IsNullOrEmpty(cmd.label) ? cmd.label : key;
|
|
bool asBeat = (cmd.tier ?? "").IndexOf("beat", System.StringComparison.OrdinalIgnoreCase) >= 0;
|
|
int n = Math.Max(1, cmd.count);
|
|
int okN = 0;
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
string one = n > 1 ? $"{line} #{i + 1}" : line;
|
|
if (ActivityLog.ForceNote(id, key, one, asBeat))
|
|
{
|
|
okN++;
|
|
}
|
|
}
|
|
|
|
WatchCaption.ForceRefreshHistory();
|
|
bool ok = okN == n && id != 0;
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail:
|
|
$"forced={okN}/{n} id={id} count={ActivityLog.CountFor(id)} shown={WatchCaption.LastActivityShown}");
|
|
break;
|
|
}
|
|
|
|
case "activity_clear":
|
|
{
|
|
ActivityLog.ClearSession();
|
|
WatchCaption.ForceRefreshHistory();
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: "activity_cleared");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_world_force":
|
|
{
|
|
string label = !string.IsNullOrEmpty(cmd.label)
|
|
? cmd.label
|
|
: (!string.IsNullOrEmpty(cmd.value) ? cmd.value : "War: harness vs test");
|
|
bool ok = Chronicle.ForceWorldNote(label);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail: $"world_count={Chronicle.WorldCount} label={label}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_death_sample":
|
|
{
|
|
string typeName = !string.IsNullOrEmpty(cmd.value) ? cmd.value : "Age";
|
|
bool ok = Chronicle.ForceDeathSample(typeName);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
ChronicleEntry latest = Chronicle.Latest;
|
|
Emit(cmd, ok, detail: $"type={typeName} latest={(latest != null ? latest.Line : "")}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_tab":
|
|
case "lore_tab":
|
|
case "world_memory_open":
|
|
{
|
|
Chronicle.ShowHud();
|
|
string tabRaw = (cmd.value ?? cmd.label ?? "world").Trim().ToLowerInvariant();
|
|
if (tabRaw == "fallen" || tabRaw == "dead")
|
|
{
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.Fallen);
|
|
}
|
|
else if (tabRaw == "living"
|
|
|| tabRaw == "characters"
|
|
|| tabRaw == "character"
|
|
|| tabRaw == "chars"
|
|
|| tabRaw == "history")
|
|
{
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.Living);
|
|
}
|
|
else
|
|
{
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.World);
|
|
}
|
|
|
|
bool open = Chronicle.HudVisible;
|
|
if (open)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, open,
|
|
detail: $"hud={open} tab={ChronicleHud.ActiveTab} memory={Chronicle.MemoryCount} recent={Chronicle.RecentFocusCount}");
|
|
break;
|
|
}
|
|
|
|
case "lore_refresh":
|
|
case "chronicle_refresh":
|
|
{
|
|
ChronicleHud.RefreshCastList();
|
|
_cmdOk++;
|
|
Emit(
|
|
cmd,
|
|
ok: true,
|
|
detail:
|
|
$"stale={ChronicleHud.CastListStale} top='{ChronicleHud.LastListTopTitle}' tab={ChronicleHud.ActiveTab}");
|
|
break;
|
|
}
|
|
|
|
case "lore_search":
|
|
{
|
|
Chronicle.ShowHud();
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.Living);
|
|
ChronicleHud.SetSearch(cmd.value ?? cmd.label ?? "");
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"search='{ChronicleHud.SearchText}'");
|
|
break;
|
|
}
|
|
|
|
case "lore_favorites":
|
|
{
|
|
Chronicle.ShowHud();
|
|
string v = (cmd.value ?? "true").Trim().ToLowerInvariant();
|
|
bool on = v != "false" && v != "0" && v != "off";
|
|
ChronicleHud.SetFavoritesOnly(on);
|
|
// Filter is a list view - leave detail if we were in one.
|
|
if (ChronicleHud.DetailUnitId != 0)
|
|
{
|
|
ChronicleHud.ClearUnitDetail();
|
|
}
|
|
|
|
_cmdOk++;
|
|
Emit(
|
|
cmd,
|
|
ok: true,
|
|
detail: $"favoritesOnly={ChronicleHud.FavoritesOnly} tab={ChronicleHud.ActiveTab}");
|
|
break;
|
|
}
|
|
|
|
case "lore_pick":
|
|
{
|
|
Chronicle.ShowHud();
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.Living);
|
|
string needle = cmd.value ?? cmd.label ?? "";
|
|
if (needle == "auto")
|
|
{
|
|
needle = "";
|
|
}
|
|
|
|
bool ok = ChronicleHud.PickFirstCharacter(needle);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok,
|
|
detail: $"picked={ok} focus={MoveCamera.hasFocusUnit()} dossier={WatchCaption.LastHeadline} recent={Chronicle.RecentFocusCount}");
|
|
break;
|
|
}
|
|
|
|
case "lore_open_focus":
|
|
case "chronicle_open_focus":
|
|
{
|
|
ChronicleHud.OpenSyncedFromFocus();
|
|
bool open = Chronicle.HudVisible;
|
|
if (open)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, open,
|
|
detail:
|
|
$"lore={Chronicle.HudVisible} detail={ChronicleHud.DetailUnitId} dossierId={WatchCaption.CurrentUnitId} idle={SpectatorMode.Active} follow={ChronicleHud.FollowFocus}");
|
|
break;
|
|
}
|
|
|
|
case "lore_pick_fallen":
|
|
{
|
|
Chronicle.ShowHud();
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.Fallen);
|
|
string needle = cmd.value ?? cmd.label ?? "";
|
|
if (needle == "auto")
|
|
{
|
|
needle = "";
|
|
}
|
|
|
|
bool ok = ChronicleHud.PickFirstFallen(needle);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok,
|
|
detail:
|
|
$"picked={ok} detail={ChronicleHud.DetailUnitId} follow={ChronicleHud.FollowFocus} hist={Chronicle.HistoryCountFor(ChronicleHud.DetailUnitId)} fallenFocus={Chronicle.LastFallenFocusDetail} manner={Chronicle.LatestDeathMannerFor(ChronicleHud.DetailUnitId)}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_orphan":
|
|
{
|
|
int n = Math.Max(1, cmd.count);
|
|
string name = !string.IsNullOrEmpty(cmd.label) ? cmd.label : "Orphan";
|
|
string species = !string.IsNullOrEmpty(cmd.asset) ? cmd.asset : "creature";
|
|
string prefix = !string.IsNullOrEmpty(cmd.value) ? cmd.value : "Fallen";
|
|
AttackType attackType = AttackType.Age;
|
|
if (!string.IsNullOrEmpty(cmd.expect)
|
|
&& System.Enum.TryParse(cmd.expect, ignoreCase: true, out AttackType parsedAttack))
|
|
{
|
|
attackType = parsedAttack;
|
|
}
|
|
|
|
long killerId = 0;
|
|
Vector3 deathPos = Vector3.zero;
|
|
string mode = (cmd.tier ?? "").Trim().ToLowerInvariant();
|
|
bool favorite = mode.IndexOf("fav", System.StringComparison.Ordinal) >= 0;
|
|
Actor focus = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
if (mode.IndexOf("killer", System.StringComparison.Ordinal) >= 0
|
|
&& focus != null
|
|
&& focus.isAlive())
|
|
{
|
|
killerId = focus.getID();
|
|
deathPos = focus.current_position;
|
|
}
|
|
else if (mode.IndexOf("place", System.StringComparison.Ordinal) >= 0
|
|
|| favorite
|
|
|| string.IsNullOrEmpty(mode))
|
|
{
|
|
if (mode.IndexOf("place", System.StringComparison.Ordinal) >= 0 || favorite)
|
|
{
|
|
if (focus != null)
|
|
{
|
|
deathPos = focus.current_position;
|
|
}
|
|
else if (MoveCamera.instance != null)
|
|
{
|
|
deathPos = MoveCamera.instance.transform.position;
|
|
deathPos.z = 0f;
|
|
}
|
|
|
|
if (deathPos == Vector3.zero)
|
|
{
|
|
deathPos = new Vector3(48f, 48f, 0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
long id = Chronicle.ForceOrphanHistory(
|
|
name, species, n, prefix, attackType, killerId, deathPos, favorite);
|
|
DeathManner manner = Chronicle.LatestDeathMannerFor(id);
|
|
bool ok = id != 0
|
|
&& Chronicle.HistoryCountFor(id) >= n
|
|
&& (!favorite || Chronicle.IsFavoriteSubject(id));
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(
|
|
cmd,
|
|
ok,
|
|
detail:
|
|
$"orphanId={id} hist={Chronicle.HistoryCountFor(id)} want={n} manner={manner} killer={killerId} mode={mode} fav={Chronicle.IsFavoriteSubject(id)}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_orphan_flood":
|
|
{
|
|
// Stress subject-cap pruning (does not need living units).
|
|
int n = Math.Max(1, cmd.count);
|
|
int made = 0;
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
long id = Chronicle.ForceOrphanHistory(
|
|
"Flood" + i,
|
|
"human",
|
|
1,
|
|
"Flood",
|
|
AttackType.Age);
|
|
if (id != 0)
|
|
{
|
|
made++;
|
|
}
|
|
}
|
|
|
|
bool ok = made == n
|
|
&& Chronicle.HistorySubjectCount <= Chronicle.MaxHistorySubjects;
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(
|
|
cmd,
|
|
ok,
|
|
detail:
|
|
$"made={made}/{n} subjects={Chronicle.HistorySubjectCount} max={Chronicle.MaxHistorySubjects} dossiers={Chronicle.FinalDossierCount}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_set_subject_cap":
|
|
{
|
|
int cap = Math.Max(40, cmd.count);
|
|
if (!string.IsNullOrEmpty(cmd.value)
|
|
&& int.TryParse(cmd.value.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out int parsed))
|
|
{
|
|
cap = parsed;
|
|
}
|
|
|
|
Chronicle.SetMaxHistorySubjects(cap);
|
|
bool ok = Chronicle.MaxHistorySubjects == Mathf.Clamp(cap, 40, Chronicle.AbsoluteMaxHistorySubjects)
|
|
&& Chronicle.HistorySubjectCount <= Chronicle.MaxHistorySubjects;
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(
|
|
cmd,
|
|
ok,
|
|
detail:
|
|
$"cap={Chronicle.MaxHistorySubjects} subjects={Chronicle.HistorySubjectCount}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_subject_bench":
|
|
{
|
|
// value: comma-separated sizes, e.g. "320,640,1280,2560"
|
|
// count: events per subject (default 3). expect: max avg fallen ms budget (default 2).
|
|
string sizesRaw = string.IsNullOrEmpty(cmd.value)
|
|
? "320,640,1280,2560,4096,8192"
|
|
: cmd.value;
|
|
int eventsPer = Math.Max(1, cmd.count);
|
|
if (eventsPer == 1 && string.IsNullOrEmpty(cmd.label))
|
|
{
|
|
eventsPer = 3;
|
|
}
|
|
|
|
float budgetMs = 2f;
|
|
if (!string.IsNullOrEmpty(cmd.expect)
|
|
&& float.TryParse(cmd.expect, NumberStyles.Float, CultureInfo.InvariantCulture, out float parsedBudget))
|
|
{
|
|
budgetMs = parsedBudget;
|
|
}
|
|
|
|
string[] parts = sizesRaw.Split(',');
|
|
var reports = new List<string>();
|
|
int best = 0;
|
|
float bestAvg = -1f;
|
|
bool any = false;
|
|
for (int i = 0; i < parts.Length; i++)
|
|
{
|
|
string p = parts[i].Trim();
|
|
if (!int.TryParse(p, NumberStyles.Integer, CultureInfo.InvariantCulture, out int size)
|
|
|| size < 40)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string report = Chronicle.BenchSubjectLoad(size, eventsPer, iters: 25);
|
|
reports.Add(report);
|
|
any = true;
|
|
|
|
float avg = float.MaxValue;
|
|
const string needle = "fallenAvgMs=";
|
|
int idx = report.IndexOf(needle, StringComparison.Ordinal);
|
|
if (idx >= 0)
|
|
{
|
|
int start = idx + needle.Length;
|
|
int end = start;
|
|
while (end < report.Length
|
|
&& (char.IsDigit(report[end]) || report[end] == '.'))
|
|
{
|
|
end++;
|
|
}
|
|
|
|
float.TryParse(
|
|
report.Substring(start, end - start),
|
|
NumberStyles.Float,
|
|
CultureInfo.InvariantCulture,
|
|
out avg);
|
|
}
|
|
|
|
// Highest size that stays within the ms budget.
|
|
if (avg <= budgetMs && size > best)
|
|
{
|
|
best = size;
|
|
bestAvg = avg;
|
|
}
|
|
}
|
|
|
|
if (best <= 0)
|
|
{
|
|
best = Chronicle.DefaultMaxHistorySubjects;
|
|
bestAvg = budgetMs;
|
|
}
|
|
|
|
Chronicle.SetMaxHistorySubjects(best);
|
|
Chronicle.ClearSession();
|
|
bool ok = any && reports.Count > 0;
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
string joined = string.Join(" || ", reports);
|
|
Emit(
|
|
cmd,
|
|
ok,
|
|
detail:
|
|
$"budgetMs={budgetMs:0.00} recommend={best} recommendAvgMs={bestAvg:0.00} capNow={Chronicle.MaxHistorySubjects} | {joined}");
|
|
break;
|
|
}
|
|
|
|
case "lore_close":
|
|
case "chronicle_close":
|
|
{
|
|
Chronicle.HideHud();
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"lore={Chronicle.HudVisible}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_open":
|
|
{
|
|
Chronicle.ShowHud();
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.World);
|
|
bool open = Chronicle.HudVisible;
|
|
if (open)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, open, detail: $"hud={open} memory={Chronicle.MemoryCount} age={Chronicle.CurrentAgeName}");
|
|
break;
|
|
}
|
|
|
|
case "dossier_favorite":
|
|
{
|
|
Actor target = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
string v = (cmd.value ?? "").Trim().ToLowerInvariant();
|
|
if (v == "true" || v == "1" || v == "on" || v == "false" || v == "0" || v == "off")
|
|
{
|
|
bool want = v == "true" || v == "1" || v == "on";
|
|
bool ok = false;
|
|
try
|
|
{
|
|
if (target != null && target.isAlive())
|
|
{
|
|
if (target.isFavorite() != want)
|
|
{
|
|
target.switchFavorite();
|
|
}
|
|
|
|
ok = target.isFavorite() == want;
|
|
WatchCaption.SetFromActor(target);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
ok = false;
|
|
}
|
|
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail: $"favorite={want} set");
|
|
break;
|
|
}
|
|
|
|
WatchCaption.ToggleFavorite();
|
|
bool fav = false;
|
|
try
|
|
{
|
|
fav = target != null && target.isFavorite();
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"favorite={fav}");
|
|
break;
|
|
}
|
|
|
|
case "dossier_expand":
|
|
case "dossier_history_open":
|
|
{
|
|
WatchCaption.OpenFullHistoryInLore();
|
|
bool open = Chronicle.HudVisible && ChronicleHud.DetailUnitId != 0;
|
|
if (open)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, open,
|
|
detail: $"lore={Chronicle.HudVisible} detail={ChronicleHud.DetailUnitId} idle={SpectatorMode.Active} shown={WatchCaption.LastHistoryShown}");
|
|
break;
|
|
}
|
|
|
|
case "lore_back":
|
|
{
|
|
ChronicleHud.ClearUnitDetail();
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"detail={ChronicleHud.DetailUnitId} tab={ChronicleHud.ActiveTab}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_jump":
|
|
{
|
|
bool ok = Chronicle.JumpToLatest();
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(
|
|
cmd,
|
|
ok,
|
|
detail:
|
|
$"jumped={ok} detail={Chronicle.LastJumpDetail} focus={MoveCamera.hasFocusUnit()} pos={Chronicle.LastJumpPosition}");
|
|
break;
|
|
}
|
|
|
|
case "lore_jump_world":
|
|
{
|
|
Chronicle.ShowHud();
|
|
ChronicleHud.SetTab(ChronicleHud.LoreTab.World);
|
|
ChronicleEntry target = null;
|
|
IReadOnlyList<ChronicleEntry> snap = Chronicle.SnapshotMemory();
|
|
for (int i = snap.Count - 1; i >= 0; i--)
|
|
{
|
|
ChronicleEntry e = snap[i];
|
|
if (e == null || e.Kind == ChronicleKind.AgeChapter)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (e.Kind == ChronicleKind.World || e.IsLegend)
|
|
{
|
|
target = e;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool ok = target != null && Chronicle.JumpTo(target);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(
|
|
cmd,
|
|
ok,
|
|
detail:
|
|
$"jumped={ok} detail={Chronicle.LastJumpDetail} focus={MoveCamera.hasFocusUnit()} line={(target != null ? target.Line : "")}");
|
|
break;
|
|
}
|
|
|
|
case "screenshot":
|
|
{
|
|
bool ok = CaptureHarnessScreenshot(cmd.value);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail: $"path={LastScreenshotPath} layoutOk={WatchCaption.LastLayoutOk} size={WatchCaption.LastPanelSize}");
|
|
break;
|
|
}
|
|
|
|
case "spawn":
|
|
DoSpawn(cmd);
|
|
break;
|
|
|
|
case "pick_unit":
|
|
DoPickUnit(cmd);
|
|
break;
|
|
|
|
case "focus":
|
|
DoFocus(cmd);
|
|
break;
|
|
|
|
case "watch":
|
|
DoWatch(cmd);
|
|
break;
|
|
|
|
case "trigger_interest":
|
|
DoTriggerInterest(cmd);
|
|
break;
|
|
|
|
case "set_setting":
|
|
DoSetSetting(cmd);
|
|
break;
|
|
|
|
case "assert":
|
|
DoAssert(cmd);
|
|
break;
|
|
|
|
case "snapshot":
|
|
DoSnapshot(cmd);
|
|
break;
|
|
|
|
case "scenario":
|
|
ExpandScenario(cmd);
|
|
return;
|
|
|
|
case "reset_counters":
|
|
{
|
|
StateProbe.ResetCounters();
|
|
string mode = (cmd.value ?? cmd.expect ?? "").Trim().ToLowerInvariant();
|
|
if (mode == "all" || mode == "harness")
|
|
{
|
|
_assertPass = 0;
|
|
_assertFail = 0;
|
|
_cmdOk = 0;
|
|
_cmdFail = 0;
|
|
}
|
|
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: mode == "all" || mode == "harness" ? "counters_reset_all" : "stateprobe_reset");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "unknown action: " + action);
|
|
break;
|
|
}
|
|
|
|
if (Queue.Count == 0)
|
|
{
|
|
string status = _assertFail == 0 && _cmdFail == 0 ? "PASS" : "FAIL";
|
|
WriteLastResult(status, $"ok={_cmdOk} fail={_cmdFail} assert_pass={_assertPass} assert_fail={_assertFail}");
|
|
LogService.LogInfo(
|
|
$"[IdleSpectator][HARNESS] batch done status={status} ok={_cmdOk} fail={_cmdFail} assert_pass={_assertPass} assert_fail={_assertFail}");
|
|
}
|
|
}
|
|
|
|
private static void ExpandScenario(HarnessCommand cmd)
|
|
{
|
|
string name = (cmd.value ?? "").Trim().ToLowerInvariant();
|
|
List<HarnessCommand> steps = HarnessScenarios.Build(name);
|
|
if (steps == null || steps.Count == 0)
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "unknown scenario: " + name);
|
|
WriteLastResult("FAIL", "unknown scenario: " + name);
|
|
return;
|
|
}
|
|
|
|
_lastBatchId = string.IsNullOrEmpty(cmd.id) ? name : cmd.id;
|
|
bool keepStats = (cmd.expect ?? "").Trim().Equals("keep", System.StringComparison.OrdinalIgnoreCase);
|
|
if (!keepStats)
|
|
{
|
|
_assertPass = 0;
|
|
_assertFail = 0;
|
|
_cmdOk = 0;
|
|
_cmdFail = 0;
|
|
StateProbe.ResetCounters();
|
|
}
|
|
|
|
// Re-queue scenario steps ahead of anything else already queued.
|
|
List<HarnessCommand> rest = new List<HarnessCommand>(Queue);
|
|
Queue.Clear();
|
|
foreach (HarnessCommand step in steps)
|
|
{
|
|
Queue.Enqueue(step);
|
|
}
|
|
|
|
foreach (HarnessCommand step in rest)
|
|
{
|
|
Queue.Enqueue(step);
|
|
}
|
|
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"expanded={name} steps={steps.Count}");
|
|
LogService.LogInfo($"[IdleSpectator][HARNESS] scenario={name} steps={steps.Count}");
|
|
}
|
|
|
|
private static void DoPickUnit(HarnessCommand cmd)
|
|
{
|
|
if (!WorldReady())
|
|
{
|
|
if (RetryFront(cmd, "world_not_ready"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "world_not_ready");
|
|
return;
|
|
}
|
|
|
|
string assetId = string.IsNullOrEmpty(cmd.asset) || cmd.asset == "auto" ? null : cmd.asset;
|
|
Actor unit = ResolveUnit(assetId);
|
|
if (unit == null || !unit.isAlive())
|
|
{
|
|
// Ignore stale harness spawn handle; scan the live world.
|
|
_lastSpawned = null;
|
|
unit = string.IsNullOrEmpty(assetId)
|
|
? WorldActivityScanner.FindNearestAliveUnit(CameraPos(), 5000f)
|
|
: WorldActivityScanner.FindAliveByAssetId(assetId, CameraPos(), 5000f);
|
|
}
|
|
|
|
if (unit == null || !unit.isAlive())
|
|
{
|
|
if (RetryFront(cmd, "no_unit"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "no living unit in world");
|
|
return;
|
|
}
|
|
|
|
_lastSpawned = unit;
|
|
_lastSpawnedAssetId = unit.asset != null ? unit.asset.id : "";
|
|
CameraDirector.FocusUnit(unit);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"picked={SafeName(unit)} asset={_lastSpawnedAssetId}");
|
|
}
|
|
|
|
private static void DoSpawn(HarnessCommand cmd)
|
|
{
|
|
if (!WorldReady())
|
|
{
|
|
if (RetryFront(cmd, "world_not_ready"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "world_not_ready");
|
|
return;
|
|
}
|
|
|
|
string assetId = string.IsNullOrEmpty(cmd.asset) ? cmd.value : cmd.asset;
|
|
if (string.IsNullOrEmpty(assetId) || assetId == "auto")
|
|
{
|
|
assetId = PickSpawnAssetId();
|
|
if (string.IsNullOrEmpty(assetId))
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "no spawnable asset");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (AssetManager.actor_library?.get(assetId) == null)
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "unknown asset: " + assetId);
|
|
return;
|
|
}
|
|
|
|
WorldTile tile = TileNearCamera();
|
|
// Prefer spawning next to an existing living unit so terrain is valid.
|
|
Actor anchor = WorldActivityScanner.FindNearestAliveUnit(CameraPos(), 5000f);
|
|
if (anchor != null)
|
|
{
|
|
WorldTile anchorTile = World.world.GetTile(
|
|
Mathf.RoundToInt(anchor.current_position.x),
|
|
Mathf.RoundToInt(anchor.current_position.y));
|
|
if (anchorTile != null)
|
|
{
|
|
tile = anchorTile;
|
|
}
|
|
}
|
|
|
|
if (tile == null)
|
|
{
|
|
if (RetryFront(cmd, "no_tile"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "no tile near camera");
|
|
return;
|
|
}
|
|
|
|
int count = Math.Max(1, cmd.count);
|
|
int spawned = 0;
|
|
Actor last = null;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
Actor actor = World.world.units.spawnNewUnit(assetId, tile, pSpawnSound: false, pMiracleSpawn: true);
|
|
if (actor != null && actor.isAlive())
|
|
{
|
|
spawned++;
|
|
last = actor;
|
|
}
|
|
}
|
|
|
|
if (spawned <= 0 || last == null || !last.isAlive())
|
|
{
|
|
if (RetryFront(cmd, "spawn_zero"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: $"spawned=0/{count} asset={assetId}");
|
|
return;
|
|
}
|
|
|
|
_lastSpawned = last;
|
|
_lastSpawnedAssetId = last.asset != null ? last.asset.id : assetId;
|
|
CameraDirector.FocusUnit(last);
|
|
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"spawned={spawned}/{count} asset={_lastSpawnedAssetId} last={SafeName(last)}");
|
|
}
|
|
|
|
private static void DoFocus(HarnessCommand cmd)
|
|
{
|
|
if (!WorldReady())
|
|
{
|
|
if (RetryFront(cmd, "world_not_ready"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "world_not_ready");
|
|
return;
|
|
}
|
|
|
|
string assetId = string.IsNullOrEmpty(cmd.asset) ? cmd.value : cmd.asset;
|
|
if (assetId == "nearest" || assetId == "auto")
|
|
{
|
|
assetId = assetId == "auto" ? _lastSpawnedAssetId : null;
|
|
}
|
|
|
|
Actor unit = ResolveUnit(assetId);
|
|
if (unit == null || !unit.isAlive())
|
|
{
|
|
if (RetryFront(cmd, "no_unit"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "no unit to focus");
|
|
return;
|
|
}
|
|
|
|
CameraDirector.FocusUnit(unit);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"unit={SafeName(unit)} asset={(unit.asset != null ? unit.asset.id : "?")}");
|
|
}
|
|
|
|
private static void DoWatch(HarnessCommand cmd)
|
|
{
|
|
if (!WorldReady())
|
|
{
|
|
if (RetryFront(cmd, "world_not_ready"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "world_not_ready");
|
|
return;
|
|
}
|
|
|
|
string assetId = cmd.asset;
|
|
if (assetId == "auto")
|
|
{
|
|
assetId = _lastSpawnedAssetId;
|
|
}
|
|
|
|
Actor follow = ResolveUnit(string.IsNullOrEmpty(assetId) ? null : assetId);
|
|
if (follow == null)
|
|
{
|
|
if (RetryFront(cmd, string.IsNullOrEmpty(assetId) ? "no_unit" : "no_asset_unit"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: string.IsNullOrEmpty(assetId) ? "no unit for watch" : "no unit for asset: " + assetId);
|
|
return;
|
|
}
|
|
|
|
InterestTier tier = ParseTier(cmd.tier, InterestTier.Curiosity);
|
|
string resolvedAsset = follow.asset != null ? follow.asset.id : assetId;
|
|
string label = string.IsNullOrEmpty(cmd.label)
|
|
? $"Harness: {resolvedAsset}"
|
|
: cmd.label.Replace("{asset}", resolvedAsset ?? "");
|
|
if (label.Contains("{asset}"))
|
|
{
|
|
label = label.Replace("{asset}", resolvedAsset ?? "");
|
|
}
|
|
|
|
InterestEvent interest = new InterestEvent
|
|
{
|
|
Tier = tier,
|
|
Score = 50f,
|
|
Position = follow.current_position,
|
|
FollowUnit = follow,
|
|
Label = label,
|
|
CreatedAt = Time.unscaledTime,
|
|
AssetId = follow.asset != null ? follow.asset.id : assetId
|
|
};
|
|
|
|
CameraDirector.Watch(interest);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"tip={label} unit={SafeName(follow)}");
|
|
}
|
|
|
|
private static void DoTriggerInterest(HarnessCommand cmd)
|
|
{
|
|
if (!WorldReady())
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "world_not_ready");
|
|
return;
|
|
}
|
|
|
|
string assetId = cmd.asset;
|
|
Actor follow = null;
|
|
if (!string.IsNullOrEmpty(assetId))
|
|
{
|
|
follow = WorldActivityScanner.FindNearestAliveUnit(CameraPos(), 200f, assetId);
|
|
}
|
|
|
|
if (follow == null)
|
|
{
|
|
follow = WorldActivityScanner.FindNearestAliveUnit(CameraPos(), 200f);
|
|
}
|
|
|
|
if (follow == null)
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "no unit for interest");
|
|
return;
|
|
}
|
|
|
|
InterestEvent interest = new InterestEvent
|
|
{
|
|
Tier = ParseTier(cmd.tier, InterestTier.Curiosity),
|
|
Score = 40f,
|
|
Position = follow.current_position,
|
|
FollowUnit = follow,
|
|
Label = string.IsNullOrEmpty(cmd.label)
|
|
? $"Harness {ParseTier(cmd.tier, InterestTier.Curiosity)}"
|
|
: cmd.label.Replace("{asset}", follow.asset != null ? follow.asset.id : (assetId ?? "")),
|
|
CreatedAt = Time.unscaledTime,
|
|
AssetId = follow.asset != null ? follow.asset.id : assetId
|
|
};
|
|
|
|
InterestCollector.EnqueueDirect(interest);
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: $"queued tier={interest.Tier} label={interest.Label} pending={InterestCollector.PendingCount}");
|
|
}
|
|
|
|
private static void DoSetSetting(HarnessCommand cmd)
|
|
{
|
|
string key = cmd.expect;
|
|
if (string.IsNullOrEmpty(key))
|
|
{
|
|
key = cmd.asset;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(key))
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "missing setting key (expect/asset)");
|
|
return;
|
|
}
|
|
|
|
bool val = ParseBool(cmd.value, defaultValue: true);
|
|
bool ok = ModSettings.TrySetBool(key, val);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail: $"{key}={val}");
|
|
}
|
|
|
|
private static void DoAssert(HarnessCommand cmd)
|
|
{
|
|
string expect = (cmd.expect ?? "").Trim().ToLowerInvariant();
|
|
if (string.IsNullOrEmpty(expect))
|
|
{
|
|
expect = (cmd.value ?? "").Trim().ToLowerInvariant();
|
|
}
|
|
|
|
bool pass;
|
|
string detail;
|
|
|
|
switch (expect)
|
|
{
|
|
case "idle":
|
|
case "spectator":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
// When expect is the whole assert name and value holds bool:
|
|
if (expect == "idle" || expect == "spectator")
|
|
{
|
|
want = ParseBool(string.IsNullOrEmpty(cmd.value) ? "true" : cmd.value, true);
|
|
}
|
|
|
|
pass = SpectatorMode.Active == want;
|
|
detail = $"idle={SpectatorMode.Active} want={want}";
|
|
break;
|
|
}
|
|
case "focus":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
bool has = MoveCamera.hasFocusUnit();
|
|
pass = has == want;
|
|
detail = $"focus={has} want={want}";
|
|
break;
|
|
}
|
|
case "power_bar":
|
|
case "bar":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: false);
|
|
bool bar = CanvasMain.isBottomBarShowing();
|
|
pass = bar == want;
|
|
detail = $"powerBar={bar} want={want}";
|
|
break;
|
|
}
|
|
case "health":
|
|
{
|
|
bool idle = SpectatorMode.Active;
|
|
bool focus = MoveCamera.hasFocusUnit();
|
|
bool bar = CanvasMain.isBottomBarShowing();
|
|
pass = idle && focus && !bar && StateProbe.BadEventCount == 0;
|
|
detail =
|
|
$"idle={idle} focus={focus} powerBar={bar} bad={StateProbe.BadEventCount}";
|
|
break;
|
|
}
|
|
case "tip_matches_unit":
|
|
{
|
|
string tipAsset = CameraDirector.LastWatchAssetId ?? "";
|
|
Actor unit = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
string unitAsset = unit?.asset != null ? unit.asset.id : "";
|
|
string tip = CameraDirector.LastWatchLabel ?? "";
|
|
bool assetsMatch = !string.IsNullOrEmpty(tipAsset)
|
|
&& tipAsset == unitAsset
|
|
&& MoveCamera.hasFocusUnit();
|
|
// If the tip claims a species, the focused unit must be that species.
|
|
bool labelOk = true;
|
|
const string prefix = "New species: ";
|
|
if (tip.StartsWith(prefix))
|
|
{
|
|
string claimed = tip.Substring(prefix.Length).Trim();
|
|
labelOk = !string.IsNullOrEmpty(claimed) && claimed == unitAsset;
|
|
}
|
|
|
|
pass = assetsMatch && labelOk;
|
|
detail =
|
|
$"tipAsset={tipAsset} unitAsset={unitAsset} tip={tip}";
|
|
break;
|
|
}
|
|
case "unit_asset":
|
|
{
|
|
string wantAsset = string.IsNullOrEmpty(cmd.asset) ? cmd.value : cmd.asset;
|
|
if (wantAsset == "auto" || string.IsNullOrEmpty(wantAsset))
|
|
{
|
|
wantAsset = _lastSpawnedAssetId;
|
|
}
|
|
|
|
Actor unit = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
string unitAsset = unit?.asset != null ? unit.asset.id : "";
|
|
pass = !string.IsNullOrEmpty(wantAsset) && wantAsset == unitAsset;
|
|
detail = $"unitAsset={unitAsset} want={wantAsset}";
|
|
break;
|
|
}
|
|
case "no_bad":
|
|
{
|
|
pass = StateProbe.BadEventCount == 0;
|
|
detail = $"bad={StateProbe.BadEventCount}";
|
|
break;
|
|
}
|
|
case "tip_contains":
|
|
{
|
|
string needle = string.IsNullOrEmpty(cmd.value) ? cmd.label : cmd.value;
|
|
if (needle == "auto" || needle.Contains("{asset}"))
|
|
{
|
|
needle = (needle == "auto" ? "New species: {asset}" : needle)
|
|
.Replace("{asset}", _lastSpawnedAssetId ?? "");
|
|
}
|
|
|
|
string tip = CameraDirector.LastWatchLabel ?? "";
|
|
pass = !string.IsNullOrEmpty(needle)
|
|
&& tip.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0;
|
|
detail = $"tip='{tip}' contains='{needle}'";
|
|
break;
|
|
}
|
|
case "enabled":
|
|
case "setting_enabled":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
pass = ModSettings.Enabled == want;
|
|
detail = $"enabled={ModSettings.Enabled} want={want}";
|
|
break;
|
|
}
|
|
case "show_watch_reasons":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
pass = ModSettings.ShowWatchReasons == want;
|
|
detail = $"show_watch_reasons={ModSettings.ShowWatchReasons} want={want}";
|
|
break;
|
|
}
|
|
case "current_tier":
|
|
{
|
|
string want = (cmd.value ?? cmd.tier ?? "").Trim();
|
|
string have = InterestDirector.CurrentTierName;
|
|
pass = !string.IsNullOrEmpty(want)
|
|
&& string.Equals(have, want, System.StringComparison.OrdinalIgnoreCase);
|
|
detail = $"tier={have} want={want} label={InterestDirector.CurrentLabel}";
|
|
break;
|
|
}
|
|
case "would_accept_curiosity":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
bool have = InterestDirector.WouldAcceptCuriosity();
|
|
pass = have == want;
|
|
detail = $"would_accept={have} want={want} tier={InterestDirector.CurrentTierName}";
|
|
break;
|
|
}
|
|
case "focus_same":
|
|
case "focus_unchanged":
|
|
{
|
|
string nowKey = FocusKey();
|
|
pass = !string.IsNullOrEmpty(_rememberedFocusKey)
|
|
&& _rememberedFocusKey != "-"
|
|
&& nowKey == _rememberedFocusKey;
|
|
detail = $"remembered={_rememberedFocusKey} now={nowKey}";
|
|
break;
|
|
}
|
|
case "focus_arrows":
|
|
case "relationship_arrows":
|
|
{
|
|
bool pinned = FocusRelationshipArrows.IsPinnedToFocus();
|
|
pass = SpectatorMode.Active && MoveCamera.hasFocusUnit() && pinned;
|
|
detail =
|
|
$"idle={SpectatorMode.Active} focus={MoveCamera.hasFocusUnit()} pinned={pinned} lastActor={(UnitSelectionEffect.last_actor != null ? SafeName(UnitSelectionEffect.last_actor) : "null")} dest={PlayerConfig.optionBoolEnabled("cursor_arrow_destination")} lover={PlayerConfig.optionBoolEnabled("cursor_arrow_lover")} attack={PlayerConfig.optionBoolEnabled("cursor_arrow_attack_target")}";
|
|
break;
|
|
}
|
|
case "presented":
|
|
{
|
|
string assetId = ResolveAssetId(cmd);
|
|
bool want = string.IsNullOrEmpty(cmd.value) || ParseBool(cmd.value, true);
|
|
bool have = SpeciesDiscovery.WasPresented(assetId);
|
|
pass = have == want;
|
|
detail = $"asset={assetId} presented={have} want={want}";
|
|
break;
|
|
}
|
|
case "pending_discovery":
|
|
case "discovery_pending":
|
|
{
|
|
int want = ParseCountExpect(cmd, defaultValue: 0);
|
|
int have = SpeciesDiscovery.PendingCount;
|
|
pass = have == want;
|
|
detail = $"pending={have} want={want}";
|
|
break;
|
|
}
|
|
case "pending_interest":
|
|
{
|
|
int want = ParseCountExpect(cmd, defaultValue: 0);
|
|
int have = InterestCollector.PendingCount;
|
|
pass = have == want;
|
|
detail = $"interest_pending={have} want={want}";
|
|
break;
|
|
}
|
|
case "in_grace":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
bool have = InterestDirector.InInputGrace;
|
|
pass = have == want;
|
|
detail = $"in_grace={have} want={want}";
|
|
break;
|
|
}
|
|
case "dossier_contains":
|
|
case "caption_contains":
|
|
{
|
|
string needle = string.IsNullOrEmpty(cmd.value) ? cmd.label : cmd.value;
|
|
if (needle == "auto" || string.IsNullOrEmpty(needle))
|
|
{
|
|
needle = _lastSpawnedAssetId;
|
|
}
|
|
|
|
string caption = WatchCaption.LastCaptionText ?? "";
|
|
UnitDossier dossier = WatchCaption.Current;
|
|
bool dossierHit = dossier != null && dossier.ContainsIgnoreCase(needle);
|
|
bool captionHit = !string.IsNullOrEmpty(needle)
|
|
&& caption.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0;
|
|
pass = dossierHit || captionHit;
|
|
detail = $"needle='{needle}' caption='{caption.Replace("\n", " | ")}' dossier={(dossier != null)}";
|
|
break;
|
|
}
|
|
case "chronicle_count":
|
|
{
|
|
int want = ParseCountExpect(cmd, defaultValue: 1);
|
|
int have = Chronicle.HistoryCountFor(Chronicle.CurrentHistorySubjectId());
|
|
string cmp = (cmd.label ?? "").Trim().ToLowerInvariant();
|
|
if (cmp == "min" || cmp == ">=" || string.IsNullOrEmpty(cmp))
|
|
{
|
|
pass = have >= want;
|
|
detail = $"history_count={have} min={want}";
|
|
}
|
|
else if (cmp == "world")
|
|
{
|
|
have = Chronicle.WorldCount;
|
|
pass = have >= want;
|
|
detail = $"world_count={have} min={want}";
|
|
}
|
|
else
|
|
{
|
|
pass = have == want;
|
|
detail = $"history_count={have} want={want}";
|
|
}
|
|
|
|
break;
|
|
}
|
|
case "chronicle_latest_contains":
|
|
{
|
|
string needle = string.IsNullOrEmpty(cmd.value) ? cmd.label : cmd.value;
|
|
if (needle == "auto")
|
|
{
|
|
needle = _lastSpawnedAssetId;
|
|
}
|
|
|
|
ChronicleEntry latest = Chronicle.Latest;
|
|
string line = latest != null ? latest.Line : "";
|
|
string display = latest != null ? latest.DisplayLine : "";
|
|
pass = latest != null
|
|
&& !string.IsNullOrEmpty(needle)
|
|
&& line.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0;
|
|
detail = $"latest='{display}' needle='{needle}' date='{(latest != null ? latest.DateLabel : "")}'";
|
|
break;
|
|
}
|
|
case "chronicle_latest_dated":
|
|
{
|
|
ChronicleEntry latest = Chronicle.Latest;
|
|
pass = latest != null
|
|
&& !string.IsNullOrEmpty(latest.DateLabel)
|
|
&& latest.WorldTime > 0;
|
|
detail =
|
|
$"date='{(latest != null ? latest.DateLabel : "")}' worldTime={(latest != null ? latest.WorldTime.ToString("0.###") : "0")} line='{(latest != null ? latest.Line : "")}'";
|
|
break;
|
|
}
|
|
case "caption_layout_ok":
|
|
{
|
|
float maxH = 220f;
|
|
pass = WatchCaption.LastLayoutOk
|
|
&& WatchCaption.LastPanelSize.y > 20f
|
|
&& WatchCaption.LastPanelSize.y < maxH
|
|
&& WatchCaption.LastPanelSize.x <= 440f
|
|
&& (WatchCaption.LastHistoryShown <= 0 || WatchCaption.LastHistoryFillsBody)
|
|
&& WatchCaption.LastHistoryShown <= 3;
|
|
detail =
|
|
$"layoutOk={WatchCaption.LastLayoutOk} size={WatchCaption.LastPanelSize} histFill={WatchCaption.LastHistoryFillsBody} shown={WatchCaption.LastHistoryShown} caption='{(WatchCaption.LastCaptionText ?? "").Replace("\n", " | ")}' hist='{(WatchCaption.LastHistoryPreview ?? "").Replace("\n", " ")}'";
|
|
break;
|
|
}
|
|
case "dossier_traits_ok":
|
|
{
|
|
UnitDossier dossier = WatchCaption.Current;
|
|
string preview = WatchCaption.LastTraitsPreview ?? "";
|
|
int count = dossier != null ? dossier.TopTraits.Count : 0;
|
|
bool noEllipsis = preview.IndexOf("...", System.StringComparison.Ordinal) < 0;
|
|
bool bounded = count >= 0 && count <= 3;
|
|
bool labelsMatch = true;
|
|
if (dossier != null)
|
|
{
|
|
for (int i = 0; i < dossier.TopTraits.Count; i++)
|
|
{
|
|
string name = dossier.TopTraits[i].Name ?? "";
|
|
if (name.IndexOf("...", System.StringComparison.Ordinal) >= 0)
|
|
{
|
|
labelsMatch = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pass = bounded && noEllipsis && labelsMatch;
|
|
detail = $"traits={count} preview='{preview}' layoutOk={WatchCaption.LastLayoutOk} size={WatchCaption.LastPanelSize}";
|
|
break;
|
|
}
|
|
case "dossier_history_contains":
|
|
{
|
|
string needle = string.IsNullOrEmpty(cmd.value) ? cmd.label : cmd.value;
|
|
string hist = WatchCaption.LastHistoryJoined ?? "";
|
|
if (string.IsNullOrEmpty(hist))
|
|
{
|
|
hist = WatchCaption.LastHistoryPreview ?? "";
|
|
}
|
|
|
|
pass = !string.IsNullOrEmpty(needle)
|
|
&& hist.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0;
|
|
detail = $"hist='{hist}' needle='{needle}' act={WatchCaption.LastActivityShown} life={WatchCaption.LastLifeShown}";
|
|
break;
|
|
}
|
|
case "activity_count":
|
|
{
|
|
long id = WatchCaption.CurrentUnitId;
|
|
int want = ParseCountExpect(cmd, defaultValue: 1);
|
|
int have = ActivityLog.CountFor(id);
|
|
string cmp = (cmd.label ?? "min").Trim().ToLowerInvariant();
|
|
pass = cmp == "exact" || cmp == "==" ? have == want : have >= want;
|
|
detail = $"activity_count={have} want={want} id={id} shown={WatchCaption.LastActivityShown}";
|
|
break;
|
|
}
|
|
case "activity_prose_variety":
|
|
{
|
|
long id = WatchCaption.CurrentUnitId;
|
|
IReadOnlyList<ActivityEntry> entries = ActivityLog.LatestForSubject(id, 12);
|
|
var distinct = new HashSet<string>(StringComparer.Ordinal);
|
|
for (int i = 0; i < entries.Count; i++)
|
|
{
|
|
if (entries[i] != null && !string.IsNullOrEmpty(entries[i].DisplayLine))
|
|
{
|
|
distinct.Add(entries[i].DisplayLine);
|
|
}
|
|
}
|
|
|
|
int want = ParseCountExpect(cmd, defaultValue: 2);
|
|
pass = distinct.Count >= want;
|
|
detail = $"distinct={distinct.Count} want={want} total={entries.Count}";
|
|
break;
|
|
}
|
|
case "activity_first_scoring":
|
|
{
|
|
pass = WorldActivityScanner.HarnessActivityFirstScoringOk(out string scoreDetail);
|
|
detail = scoreDetail;
|
|
break;
|
|
}
|
|
case "activity_band_cold_focus":
|
|
{
|
|
Actor focus = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
ActivityBand band = ActivityInterestTable.Classify(focus);
|
|
bool cold = WorldActivityScanner.IsFocusActivityCold(focus);
|
|
string want = (cmd.value ?? "cold").Trim().ToLowerInvariant();
|
|
pass = want == "cold" ? cold : !cold;
|
|
detail = $"band={band} cold={cold} want={want} probe={ActivityInterestTable.DumpFocusProbe(focus)}";
|
|
break;
|
|
}
|
|
case "chronicle_world_latest_contains":
|
|
case "world_memory_contains":
|
|
{
|
|
string needle = string.IsNullOrEmpty(cmd.value) ? cmd.label : cmd.value;
|
|
ChronicleEntry latest = Chronicle.LatestWorld;
|
|
string line = latest != null ? latest.Line : "";
|
|
string lore = latest != null ? latest.HudLine : "";
|
|
string display = latest != null ? latest.DisplayLine : "";
|
|
pass = latest != null
|
|
&& latest.Kind != ChronicleKind.AgeChapter
|
|
&& !string.IsNullOrEmpty(needle)
|
|
&& (line.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0
|
|
|| lore.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0);
|
|
detail = $"world_latest='{display}' needle='{needle}' age='{Chronicle.CurrentAgeName}'";
|
|
break;
|
|
}
|
|
case "world_memory_age":
|
|
{
|
|
pass = !string.IsNullOrEmpty(Chronicle.CurrentAgeId)
|
|
|| Chronicle.MemoryCount > 0;
|
|
detail = $"ageId='{Chronicle.CurrentAgeId}' ageName='{Chronicle.CurrentAgeName}' memory={Chronicle.MemoryCount}";
|
|
break;
|
|
}
|
|
case "world_memory_world_only":
|
|
{
|
|
// World tab must not mix in character Kill/Death/Lover rows.
|
|
IReadOnlyList<ChronicleEntry> snap = Chronicle.SnapshotMemory();
|
|
int bad = 0;
|
|
int worldRows = 0;
|
|
for (int i = 0; i < snap.Count; i++)
|
|
{
|
|
ChronicleEntry e = snap[i];
|
|
if (e == null || e.Kind == ChronicleKind.AgeChapter)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (e.Kind == ChronicleKind.World)
|
|
{
|
|
worldRows++;
|
|
continue;
|
|
}
|
|
|
|
bad++;
|
|
}
|
|
|
|
pass = bad == 0;
|
|
detail = $"badKinds={bad} worldRows={worldRows} memory={snap.Count}";
|
|
break;
|
|
}
|
|
case "chronicle_subjects_capped":
|
|
{
|
|
int subjects = Chronicle.HistorySubjectCount;
|
|
int dossiers = Chronicle.FinalDossierCount;
|
|
pass = subjects <= Chronicle.MaxHistorySubjects
|
|
&& dossiers <= Chronicle.MaxHistorySubjects;
|
|
detail =
|
|
$"subjects={subjects} dossiers={dossiers} max={Chronicle.MaxHistorySubjects} revision={Chronicle.HistoryRevision}";
|
|
break;
|
|
}
|
|
case "chronicle_memory_capped":
|
|
{
|
|
int memory = Chronicle.MemoryCount;
|
|
pass = memory <= Chronicle.MaxLandmarks;
|
|
detail = $"memory={memory} max={Chronicle.MaxLandmarks}";
|
|
break;
|
|
}
|
|
case "dossier_favorite":
|
|
case "is_favorite":
|
|
{
|
|
Actor unit = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
bool fav = false;
|
|
try
|
|
{
|
|
fav = unit != null && unit.isAlive() && unit.isFavorite();
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
if (!fav)
|
|
{
|
|
long id = WatchCaption.CurrentUnitId;
|
|
if (id == 0)
|
|
{
|
|
id = ChronicleHud.DetailUnitId;
|
|
}
|
|
|
|
if (id == 0 && unit != null)
|
|
{
|
|
try
|
|
{
|
|
id = unit.getID();
|
|
}
|
|
catch
|
|
{
|
|
id = 0;
|
|
}
|
|
}
|
|
|
|
fav = Chronicle.IsFavoriteSubject(id);
|
|
}
|
|
|
|
string wantRaw = (cmd.value ?? "true").Trim().ToLowerInvariant();
|
|
bool want = wantRaw != "false" && wantRaw != "0" && wantRaw != "off";
|
|
pass = fav == want;
|
|
detail = $"favorite={fav} want={want}";
|
|
break;
|
|
}
|
|
case "dossier_history_shown":
|
|
{
|
|
int want = ParseCountExpect(cmd, defaultValue: 1);
|
|
string scope = (cmd.tier ?? "").Trim().ToLowerInvariant();
|
|
int have = scope == "life"
|
|
? WatchCaption.LastLifeShown
|
|
: scope == "activity"
|
|
? WatchCaption.LastActivityShown
|
|
: WatchCaption.LastHistoryShown;
|
|
string cmp = (cmd.label ?? "min").Trim().ToLowerInvariant();
|
|
if (cmp == "exact" || cmp == "==")
|
|
{
|
|
pass = have == want;
|
|
}
|
|
else
|
|
{
|
|
pass = have >= want;
|
|
}
|
|
|
|
detail =
|
|
$"shown={have} want={want} scope={scope} total={WatchCaption.LastHistoryShown} act={WatchCaption.LastActivityShown} life={WatchCaption.LastLifeShown} scrollable={WatchCaption.LastHistoryScrollable} histFill={WatchCaption.LastHistoryFillsBody}";
|
|
break;
|
|
}
|
|
case "dossier_history_scrollable":
|
|
{
|
|
// Dossier history is no longer scrollable; full history lives in Lore.
|
|
pass = !WatchCaption.LastHistoryScrollable && WatchCaption.LastHistoryShown <= 3;
|
|
detail =
|
|
$"scrollable={WatchCaption.LastHistoryScrollable} shown={WatchCaption.LastHistoryShown}";
|
|
break;
|
|
}
|
|
case "lore_detail":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
bool have = ChronicleHud.DetailUnitId != 0;
|
|
pass = Chronicle.HudVisible && have == want;
|
|
detail =
|
|
$"detailId={ChronicleHud.DetailUnitId} want={want} tab={ChronicleHud.ActiveTab} follow={ChronicleHud.FollowFocus}";
|
|
break;
|
|
}
|
|
case "lore_follow":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
bool have = ChronicleHud.FollowFocus;
|
|
pass = Chronicle.HudVisible && ChronicleHud.DetailUnitId != 0 && have == want;
|
|
detail =
|
|
$"follow={have} want={want} detailId={ChronicleHud.DetailUnitId}";
|
|
break;
|
|
}
|
|
case "fallen_focus":
|
|
{
|
|
string want = (cmd.value ?? "").Trim().ToLowerInvariant();
|
|
string have = (Chronicle.LastFallenFocusDetail ?? "").Trim().ToLowerInvariant();
|
|
if (want == "killer" || want.StartsWith("killer"))
|
|
{
|
|
pass = have.StartsWith("killer:");
|
|
}
|
|
else if (want == "place")
|
|
{
|
|
pass = have == "place";
|
|
}
|
|
else if (want == "none")
|
|
{
|
|
pass = have == "none" || string.IsNullOrEmpty(have);
|
|
}
|
|
else
|
|
{
|
|
pass = have == want;
|
|
}
|
|
|
|
detail = $"fallenFocus={Chronicle.LastFallenFocusDetail} want={cmd.value}";
|
|
break;
|
|
}
|
|
case "death_manner":
|
|
{
|
|
long id = ChronicleHud.DetailUnitId;
|
|
DeathManner have = Chronicle.LatestDeathMannerFor(id);
|
|
string haveLabel = Chronicle.DeathMannerLabel(have);
|
|
string want = (cmd.value ?? "").Trim().ToLowerInvariant();
|
|
pass = id != 0
|
|
&& (haveLabel == want
|
|
|| have.ToString().Equals(want, System.StringComparison.OrdinalIgnoreCase));
|
|
detail = $"manner={have} label={haveLabel} want={cmd.value} detailId={id}";
|
|
break;
|
|
}
|
|
case "lore_follows_focus":
|
|
{
|
|
long focusId = WatchCaption.CurrentUnitId;
|
|
if (focusId == 0)
|
|
{
|
|
focusId = Chronicle.CurrentHistorySubjectId();
|
|
}
|
|
|
|
long loreId = ChronicleHud.DetailUnitId;
|
|
pass = Chronicle.HudVisible
|
|
&& ChronicleHud.FollowFocus
|
|
&& SpectatorMode.Active
|
|
&& focusId != 0
|
|
&& loreId == focusId;
|
|
detail =
|
|
$"follow={ChronicleHud.FollowFocus} idle={SpectatorMode.Active} focusId={focusId} loreId={loreId}";
|
|
break;
|
|
}
|
|
case "lore_history_shown":
|
|
{
|
|
int want = ParseCountExpect(cmd, defaultValue: 1);
|
|
long detailId = ChronicleHud.DetailUnitId;
|
|
int haveData = Chronicle.HistoryCountFor(detailId);
|
|
int haveUi = ChronicleHud.LastDetailHistoryRows;
|
|
string cmp = (cmd.label ?? "min").Trim().ToLowerInvariant();
|
|
bool dataOk = cmp == "exact" || cmp == "==" ? haveData == want : haveData >= want;
|
|
bool uiOk = cmp == "exact" || cmp == "==" ? haveUi == want : haveUi >= want;
|
|
pass = Chronicle.HudVisible && detailId != 0 && dataOk && uiOk;
|
|
detail =
|
|
$"loreHist={haveData} uiRows={haveUi} want={want} detailId={detailId} dossierId={WatchCaption.CurrentUnitId}";
|
|
break;
|
|
}
|
|
case "dossier_lore_history_match":
|
|
{
|
|
long dossierId = WatchCaption.CurrentUnitId;
|
|
long loreId = ChronicleHud.DetailUnitId;
|
|
int lifeShown = WatchCaption.LastLifeShown;
|
|
int loreData = Chronicle.HistoryCountFor(loreId);
|
|
int loreUi = ChronicleHud.LastDetailHistoryRows;
|
|
bool idsMatch = dossierId != 0 && dossierId == loreId;
|
|
// Life lines must agree with Lore; activity-only peek does not imply chronicle rows.
|
|
bool countsAgree = lifeShown <= 0
|
|
? loreData == 0 && loreUi == 0
|
|
: loreData >= lifeShown && loreUi >= Mathf.Min(lifeShown, 24);
|
|
pass = Chronicle.HudVisible && idsMatch && countsAgree;
|
|
detail =
|
|
$"dossierId={dossierId} loreId={loreId} lifeShown={lifeShown} act={WatchCaption.LastActivityShown} loreData={loreData} loreUi={loreUi} preview={WatchCaption.LastHistoryPreview}";
|
|
break;
|
|
}
|
|
case "dossier_pinned":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
bool have = WatchCaption.PinnedWhilePaused && WatchCaption.Visible;
|
|
pass = have == want;
|
|
detail =
|
|
$"pinned={WatchCaption.PinnedWhilePaused} visible={WatchCaption.Visible} idle={SpectatorMode.Active} want={want}";
|
|
break;
|
|
}
|
|
case "dossier_unit_matches_lore":
|
|
{
|
|
long dossierId = WatchCaption.CurrentUnitId;
|
|
long loreId = ChronicleHud.DetailUnitId;
|
|
pass = dossierId != 0 && loreId != 0 && dossierId == loreId;
|
|
detail =
|
|
$"dossierId={dossierId} loreId={loreId} headline={WatchCaption.LastHeadline}";
|
|
break;
|
|
}
|
|
case "dossier_species":
|
|
{
|
|
string want = (cmd.value ?? cmd.asset ?? "").Trim();
|
|
string have = WatchCaption.Current != null ? WatchCaption.Current.SpeciesId ?? "" : "";
|
|
pass = !string.IsNullOrEmpty(want)
|
|
&& have.Equals(want, System.StringComparison.OrdinalIgnoreCase);
|
|
detail =
|
|
$"species={have} want={want} headline={WatchCaption.LastHeadline} avatarLive={DossierAvatar.ShowingLiveAvatar} avatarSpecies={DossierAvatar.ShowingSpeciesFallback}";
|
|
break;
|
|
}
|
|
case "dossier_matches_focus":
|
|
{
|
|
Actor focus = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
UnitDossier dossier = WatchCaption.Current;
|
|
string focusSpecies = focus?.asset != null ? focus.asset.id : "";
|
|
long focusId = 0;
|
|
try
|
|
{
|
|
focusId = focus != null ? focus.getID() : 0;
|
|
}
|
|
catch
|
|
{
|
|
focusId = 0;
|
|
}
|
|
|
|
pass = focus != null
|
|
&& focus.isAlive()
|
|
&& dossier != null
|
|
&& dossier.UnitId == focusId
|
|
&& !string.IsNullOrEmpty(focusSpecies)
|
|
&& focusSpecies.Equals(dossier.SpeciesId ?? "", System.StringComparison.OrdinalIgnoreCase)
|
|
&& DossierAvatar.ShowingLiveAvatar
|
|
&& !DossierAvatar.ShowingSpeciesFallback;
|
|
detail =
|
|
$"focusId={focusId} dossierId={(dossier != null ? dossier.UnitId : 0)} focusSpecies={focusSpecies} dossierSpecies={(dossier != null ? dossier.SpeciesId : "")} avatarLive={DossierAvatar.ShowingLiveAvatar} avatarSpecies={DossierAvatar.ShowingSpeciesFallback}";
|
|
break;
|
|
}
|
|
case "dossier_avatar_live":
|
|
{
|
|
pass = DossierAvatar.ShowingLiveAvatar && !DossierAvatar.ShowingSpeciesFallback;
|
|
detail =
|
|
$"avatarLive={DossierAvatar.ShowingLiveAvatar} avatarSpecies={DossierAvatar.ShowingSpeciesFallback} dossierId={WatchCaption.CurrentUnitId}";
|
|
break;
|
|
}
|
|
case "dossier_avatar_species":
|
|
{
|
|
pass = DossierAvatar.ShowingSpeciesFallback && !DossierAvatar.ShowingLiveAvatar;
|
|
detail =
|
|
$"avatarLive={DossierAvatar.ShowingLiveAvatar} avatarSpecies={DossierAvatar.ShowingSpeciesFallback} dossierId={WatchCaption.CurrentUnitId}";
|
|
break;
|
|
}
|
|
case "fallen_place_no_follow":
|
|
{
|
|
// Place focus must clear unit follow so the camera stays at the death site.
|
|
pass = Chronicle.LastFallenFocusDetail == "place" && !MoveCamera.hasFocusUnit();
|
|
detail =
|
|
$"fallenFocus={Chronicle.LastFallenFocusDetail} hasFocus={MoveCamera.hasFocusUnit()} pos={Chronicle.LastFallenFocusPosition}";
|
|
break;
|
|
}
|
|
case "world_jump_place":
|
|
{
|
|
pass = Chronicle.LastJumpDetail == "place"
|
|
&& !MoveCamera.hasFocusUnit()
|
|
&& Chronicle.LastJumpPosition.sqrMagnitude > 0.0001f;
|
|
detail =
|
|
$"jump={Chronicle.LastJumpDetail} hasFocus={MoveCamera.hasFocusUnit()} pos={Chronicle.LastJumpPosition}";
|
|
break;
|
|
}
|
|
case "fallen_killer_camera":
|
|
{
|
|
Actor focus = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
long focusId = 0;
|
|
try
|
|
{
|
|
focusId = focus != null ? focus.getID() : 0;
|
|
}
|
|
catch
|
|
{
|
|
focusId = 0;
|
|
}
|
|
|
|
string detailStr = Chronicle.LastFallenFocusDetail ?? "";
|
|
bool killerTag = detailStr.StartsWith("killer:");
|
|
long killerId = 0;
|
|
if (killerTag)
|
|
{
|
|
long.TryParse(detailStr.Substring("killer:".Length), out killerId);
|
|
}
|
|
|
|
pass = killerTag
|
|
&& killerId != 0
|
|
&& focusId == killerId
|
|
&& WatchCaption.CurrentUnitId != 0
|
|
&& WatchCaption.CurrentUnitId != focusId;
|
|
detail =
|
|
$"fallenFocus={detailStr} focusId={focusId} dossierId={WatchCaption.CurrentUnitId}";
|
|
break;
|
|
}
|
|
case "lore_zoom_blocked":
|
|
{
|
|
MoveCamera cam = MoveCamera.instance;
|
|
if (cam == null)
|
|
{
|
|
pass = false;
|
|
detail = "no camera";
|
|
break;
|
|
}
|
|
|
|
float before = cam.getTargetZoom();
|
|
CameraZoomPatches.ForceAbsorbForHarness = true;
|
|
try
|
|
{
|
|
MoveCamera.zoomInWheel(null);
|
|
MoveCamera.zoomOutWheel(null);
|
|
}
|
|
finally
|
|
{
|
|
CameraZoomPatches.ForceAbsorbForHarness = false;
|
|
}
|
|
|
|
float after = cam.getTargetZoom();
|
|
pass = Mathf.Abs(after - before) < 0.001f;
|
|
detail = $"zoomBefore={before} zoomAfter={after} absorb={ChronicleHud.ShouldAbsorbScrollZoom()}";
|
|
break;
|
|
}
|
|
case "dossier_history_fills_body":
|
|
{
|
|
pass = WatchCaption.LastHistoryShown > 0 && WatchCaption.LastHistoryFillsBody;
|
|
detail =
|
|
$"histFill={WatchCaption.LastHistoryFillsBody} shown={WatchCaption.LastHistoryShown} size={WatchCaption.LastPanelSize}";
|
|
break;
|
|
}
|
|
case "hud_no_overlap":
|
|
{
|
|
bool hasDossier = WatchCaption.TryGetScreenPixelRect(out Rect dossier);
|
|
bool hasMemory = ChronicleHud.TryGetScreenPixelRect(out Rect memory);
|
|
bool overlap = false;
|
|
if (hasDossier && hasMemory && ChronicleHud.Visible)
|
|
{
|
|
overlap = dossier.Overlaps(memory);
|
|
}
|
|
|
|
pass = hasDossier && (!ChronicleHud.Visible || (hasMemory && !overlap));
|
|
detail =
|
|
$"dossier={(hasDossier ? dossier.ToString() : "-")} memory={(hasMemory ? memory.ToString() : "-")} visible={ChronicleHud.Visible} overlap={overlap}";
|
|
break;
|
|
}
|
|
case "world_memory_compact":
|
|
{
|
|
bool hasMemory = ChronicleHud.TryGetScreenPixelRect(out Rect memory);
|
|
// Same canvas scale as dossier (no localScale damp). Reject tiny or near-fullscreen.
|
|
float minW = Screen.width * 0.22f;
|
|
float maxW = Screen.width * 0.55f;
|
|
float minH = Screen.height * 0.16f;
|
|
float maxH = Screen.height * 0.50f;
|
|
pass = ChronicleHud.Visible
|
|
&& hasMemory
|
|
&& memory.width >= minW
|
|
&& memory.height >= minH
|
|
&& memory.width <= maxW
|
|
&& memory.height <= maxH;
|
|
detail =
|
|
$"memory={(hasMemory ? memory.ToString() : "-")} screen={Screen.width}x{Screen.height} band=({minW:0}-{maxW:0} x {minH:0}-{maxH:0})";
|
|
break;
|
|
}
|
|
case "chronicle_tab":
|
|
case "lore_tab":
|
|
{
|
|
string wantRaw = (cmd.value ?? cmd.label ?? "world").Trim().ToLowerInvariant();
|
|
ChronicleHud.LoreTab want = ChronicleHud.LoreTab.World;
|
|
if (wantRaw == "fallen" || wantRaw == "dead")
|
|
{
|
|
want = ChronicleHud.LoreTab.Fallen;
|
|
}
|
|
else if (wantRaw == "living"
|
|
|| wantRaw == "characters"
|
|
|| wantRaw == "character"
|
|
|| wantRaw == "chars"
|
|
|| wantRaw == "history")
|
|
{
|
|
want = ChronicleHud.LoreTab.Living;
|
|
}
|
|
|
|
pass = Chronicle.HudVisible && ChronicleHud.ActiveTab == want;
|
|
detail =
|
|
$"hud={Chronicle.HudVisible} tab={ChronicleHud.ActiveTab} want={want} recent={Chronicle.RecentFocusCount}";
|
|
break;
|
|
}
|
|
case "fallen_list_top":
|
|
{
|
|
string want = (cmd.value ?? cmd.label ?? "").Trim();
|
|
string have = ChronicleHud.LastListTopTitle ?? "";
|
|
pass = Chronicle.HudVisible
|
|
&& ChronicleHud.ActiveTab == ChronicleHud.LoreTab.Fallen
|
|
&& ChronicleHud.DetailUnitId == 0
|
|
&& !string.IsNullOrEmpty(want)
|
|
&& have.IndexOf(want, System.StringComparison.OrdinalIgnoreCase) >= 0;
|
|
detail = $"top='{have}' want='{want}' tab={ChronicleHud.ActiveTab}";
|
|
break;
|
|
}
|
|
case "lore_list_stale":
|
|
{
|
|
bool want = ParseBool(cmd.value, defaultValue: true);
|
|
if (string.IsNullOrEmpty(cmd.value) && !string.IsNullOrEmpty(cmd.expect)
|
|
&& cmd.expect != "lore_list_stale")
|
|
{
|
|
want = ParseBool(cmd.expect, defaultValue: true);
|
|
}
|
|
|
|
bool have = ChronicleHud.CastListStale;
|
|
bool castTab = ChronicleHud.ActiveTab == ChronicleHud.LoreTab.Living
|
|
|| ChronicleHud.ActiveTab == ChronicleHud.LoreTab.Fallen;
|
|
pass = Chronicle.HudVisible && castTab && ChronicleHud.DetailUnitId == 0 && have == want;
|
|
detail =
|
|
$"stale={have} want={want} tab={ChronicleHud.ActiveTab} revision={Chronicle.HistoryRevision}";
|
|
break;
|
|
}
|
|
case "lore_recent":
|
|
{
|
|
int want = ParseCountExpect(cmd, defaultValue: 1);
|
|
int have = Chronicle.RecentFocusCount;
|
|
pass = have >= want;
|
|
detail = $"recent={have} min={want}";
|
|
break;
|
|
}
|
|
default:
|
|
pass = false;
|
|
detail = "unknown expect: " + expect;
|
|
break;
|
|
}
|
|
|
|
if (pass)
|
|
{
|
|
_assertPass++;
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_assertFail++;
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, pass, detail);
|
|
LogService.LogInfo(
|
|
$"[IdleSpectator][ASSERT] {(pass ? "PASS" : "FAIL")} id={cmd.id} expect={expect} {detail}");
|
|
}
|
|
|
|
private static void DoSnapshot(HarnessCommand cmd)
|
|
{
|
|
string snap =
|
|
$"idle={SpectatorMode.Active} focus={MoveCamera.hasFocusUnit()} powerBar={CanvasMain.isBottomBarShowing()} unit={FocusLabel()} tip={CameraDirector.LastWatchLabel} tipAsset={CameraDirector.LastWatchAssetId} bad={StateProbe.BadEventCount} tier={InterestDirector.CurrentTierName} discoveryPending={SpeciesDiscovery.PendingCount} caption={WatchCaption.LastHeadline} chronicle={Chronicle.Count}";
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true, detail: snap);
|
|
LogService.LogInfo("[IdleSpectator][SNAP] " + snap);
|
|
}
|
|
|
|
private static void DoDiscoveryNote(HarnessCommand cmd)
|
|
{
|
|
string assetId = ResolveAssetId(cmd);
|
|
if (string.IsNullOrEmpty(assetId))
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "missing asset for discovery_note");
|
|
return;
|
|
}
|
|
|
|
Vector3 pos = CameraPos();
|
|
Actor unit = ResolveUnit(assetId);
|
|
if (unit != null)
|
|
{
|
|
pos = unit.current_position;
|
|
}
|
|
|
|
bool ok = SpeciesDiscovery.HarnessNoteAsset(assetId, pos);
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail: $"asset={assetId} pending={SpeciesDiscovery.PendingCount}");
|
|
}
|
|
|
|
private static void DoWatchGhost(HarnessCommand cmd)
|
|
{
|
|
if (!WorldReady())
|
|
{
|
|
if (RetryFront(cmd, "world_not_ready"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "world_not_ready");
|
|
return;
|
|
}
|
|
|
|
Actor near = ResolveUnit(_lastSpawnedAssetId);
|
|
if (near == null)
|
|
{
|
|
near = WorldActivityScanner.FindNearestAliveUnit(CameraPos(), 5000f);
|
|
}
|
|
|
|
if (near == null)
|
|
{
|
|
_cmdFail++;
|
|
Emit(cmd, ok: false, detail: "no unit near camera for ghost watch");
|
|
return;
|
|
}
|
|
|
|
// Claim a species that is extremely unlikely to match the focused unit.
|
|
string fakeAsset = string.IsNullOrEmpty(cmd.asset) || cmd.asset == "auto"
|
|
? "__ghost_species__"
|
|
: cmd.asset;
|
|
string label = string.IsNullOrEmpty(cmd.label)
|
|
? $"New species: {fakeAsset}"
|
|
: cmd.label.Replace("{asset}", fakeAsset);
|
|
|
|
InterestEvent interest = new InterestEvent
|
|
{
|
|
Tier = ParseTier(cmd.tier, InterestTier.Curiosity),
|
|
Score = 50f,
|
|
Position = near.current_position,
|
|
FollowUnit = null,
|
|
Label = label,
|
|
CreatedAt = Time.unscaledTime,
|
|
AssetId = fakeAsset
|
|
};
|
|
|
|
string before = FocusKey();
|
|
CameraDirector.Watch(interest);
|
|
string after = FocusKey();
|
|
bool unchanged = before == after && MoveCamera.hasFocusUnit();
|
|
if (unchanged)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, unchanged, detail: $"ghost={fakeAsset} before={before} after={after} tip={CameraDirector.LastWatchLabel}");
|
|
}
|
|
|
|
private static string ResolveAssetId(HarnessCommand cmd)
|
|
{
|
|
string assetId = string.IsNullOrEmpty(cmd.asset) ? cmd.value : cmd.asset;
|
|
if (assetId == "auto" || string.IsNullOrEmpty(assetId))
|
|
{
|
|
assetId = _lastSpawnedAssetId;
|
|
}
|
|
|
|
return assetId ?? "";
|
|
}
|
|
|
|
private static string FocusKey()
|
|
{
|
|
if (!MoveCamera.hasFocusUnit() || MoveCamera._focus_unit == null)
|
|
{
|
|
return "-";
|
|
}
|
|
|
|
Actor unit = MoveCamera._focus_unit;
|
|
string asset = unit.asset != null ? unit.asset.id : "?";
|
|
return $"{asset}@{unit.GetHashCode()}";
|
|
}
|
|
|
|
private static void IngestNewCommands()
|
|
{
|
|
string path = CommandsPath();
|
|
if (!File.Exists(path))
|
|
{
|
|
return;
|
|
}
|
|
|
|
long length;
|
|
try
|
|
{
|
|
length = new FileInfo(path).Length;
|
|
}
|
|
catch
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (length < _offset)
|
|
{
|
|
_offset = 0;
|
|
}
|
|
|
|
if (length == _offset)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
|
|
{
|
|
fs.Seek(_offset, SeekOrigin.Begin);
|
|
using (StreamReader reader = new StreamReader(fs, Encoding.UTF8))
|
|
{
|
|
string line;
|
|
while ((line = reader.ReadLine()) != null)
|
|
{
|
|
_offset = fs.Position;
|
|
line = line.Trim();
|
|
if (string.IsNullOrEmpty(line) || line.StartsWith("#"))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
HarnessCommand cmd = null;
|
|
try
|
|
{
|
|
cmd = JsonUtility.FromJson<HarnessCommand>(line);
|
|
}
|
|
catch
|
|
{
|
|
LogService.LogInfo("[IdleSpectator][HARNESS] bad json: " + line);
|
|
continue;
|
|
}
|
|
|
|
if (cmd == null || string.IsNullOrEmpty(cmd.action))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(cmd.id))
|
|
{
|
|
cmd.id = Guid.NewGuid().ToString("N").Substring(0, 8);
|
|
}
|
|
|
|
Queue.Enqueue(cmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
File.WriteAllText(OffsetPath(), _offset.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogService.LogInfo("[IdleSpectator][HARNESS] ingest error: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static void Emit(HarnessCommand cmd, bool ok, string detail)
|
|
{
|
|
string line =
|
|
$"{{\"id\":\"{Escape(cmd.id)}\",\"action\":\"{Escape(cmd.action)}\",\"ok\":{(ok ? "true" : "false")},\"detail\":\"{Escape(detail)}\"}}";
|
|
try
|
|
{
|
|
File.AppendAllText(ResultsPath(), line + "\n");
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
LogService.LogInfo(
|
|
$"[IdleSpectator][HARNESS] {(ok ? "ok" : "FAIL")} id={cmd.id} action={cmd.action} detail={detail}");
|
|
}
|
|
|
|
private static void WriteLastResult(string status, string detail)
|
|
{
|
|
LastResult result = new LastResult
|
|
{
|
|
batch_id = _lastBatchId,
|
|
status = status,
|
|
ok = _cmdOk,
|
|
fail = _cmdFail,
|
|
assert_pass = _assertPass,
|
|
assert_fail = _assertFail,
|
|
idle = SpectatorMode.Active.ToString(),
|
|
focus = MoveCamera.hasFocusUnit().ToString(),
|
|
power_bar = CanvasMain.isBottomBarShowing().ToString(),
|
|
unit = FocusLabel(),
|
|
tip = CameraDirector.LastWatchLabel ?? "",
|
|
detail = detail ?? "",
|
|
updated_at = DateTime.UtcNow.ToString("o")
|
|
};
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(LastResultPath(), JsonUtility.ToJson(result, true));
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
private static bool WorldReady()
|
|
{
|
|
return Config.game_loaded && World.world != null && !SmoothLoader.isLoading();
|
|
}
|
|
|
|
private static bool HasAnyAliveUnit()
|
|
{
|
|
return WorldActivityScanner.FindNearestAliveUnit(CameraPos(), 5000f) != null;
|
|
}
|
|
|
|
private static bool ShouldAutoDismissUi()
|
|
{
|
|
if (Queue.Count > 0 || _waitUntil > 0f)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
string dir = HarnessDir();
|
|
if (string.IsNullOrEmpty(dir))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (File.Exists(Path.Combine(dir, "auto-dismiss")))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
string commands = CommandsPath();
|
|
if (!File.Exists(commands))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
return new FileInfo(commands).Length > _offset;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes Welcome Back (and optionally any ScrollWindow) so map gen / play can proceed.
|
|
/// </summary>
|
|
public static bool TryDismissBlockingWindows(bool forceAll = false)
|
|
{
|
|
if (!ScrollWindow.isWindowActive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ScrollWindow current = ScrollWindow.getCurrentWindow();
|
|
string id = current != null ? current.screen_id : "";
|
|
bool welcome = id == "welcome"
|
|
|| (current != null && current.GetComponent<WindowWelcome>() != null);
|
|
|
|
if (!welcome && !forceAll)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ScrollWindow.hideAllEvent(pWithAnimation: false);
|
|
LogService.LogInfo($"[IdleSpectator][HARNESS] dismissed window id={id}");
|
|
return true;
|
|
}
|
|
|
|
private static bool IsBlockingWindowOpen()
|
|
{
|
|
if (!ScrollWindow.isWindowActive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ScrollWindow current = ScrollWindow.getCurrentWindow();
|
|
if (current == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (current.screen_id == "welcome")
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return current.GetComponent<WindowWelcome>() != null;
|
|
}
|
|
|
|
private static WorldTile TileNearCamera()
|
|
{
|
|
Vector3 pos = CameraPos();
|
|
int x = Mathf.RoundToInt(pos.x);
|
|
int y = Mathf.RoundToInt(pos.y);
|
|
WorldTile tile = World.world.GetTile(x, y);
|
|
if (tile != null)
|
|
{
|
|
return tile;
|
|
}
|
|
|
|
return World.world.GetTileSimple(x, y);
|
|
}
|
|
|
|
private static Vector3 CameraPos()
|
|
{
|
|
if (MoveCamera.instance != null)
|
|
{
|
|
return MoveCamera.instance.transform.position;
|
|
}
|
|
|
|
return Vector3.zero;
|
|
}
|
|
|
|
private static string FocusLabel()
|
|
{
|
|
if (!MoveCamera.hasFocusUnit() || MoveCamera._focus_unit == null)
|
|
{
|
|
return "-";
|
|
}
|
|
|
|
return SafeName(MoveCamera._focus_unit);
|
|
}
|
|
|
|
private static string SafeName(Actor actor)
|
|
{
|
|
try
|
|
{
|
|
string name = actor.getName();
|
|
if (!string.IsNullOrEmpty(name))
|
|
{
|
|
return name;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
return actor.asset != null ? actor.asset.id : "unit";
|
|
}
|
|
|
|
private static InterestTier ParseTier(string raw, InterestTier fallback)
|
|
{
|
|
if (string.IsNullOrEmpty(raw))
|
|
{
|
|
return fallback;
|
|
}
|
|
|
|
if (Enum.TryParse(raw, ignoreCase: true, out InterestTier tier))
|
|
{
|
|
return tier;
|
|
}
|
|
|
|
return fallback;
|
|
}
|
|
|
|
private static int ParseCountExpect(HarnessCommand cmd, int defaultValue)
|
|
{
|
|
// Prefer explicit value= so Step()'s default count=1 does not override want=0.
|
|
if (!string.IsNullOrEmpty(cmd.value)
|
|
&& int.TryParse(cmd.value.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out int fromValue))
|
|
{
|
|
return fromValue;
|
|
}
|
|
|
|
if (cmd.count != 1 || string.IsNullOrEmpty(cmd.value))
|
|
{
|
|
// count explicitly set via Step(..., count: N) when N != default 1, or no value given.
|
|
if (string.IsNullOrEmpty(cmd.value))
|
|
{
|
|
return cmd.count;
|
|
}
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
private static bool ParseBool(string raw, bool defaultValue)
|
|
{
|
|
if (string.IsNullOrEmpty(raw))
|
|
{
|
|
return defaultValue;
|
|
}
|
|
|
|
raw = raw.Trim().ToLowerInvariant();
|
|
if (raw == "1" || raw == "true" || raw == "on" || raw == "yes")
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (raw == "0" || raw == "false" || raw == "off" || raw == "no")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
private static float ParseFloat(string raw, float defaultValue)
|
|
{
|
|
if (float.TryParse(raw, NumberStyles.Float, CultureInfo.InvariantCulture, out float v))
|
|
{
|
|
return v;
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
private static string Escape(string s)
|
|
{
|
|
if (string.IsNullOrEmpty(s))
|
|
{
|
|
return "";
|
|
}
|
|
|
|
return s.Replace("\\", "\\\\").Replace("\"", "\\\"");
|
|
}
|
|
|
|
private static void EnsureDirs()
|
|
{
|
|
string dir = HarnessDir();
|
|
if (string.IsNullOrEmpty(dir))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!Directory.Exists(dir))
|
|
{
|
|
Directory.CreateDirectory(dir);
|
|
}
|
|
|
|
if (_offset == 0 && File.Exists(OffsetPath()))
|
|
{
|
|
if (long.TryParse(File.ReadAllText(OffsetPath()).Trim(), out long stored))
|
|
{
|
|
_offset = stored;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Script drops <c>.harness/reset</c> (and/or writes offset=0) before a new command batch.
|
|
/// Without this, a same-length rewrite of commands.jsonl is skipped forever.
|
|
/// </summary>
|
|
private static void CheckExternalReset()
|
|
{
|
|
string dir = HarnessDir();
|
|
if (string.IsNullOrEmpty(dir))
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool resetRequested = false;
|
|
string resetPath = Path.Combine(dir, "reset");
|
|
if (File.Exists(resetPath))
|
|
{
|
|
try
|
|
{
|
|
File.Delete(resetPath);
|
|
}
|
|
catch
|
|
{
|
|
// Still reset in memory.
|
|
}
|
|
|
|
resetRequested = true;
|
|
}
|
|
|
|
// Also honor an on-disk offset that was rewound by the runner.
|
|
if (!resetRequested && File.Exists(OffsetPath()))
|
|
{
|
|
try
|
|
{
|
|
if (long.TryParse(File.ReadAllText(OffsetPath()).Trim(), out long diskOffset)
|
|
&& diskOffset < _offset)
|
|
{
|
|
resetRequested = true;
|
|
_offset = diskOffset;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
if (!resetRequested)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Queue.Clear();
|
|
_waitUntil = -1f;
|
|
_directorRunActive = false;
|
|
_readyLogged = false;
|
|
_offset = 0;
|
|
_lastSpawned = null;
|
|
_lastSpawnedAssetId = "";
|
|
_rememberedFocusKey = "";
|
|
InterestDirector.SetHarnessFastTiming(false);
|
|
SpeciesDiscovery.SetHarnessFastTiming(false);
|
|
try
|
|
{
|
|
File.WriteAllText(OffsetPath(), "0");
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
LogService.LogInfo("[IdleSpectator][HARNESS] inbox reset - re-reading commands.jsonl");
|
|
}
|
|
|
|
private static void RequeueFront(HarnessCommand cmd)
|
|
{
|
|
List<HarnessCommand> rest = new List<HarnessCommand>(Queue);
|
|
Queue.Clear();
|
|
Queue.Enqueue(cmd);
|
|
foreach (HarnessCommand step in rest)
|
|
{
|
|
Queue.Enqueue(step);
|
|
}
|
|
}
|
|
|
|
private static string PickSpawnAssetId()
|
|
{
|
|
foreach (string id in PreferredSpawnAssets)
|
|
{
|
|
if (AssetManager.actor_library?.get(id) != null)
|
|
{
|
|
return id;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static Actor ResolveUnit(string assetId)
|
|
{
|
|
if (_lastSpawned != null && _lastSpawned.isAlive())
|
|
{
|
|
if (string.IsNullOrEmpty(assetId)
|
|
|| (_lastSpawned.asset != null && _lastSpawned.asset.id == assetId))
|
|
{
|
|
return _lastSpawned;
|
|
}
|
|
}
|
|
|
|
Vector3 pos = CameraPos();
|
|
if (!string.IsNullOrEmpty(assetId))
|
|
{
|
|
return WorldActivityScanner.FindAliveByAssetId(assetId, pos, 5000f);
|
|
}
|
|
|
|
if (MoveCamera.hasFocusUnit() && MoveCamera._focus_unit != null && MoveCamera._focus_unit.isAlive())
|
|
{
|
|
return MoveCamera._focus_unit;
|
|
}
|
|
|
|
return WorldActivityScanner.FindNearestAliveUnit(pos, 5000f);
|
|
}
|
|
|
|
private static bool RetryFront(HarnessCommand cmd, string reason, int maxRetries = 20)
|
|
{
|
|
cmd.retries++;
|
|
if (cmd.retries > maxRetries)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
RequeueFront(cmd);
|
|
_waitUntil = Time.unscaledTime + 0.35f;
|
|
if (cmd.retries == 1 || cmd.retries % 10 == 0)
|
|
{
|
|
LogService.LogInfo(
|
|
$"[IdleSpectator][HARNESS] retry id={cmd.id} action={cmd.action} reason={reason} attempt={cmd.retries}");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static bool CaptureHarnessScreenshot(string fileName)
|
|
{
|
|
try
|
|
{
|
|
string dir = HarnessDir();
|
|
if (string.IsNullOrEmpty(dir))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Directory.CreateDirectory(dir);
|
|
string name = string.IsNullOrEmpty(fileName) ? "hud.png" : fileName;
|
|
if (!name.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
name += ".png";
|
|
}
|
|
|
|
string path = Path.Combine(dir, name);
|
|
// Absolute path required so Unity does not write under the game cwd.
|
|
ScreenCapture.CaptureScreenshot(path);
|
|
LastScreenshotPath = path;
|
|
|
|
string cropPath = Path.Combine(
|
|
dir,
|
|
Path.GetFileNameWithoutExtension(name) + "-dossier.png");
|
|
if (ModClass.Instance != null)
|
|
{
|
|
ModClass.Instance.StartCoroutine(CaptureDossierCropEndOfFrame(cropPath));
|
|
}
|
|
|
|
LogService.LogInfo(
|
|
$"[IdleSpectator][HARNESS] screenshot queued path={path} crop={cropPath} layoutOk={WatchCaption.LastLayoutOk} size={WatchCaption.LastPanelSize}");
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LastScreenshotPath = "";
|
|
LogService.LogInfo("[IdleSpectator][HARNESS] screenshot failed: " + ex.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static IEnumerator CaptureDossierCropEndOfFrame(string cropPath)
|
|
{
|
|
yield return new WaitForEndOfFrame();
|
|
try
|
|
{
|
|
if (!WatchCaption.TryGetScreenPixelRect(out Rect rect))
|
|
{
|
|
LogService.LogInfo("[IdleSpectator][HARNESS] dossier crop skipped: no visible dossier rect");
|
|
yield break;
|
|
}
|
|
|
|
int x = Mathf.Clamp(Mathf.FloorToInt(rect.xMin), 0, Screen.width - 1);
|
|
int y = Mathf.Clamp(Mathf.FloorToInt(rect.yMin), 0, Screen.height - 1);
|
|
int w = Mathf.Clamp(Mathf.CeilToInt(rect.width), 1, Screen.width - x);
|
|
int h = Mathf.Clamp(Mathf.CeilToInt(rect.height), 1, Screen.height - y);
|
|
if (w < 16 || h < 16)
|
|
{
|
|
LogService.LogInfo($"[IdleSpectator][HARNESS] dossier crop skipped: tiny rect {w}x{h}");
|
|
yield break;
|
|
}
|
|
|
|
Texture2D tex = new Texture2D(w, h, TextureFormat.RGB24, false);
|
|
tex.ReadPixels(new Rect(x, y, w, h), 0, 0);
|
|
tex.Apply();
|
|
byte[] png = tex.EncodeToPNG();
|
|
UnityEngine.Object.Destroy(tex);
|
|
File.WriteAllBytes(cropPath, png);
|
|
LogService.LogInfo(
|
|
$"[IdleSpectator][HARNESS] dossier crop written path={cropPath} rect=({x},{y},{w},{h}) screen={Screen.width}x{Screen.height}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogService.LogInfo("[IdleSpectator][HARNESS] dossier crop failed: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static string HarnessDir()
|
|
{
|
|
if (string.IsNullOrEmpty(ModClass.ModFolder))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return Path.Combine(ModClass.ModFolder, ".harness");
|
|
}
|
|
|
|
private static string CommandsPath() => Path.Combine(HarnessDir(), "commands.jsonl");
|
|
private static string ResultsPath() => Path.Combine(HarnessDir(), "results.jsonl");
|
|
private static string LastResultPath() => Path.Combine(HarnessDir(), "last-result.json");
|
|
private static string OffsetPath() => Path.Combine(HarnessDir(), "offset");
|
|
}
|