2113 lines
68 KiB
C#
2113 lines
68 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 "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 "world_memory_open":
|
|
{
|
|
// Tabs removed - World Memory is a single panel.
|
|
Chronicle.ShowHud();
|
|
bool open = Chronicle.HudVisible;
|
|
if (open)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, open, detail: $"hud={open} memory={Chronicle.MemoryCount} age={Chronicle.CurrentAgeName}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_open":
|
|
{
|
|
Chronicle.ShowHud();
|
|
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":
|
|
{
|
|
// Expand control removed: history is always full-list + scroll when tall.
|
|
_cmdOk++;
|
|
Emit(cmd, ok: true,
|
|
detail: $"expand_removed shown={WatchCaption.LastHistoryShown} scrollable={WatchCaption.LastHistoryScrollable}");
|
|
break;
|
|
}
|
|
|
|
case "chronicle_jump":
|
|
{
|
|
bool ok = Chronicle.JumpToLatest();
|
|
if (ok)
|
|
{
|
|
_cmdOk++;
|
|
}
|
|
else
|
|
{
|
|
_cmdFail++;
|
|
}
|
|
|
|
Emit(cmd, ok, detail: $"jumped={ok} focus={MoveCamera.hasFocusUnit()}");
|
|
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);
|
|
detail =
|
|
$"layoutOk={WatchCaption.LastLayoutOk} size={WatchCaption.LastPanelSize} histFill={WatchCaption.LastHistoryFillsBody} scrollable={WatchCaption.LastHistoryScrollable} 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.LastHistoryPreview ?? "";
|
|
pass = !string.IsNullOrEmpty(needle)
|
|
&& hist.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0;
|
|
detail = $"hist='{hist}' needle='{needle}'";
|
|
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 "dossier_favorite":
|
|
case "is_favorite":
|
|
{
|
|
Actor unit = MoveCamera.hasFocusUnit() ? MoveCamera._focus_unit : null;
|
|
bool fav = false;
|
|
try
|
|
{
|
|
fav = unit != null && unit.isFavorite();
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
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);
|
|
int have = 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} scrollable={WatchCaption.LastHistoryScrollable} histFill={WatchCaption.LastHistoryFillsBody}";
|
|
break;
|
|
}
|
|
case "dossier_history_scrollable":
|
|
{
|
|
pass = WatchCaption.LastHistoryScrollable && WatchCaption.LastHistoryShown > 3;
|
|
detail =
|
|
$"scrollable={WatchCaption.LastHistoryScrollable} shown={WatchCaption.LastHistoryShown}";
|
|
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":
|
|
{
|
|
// Deprecated: panel is always World Memory when open.
|
|
pass = Chronicle.HudVisible;
|
|
detail = $"hud={Chronicle.HudVisible} memory={Chronicle.MemoryCount} (tabs removed)";
|
|
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");
|
|
}
|