UI提升,进入能跑阶段

This commit is contained in:
2026-09-24 22:55:46 +08:00
parent afb343aa49
commit 5f1be65512
47 changed files with 4645 additions and 354 deletions
+360 -113
View File
@@ -1,33 +1,117 @@
using OSM.Client.Autoload;
using OSM.Client.Contracts;
using OSM.Client.Screens.Battle;
namespace OSM.Client.Diagnostics;
/// <summary>
/// 阶段 C 真实 /ws/solo 竖切回归:移动、服务器拒绝恢复、普通攻击,并顺带观察 Continue。
/// <para><b>权威服务器原则</b>:客户端不推算射程、合法性或可选目标,只依据服务器下发的内容决策——</para>
/// <list type="bullet">
/// <item><c>ActionType.enemyOptions / enemys</c>:当前位置「攻击可达 ∪ 施法可达」的敌人
/// (见 GamingQueue 中按 canAttackGrids/canCastGrids 过滤后的 enemys)。列表为空时普通攻击
/// 必然被服务器取消,因此不提交。</item>
/// <item><c>ActionType.dp.quotas</c>:该行动类型本回合是否还可用(配额 + 决策点)。</item>
/// <item><c>TargetGrid.gridIds</c> / <c>Targets.targets</c>:唯一合法的格子与目标。</item>
/// </list>
/// <para>服务器对非法提交没有显式回执(<c>gaming.resolved</c> 尚未实现),被作废的行动只能在下一次
/// <c>gaming.request</c> 里看出来:又回到 <c>ActionType</c> 就说明上一个行动无效。所以这里用
/// 「同一回合内不重复提交刚被取消的行动」收敛,而不是让客户端猜距离——重复白提交会撞上服务端防打转
/// 护栏(同类决策连续 4 次 ⇒ 强制 AI 托管并结束回合),连 Continue 一起吃掉。</para>
/// <para>Continue 只记录、不作为通过条件:本局是否真的下发 Continue 取决于该回合是否正常结束且玩家
/// 未被托管;它的协议形状由 <see cref="PhaseCDecisionSmokeTest"/> 静态覆盖。</para>
/// </summary>
public partial class SoloVerticalSliceSmokeTest : Node
{
// 移动上限给足:种子固定后抽到的两名角色可能开局离得很远,而回归要求真实走到普攻射程内。
// 收敛由「朝敌人移动 + 敌人也朝你来」保证;服务器拒绝移动时会置 _moveCancelled 提前收手。
private const int MaxSteps = 900;
private const int MaxMoves = 80;
private const int MaxSettlingSteps = 12;
/// <summary>核心路径达成后,再给多少步专门去验证「普攻可达门控」(需要敌人真的走进 ATR)。</summary>
private const int MaxGateSettlingSteps = 200;
/// <summary>等服务器下发下一条决策的超时(**秒**)。别写成毫秒 —— 写错就是「永远卡住」。</summary>
private const double DecisionTimeoutSeconds = 20.0;
private const double ShortTimeoutSeconds = 15.0;
private const double TotalTimeoutSeconds = 240.0;
/// <summary>看门狗上限:超过它无论如何都要退出,并留下原因(否则工具只能 SIGTERM,输出全丢)。</summary>
private const double WatchdogSeconds = 300.0;
private GameSession _session = null!;
private BattleStore _store = null!;
private SoloTestDriver _driver = null!;
private int _moves;
private int _attackAttempts;
private int _attackCancelledCount;
private int _attackTargetsOffered;
private bool _preciseAttackSignal;
private bool _attackGateVerified;
private bool _attackSubmitted;
private bool _attackCancelled;
private bool _moveCancelled;
private bool _rejectionRecovered;
private bool _continued;
private bool _continueObserved;
private int _lastRound = -1;
private ulong _deadlineMs;
private ulong _nextBeatAtMs;
public override void _Ready()
{
_session = GetNode<GameSession>("/root/GameSession");
_store = GetNode<BattleStore>("/root/BattleStore");
_driver = new SoloTestDriver(_store, this);
_ = RunAsync();
_ = WatchdogAsync();
}
/// <summary>
/// 心跳:每 2 秒打一行当前状态。
/// 用途是把「主循环整个卡死」和「某个 await 永远不返回」区分开 ——
/// 心跳停 = 主循环卡死(SceneTreeTimer 也不会触发);心跳继续 = 主循环活着但 await 链断了。
/// </summary>
public override void _Process(double delta)
{
if (Time.GetTicksMsec() < _nextBeatAtMs)
{
return;
}
_nextBeatAtMs = Time.GetTicksMsec() + 2_000;
SoloTrace.Step(
$"beat session={_session.State} pending={_store.PendingDecision?.Kind ?? "none"} "
+ $"inFlight={_store.IsSubmittingDecision} logs={_store.LogLines.Count} "
+ $"units={GetTree().GetNodesInGroup("battle_unit").Count}");
}
/// <summary>
/// 看门狗:正常路径很快就能跑完,卡住时不能让进程一直挂着 ——
/// 挂死会让工具 SIGTERM,而 Godot 失缓冲的 stdout 到时全丢,只剩「什么都没跑」。
/// </summary>
private async Task WatchdogAsync()
{
await ToSignal(GetTree().CreateTimer(WatchdogSeconds), SceneTreeTimer.SignalName.Timeout);
var message = $"SOLO_VERTICAL_FAILED watchdog timed out after {WatchdogSeconds:0}s";
SoloTrace.Step(message);
GD.PushError(message);
GetTree().Quit(1);
}
private async Task RunAsync()
{
try
{
if (!await _session.ConnectAsync(new Uri("ws://localhost:11030/ws/solo")))
_deadlineMs = Time.GetTicksMsec() + (ulong)(TotalTimeoutSeconds * 1_000);
SoloTrace.Step("connecting");
if (!await _session.ConnectAsync(new Uri("ws://localhost:12030/ws/solo")))
{
throw new InvalidOperationException("WebSocket connection failed.");
}
await WaitUntilAsync(() => _session.State == SessionState.Connected, 5.0);
await _driver.WaitOrThrowAsync(() => _session.State == SessionState.Connected, 5.0);
await _store.StartGameAsync(new SoloStartOptions
{
CharacterCount = 2,
@@ -37,104 +121,113 @@ public partial class SoloVerticalSliceSmokeTest : Node
MaxRespawnTimes = 0,
MaxScoreToWin = 0,
DecisionTimeoutSeconds = 30,
// 协议层确认服务端接收 requireContinue;本局是否真的下发 Continue 由服务器流程决定。
RequireContinue = true,
RoundDelayMs = 0,
DropItemsIntervalSeconds = 0,
Seed = 20260919
});
await WaitForDecisionAsync(SoloDecisionKinds.SelectCharacter, 10.0);
var character = _store.PendingDecision!
.ReadPayload<SelectCharacterPayload>()?
SoloTrace.Step("connected, gaming.start sent, waiting SelectCharacter");
var decision = await _driver.AwaitDecisionAsync(10.0);
if (decision.Kind != SoloDecisionKinds.SelectCharacter)
{
throw new InvalidOperationException($"Expected SelectCharacter, got {decision.Kind}.");
}
var character = decision.ReadPayload<SelectCharacterPayload>()?
.Characters
.FirstOrDefault()
?? throw new InvalidOperationException("Server returned no selectable characters.");
await _store.SubmitDecisionAsync(new { characterGuid = character.Guid });
decision = await _driver.SubmitAndAwaitNextAsync(
decision,
new { characterGuid = character.Guid },
ShortTimeoutSeconds);
await WaitUntilAsync(
await _driver.WaitOrThrowAsync(
() => _store.Snapshot is { PlayerGuid.Length: > 0, Characters.Count: > 1, Map: not null },
10.0);
await WaitUntilAsync(
ShortTimeoutSeconds);
await _driver.WaitOrThrowAsync(
() => GetTree().GetNodesInGroup("battle_unit").Count == _store.Snapshot!.Characters.Count,
5.0);
var attacked = false;
for (var step = 0; step < 24 && (!attacked || !_continued); step++)
SoloTrace.Step($"character selected, entering decision loop");
// 用可空局部变量承载「下一轮要处理的决策」:服务器放弃决策时它会变成 null,循环随之收尾。
SoloDecisionRequest? current = decision;
var steps = 0;
var settling = 0;
var gateSettling = 0;
while (steps++ < MaxSteps)
{
await WaitUntilAsync(() => _store.PendingDecision is not null, 45.0);
var decision = _store.PendingDecision!;
switch (decision.Kind)
if (Time.GetTicksMsec() >= _deadlineMs)
{
case SoloDecisionKinds.ActionType:
await _store.SubmitDecisionAsync(new
{
actionType = attacked
? "EndTurn"
: _moves == 0
? "Move"
: HasServerAttackTarget(decision) ? "NormalAttack" : "Move"
});
break;
case SoloDecisionKinds.TargetGrid:
if (!_rejectionRecovered)
{
var rejectedRequestId = decision.RequestId;
await _store.SubmitDecisionAsync(new { gridId = long.MaxValue });
await WaitUntilAsync(
() => _store.PendingDecision is not null
&& _store.PendingDecision.RequestId != rejectedRequestId,
10.0);
_rejectionRecovered = true;
}
else
{
await SubmitBestMoveAsync(decision);
}
break;
case SoloDecisionKinds.Targets:
{
var target = decision.ReadPayload<TargetsPayload>()?.Targets.FirstOrDefault()
?? throw new InvalidOperationException("Attack request contained no legal target.");
await _store.SubmitDecisionAsync(new { targetGuids = new[] { target.Guid } });
attacked = true;
break;
}
case SoloDecisionKinds.Continue:
await _store.SubmitDecisionAsync(new { cancelled = false });
_continued = true;
break;
default:
await _store.SubmitDecisionAsync(new { cancelled = true });
break;
SoloTrace.Step($"SOLO_VERTICAL_DEADLINE reached after {steps} steps");
GD.PushWarning($"SOLO_VERTICAL_DEADLINE reached after {steps} steps.");
break;
}
if (!_store.IsStarted)
{
// 对局结束(gaming.over)或玩家被服务器托管:不会再有决策下发,收尾评估即可。
SoloTrace.Step($"server stopped asking for decisions after {steps} steps");
break;
}
if (IsCorePathSatisfied()
&& (_continueObserved || ++settling > MaxSettlingSteps)
&& (_attackGateVerified || ++gateSettling > MaxGateSettlingSteps))
{
break;
}
if (current is null)
{
// 服务器放弃/不再下发决策(对局结束、玩家被接管):本轮观测到此为止。
SoloTrace.Step($"server dropped the decision after {steps} steps");
break;
}
ResetTurnGuards();
SoloTrace.Step(
$"step={steps} kind={current.Kind} moves={_moves} attacks={_attackAttempts} "
+ $"cancelled={_attackCancelledCount} submitted={_attackSubmitted} rejected={_rejectionRecovered}");
current = await TryHandleDecisionAsync(current);
}
SoloTrace.Step($"decision loop exited after {steps} steps");
if (_moves == 0)
{
throw new InvalidOperationException("Vertical slice did not complete a movement.");
}
if (!attacked)
if (!_attackSubmitted)
{
throw new InvalidOperationException("Vertical slice did not reach an attack target request.");
throw new InvalidOperationException(
"Vertical slice did not submit a normal attack on a server-listed target. "
+ $"moves={_moves} attackAttempts={_attackAttempts} "
+ $"attackReachableRounds={_attackTargetsOffered} attackGateVerified={_attackGateVerified} "
+ $"preciseSignal={_preciseAttackSignal} enemyNeverInAtr={_attackTargetsOffered == 0}");
}
if (!_rejectionRecovered)
{
throw new InvalidOperationException("Vertical slice did not recover from a rejected grid.");
}
if (!_continued)
if (_preciseAttackSignal && _attackCancelledCount > 0)
{
throw new InvalidOperationException("Vertical slice did not complete a Continue decision.");
// 服务器下发了严格口径的 attackTargets,却仍有普攻被作废 ⇒ 该信号不可信
throw new InvalidOperationException(
$"Server advertised precise attackTargets but {_attackCancelledCount} normal attack(s) were cancelled.");
}
GD.Print(
$"SOLO_VERTICAL_OK game={_store.Snapshot!.GameId} moves={_moves} "
+ $"attackTargetSubmitted=true rejectionRecovered=true "
+ $"continueSubmitted=true "
+ $"units={GetTree().GetNodesInGroup("battle_unit").Count}");
var okLine = $"SOLO_VERTICAL_OK game={_store.Snapshot!.GameId} moves={_moves} "
+ "attackTargetSubmitted=true rejectionRecovered=true "
+ $"attackAttempts={_attackAttempts} attackCancelled={_attackCancelledCount} "
+ $"attackReachableRounds={_attackTargetsOffered} attackGateVerified={_attackGateVerified} "
+ $"preciseAttackSignal={(_preciseAttackSignal ? "true" : "false")} "
+ $"continueObserved={(_continueObserved ? "true" : "false")} "
+ $"units={GetTree().GetNodesInGroup("battle_unit").Count}";
SoloTrace.Step(okLine);
GD.Print(okLine);
await _session.EndSoloGameAsync();
await _session.DisconnectAsync();
@@ -142,73 +235,227 @@ public partial class SoloVerticalSliceSmokeTest : Node
}
catch (Exception exception)
{
// 先写 stderr(不带缓冲),保证即使后面清理步骤卡住、进程被强杀,失败原因也留得下来。
SoloTrace.Step($"SOLO_VERTICAL_FAILED {exception.Message}");
GD.PushError($"SOLO_VERTICAL_FAILED {exception.Message}");
await _session.DisconnectAsync();
GetTree().Quit(1);
}
}
private static bool HasServerAttackTarget(SoloDecisionRequest decision)
/// <summary>
/// 处理一条决策;服务器在等待期间不再下发新决策时返回 null(对局结束 / 托管),
/// 让循环优雅收尾而不是干等到超时 —— 这类「服务端主动静默」不是客户端故障。
/// </summary>
private async Task<SoloDecisionRequest?> TryHandleDecisionAsync(SoloDecisionRequest decision)
{
var payload = decision.ReadPayload<ActionTypePayload>();
return payload is not null
&& (payload.EnemyOptions.Count > 0 || payload.Enemys.Count > 0);
try
{
return await HandleDecisionAsync(decision);
}
catch (TimeoutException exception)
{
SoloTrace.Step($"no further decision from server: {exception.Message}");
return null;
}
}
private async Task SubmitBestMoveAsync(SoloDecisionRequest decision)
{
var state = _store.Snapshot ?? throw new InvalidOperationException("Missing state before movement.");
var map = state.Map ?? throw new InvalidOperationException("Missing map before movement.");
var player = state.Characters.First(character => character.Guid == state.PlayerGuid);
var grids = map.Grids.ToDictionary(grid => grid.Id);
var enemies = state.Characters
.Where(character => !character.IsPlayer && !character.IsEliminated)
.Where(character => grids.ContainsKey(character.GridId))
.Select(character => grids[character.GridId])
.ToArray();
var allowed = decision.ReadPayload<TargetGridPayload>()?.GridIds ?? [];
var destination = allowed
.Where(gridId => gridId != player.GridId && grids.ContainsKey(gridId))
.Select(gridId => grids[gridId])
.OrderBy(grid => enemies.Length == 0 ? 0 : enemies.Min(enemy => Manhattan(grid, enemy)))
.FirstOrDefault();
/// <summary>核心路径:真实移动 + 真实普攻(按服务器给的 Targets)+ 拒绝恢复。</summary>
private bool IsCorePathSatisfied() => _moves > 0 && _attackSubmitted && _rejectionRecovered;
if (destination is null)
/// <summary>
/// 新回合清除「上一回合学到的不可行动作」:服务器每回合重新给一次机会,
/// 上一回合的攻击/移动被取消不代表这一回合也不行。
/// </summary>
private void ResetTurnGuards()
{
var round = _store.Snapshot?.Round ?? -1;
if (round == _lastRound)
{
await _store.SubmitDecisionAsync(new { cancelled = true });
return;
}
var originGridId = player.GridId;
await _store.SubmitDecisionAsync(new { gridId = destination.Id });
await WaitUntilAsync(
() => _store.Snapshot?.Characters
.FirstOrDefault(character => character.Guid == state.PlayerGuid)?.GridId != originGridId,
10.0);
_moves++;
_lastRound = round;
_attackCancelled = false;
_moveCancelled = false;
}
private async Task WaitForDecisionAsync(string kind, double timeoutSeconds)
private async Task<SoloDecisionRequest?> HandleDecisionAsync(SoloDecisionRequest decision)
{
await WaitUntilAsync(() => _store.PendingDecision?.Kind == kind, timeoutSeconds);
}
private async Task WaitUntilAsync(Func<bool> predicate, double timeoutSeconds)
{
var startedAt = Time.GetTicksMsec();
var timeoutMs = timeoutSeconds * 1_000.0;
while (!predicate())
switch (decision.Kind)
{
if (Time.GetTicksMsec() - startedAt >= timeoutMs)
case SoloDecisionKinds.ActionType:
return await HandleActionTypeAsync(decision);
case SoloDecisionKinds.TargetGrid:
return await HandleTargetGridAsync(decision);
case SoloDecisionKinds.Targets:
{
throw new TimeoutException($"Timed out after {timeoutSeconds:0.#} seconds.");
var target = decision.ReadPayload<TargetsPayload>()?.Targets.FirstOrDefault()
?? throw new InvalidOperationException("Attack request contained no legal target.");
_attackSubmitted = true;
return await _driver.SubmitAndAwaitNextAsync(
decision,
new { targetGuids = new[] { target.Guid } },
DecisionTimeoutSeconds);
}
await ToSignal(GetTree().CreateTimer(0.05), SceneTreeTimer.SignalName.Timeout);
case SoloDecisionKinds.Continue:
_continueObserved = true;
return await _driver.SubmitAndAwaitNextAsync(
decision,
new { cancelled = false },
DecisionTimeoutSeconds);
case SoloDecisionKinds.Inquiry:
return await _driver.SubmitAndAwaitNextAsync(
decision,
BuildInquiryReply(decision.ReadPayload<InquiryPayload>()),
DecisionTimeoutSeconds);
default:
// Skill / Item / TargetGrids:本竖切不主动使用,按取消处理,让服务器回到行动菜单。
return await _driver.SubmitAndAwaitNextAsync(decision, new { cancelled = true }, DecisionTimeoutSeconds);
}
}
private static int Manhattan(SoloGridDto left, SoloGridDto right)
private async Task<SoloDecisionRequest?> HandleActionTypeAsync(SoloDecisionRequest decision)
{
return Math.Abs(left.X - right.X) + Math.Abs(left.Y - right.Y);
var payload = decision.ReadPayload<ActionTypePayload>();
// 与 BattleScreen 同一套判定:优先服务端的严格口径 attackTargets(ATR 内可达)。
var attackReachable = DecisionUiRules.IsNormalAttackReachable(payload) == true;
_preciseAttackSignal |= payload?.AttackTargets is not null;
if (attackReachable)
{
_attackTargetsOffered++;
}
var attackQuotaAvailable = DecisionUiRules.IsActionAvailable(payload?.Dp, "NormalAttack");
var canMove = !_moveCancelled && _moves < MaxMoves;
string actionType;
if (canMove && _moves == 0)
{
// 回归要求至少完成一次真实移动,这一步优先。
actionType = "Move";
}
else if (!_attackCancelled && attackReachable && attackQuotaAvailable)
{
// 服务器说「射程内有人」且配额允许 → 打。
// 这既是正常的对局行为,也是「精确口径 → 提交普攻 → 不被作废」这条门控的真实验证。
actionType = "NormalAttack";
}
else if (canMove)
{
// 打不着就继续朝敌人靠近,让下一回合有机会进入 ATR(否则门控永远验证不到)。
actionType = "Move";
}
else
{
actionType = "EndTurn";
}
if (actionType == "NormalAttack")
{
_attackAttempts++;
}
SoloTrace.Step(
$"payload kind=ActionType actorGrid={payload?.ActorGridId} atr={payload?.Atr} "
+ $"enemys={payload?.Enemys.Count} enemyOptions={payload?.EnemyOptions.Count} "
+ $"attackTargets={payload?.AttackTargets?.Count.ToString() ?? "null"} "
+ $"canNormalAttack={payload?.CanNormalAttack?.ToString() ?? "null"} "
+ $"reachable={attackReachable} choose={actionType}");
SoloTrace.Step($"submit actionType={actionType}");
var next = await _driver.SubmitAndAwaitNextAsync(decision, new { actionType }, DecisionTimeoutSeconds);
if (next is null)
{
SoloTrace.Step($"actionType={actionType} -> server dropped the decision");
return null;
}
SoloTrace.Step($"actionType={actionType} -> next kind={next.Kind}");
// 没有拒绝回执:行动被作废的唯一信号是「下一次又要 ActionType」。学到即收敛。
if (attackReachable && actionType == "NormalAttack" && next.Kind == SoloDecisionKinds.Targets)
{
// 服务端说可达 → 我们据此提交 → 真的进了选目标阶段:门控成立
_attackGateVerified = true;
}
if (next.Kind == SoloDecisionKinds.ActionType)
{
if (actionType == "NormalAttack")
{
_attackCancelled = true;
_attackCancelledCount++;
}
else if (actionType == "Move")
{
_moveCancelled = true;
}
}
return next;
}
private async Task<SoloDecisionRequest?> HandleTargetGridAsync(SoloDecisionRequest decision)
{
if (!_rejectionRecovered)
{
// 阶段 B 的拒绝恢复:故意提交服务器不可能认下的格子,确认之后还能回到可提交状态。
_rejectionRecovered = true;
return await _driver.SubmitAndAwaitNextAsync(decision, new { gridId = long.MaxValue }, ShortTimeoutSeconds);
}
var destination = _driver.PickMoveGrid(decision, _store.Snapshot);
if (destination is null)
{
_moveCancelled = true;
return await _driver.SubmitAndAwaitNextAsync(decision, new { cancelled = true }, DecisionTimeoutSeconds);
}
var originGridId = _driver.CurrentPlayerGridId();
var next = await _driver.SubmitAndAwaitNextAsync(
decision,
new { gridId = destination.Value },
DecisionTimeoutSeconds);
if (next is null)
{
return null;
}
// 下一次决策是服务器在应用移动后(先 FlushState 再下发)发出的,快照顺序在协议里保证,
// 因此这里读到的位置就是权威结果。
if (_driver.CurrentPlayerGridId() == originGridId)
{
_moveCancelled = true;
}
else
{
_moves++;
}
return next;
}
private static object BuildInquiryReply(InquiryPayload? payload)
{
if (payload is null || payload.CanCancel)
{
return new { cancel = true };
}
if (!string.IsNullOrEmpty(payload.DefaultChoice))
{
return new { choices = new[] { payload.DefaultChoice } };
}
if (payload.Choices.Count > 0)
{
return new { choices = new[] { payload.Choices[0].Key } };
}
return new { number = payload.DefaultNumber };
}
}