462 lines
20 KiB
C#
462 lines
20 KiB
C#
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 _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
|
||
{
|
||
_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 _driver.WaitOrThrowAsync(() => _session.State == SessionState.Connected, 5.0);
|
||
await _store.StartGameAsync(new SoloStartOptions
|
||
{
|
||
CharacterCount = 2,
|
||
TeamMode = false,
|
||
TeamSize = 1,
|
||
MaxRound = 30,
|
||
MaxRespawnTimes = 0,
|
||
MaxScoreToWin = 0,
|
||
DecisionTimeoutSeconds = 30,
|
||
// 协议层确认服务端接收 requireContinue;本局是否真的下发 Continue 由服务器流程决定。
|
||
RequireContinue = true,
|
||
RoundDelayMs = 0,
|
||
DropItemsIntervalSeconds = 0,
|
||
Seed = 20260919
|
||
});
|
||
|
||
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.");
|
||
decision = await _driver.SubmitAndAwaitNextAsync(
|
||
decision,
|
||
new { characterGuid = character.Guid },
|
||
ShortTimeoutSeconds);
|
||
|
||
await _driver.WaitOrThrowAsync(
|
||
() => _store.Snapshot is { PlayerGuid.Length: > 0, Characters.Count: > 1, Map: not null },
|
||
ShortTimeoutSeconds);
|
||
await _driver.WaitOrThrowAsync(
|
||
() => GetTree().GetNodesInGroup("battle_unit").Count == _store.Snapshot!.Characters.Count,
|
||
5.0);
|
||
|
||
SoloTrace.Step($"character selected, entering decision loop");
|
||
|
||
// 用可空局部变量承载「下一轮要处理的决策」:服务器放弃决策时它会变成 null,循环随之收尾。
|
||
SoloDecisionRequest? current = decision;
|
||
var steps = 0;
|
||
var settling = 0;
|
||
var gateSettling = 0;
|
||
while (steps++ < MaxSteps)
|
||
{
|
||
if (Time.GetTicksMsec() >= _deadlineMs)
|
||
{
|
||
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 (!_attackSubmitted)
|
||
{
|
||
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 (_preciseAttackSignal && _attackCancelledCount > 0)
|
||
{
|
||
// 服务器下发了严格口径的 attackTargets,却仍有普攻被作废 ⇒ 该信号不可信
|
||
throw new InvalidOperationException(
|
||
$"Server advertised precise attackTargets but {_attackCancelledCount} normal attack(s) were cancelled.");
|
||
}
|
||
|
||
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();
|
||
GetTree().Quit(0);
|
||
}
|
||
catch (Exception exception)
|
||
{
|
||
// 先写 stderr(不带缓冲),保证即使后面清理步骤卡住、进程被强杀,失败原因也留得下来。
|
||
SoloTrace.Step($"SOLO_VERTICAL_FAILED {exception.Message}");
|
||
GD.PushError($"SOLO_VERTICAL_FAILED {exception.Message}");
|
||
await _session.DisconnectAsync();
|
||
GetTree().Quit(1);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 处理一条决策;服务器在等待期间不再下发新决策时返回 null(对局结束 / 托管),
|
||
/// 让循环优雅收尾而不是干等到超时 —— 这类「服务端主动静默」不是客户端故障。
|
||
/// </summary>
|
||
private async Task<SoloDecisionRequest?> TryHandleDecisionAsync(SoloDecisionRequest decision)
|
||
{
|
||
try
|
||
{
|
||
return await HandleDecisionAsync(decision);
|
||
}
|
||
catch (TimeoutException exception)
|
||
{
|
||
SoloTrace.Step($"no further decision from server: {exception.Message}");
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// <summary>核心路径:真实移动 + 真实普攻(按服务器给的 Targets)+ 拒绝恢复。</summary>
|
||
private bool IsCorePathSatisfied() => _moves > 0 && _attackSubmitted && _rejectionRecovered;
|
||
|
||
/// <summary>
|
||
/// 新回合清除「上一回合学到的不可行动作」:服务器每回合重新给一次机会,
|
||
/// 上一回合的攻击/移动被取消不代表这一回合也不行。
|
||
/// </summary>
|
||
private void ResetTurnGuards()
|
||
{
|
||
var round = _store.Snapshot?.Round ?? -1;
|
||
if (round == _lastRound)
|
||
{
|
||
return;
|
||
}
|
||
|
||
_lastRound = round;
|
||
_attackCancelled = false;
|
||
_moveCancelled = false;
|
||
}
|
||
|
||
private async Task<SoloDecisionRequest?> HandleDecisionAsync(SoloDecisionRequest decision)
|
||
{
|
||
switch (decision.Kind)
|
||
{
|
||
case SoloDecisionKinds.ActionType:
|
||
return await HandleActionTypeAsync(decision);
|
||
|
||
case SoloDecisionKinds.TargetGrid:
|
||
return await HandleTargetGridAsync(decision);
|
||
|
||
case SoloDecisionKinds.Targets:
|
||
{
|
||
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);
|
||
}
|
||
|
||
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 async Task<SoloDecisionRequest?> HandleActionTypeAsync(SoloDecisionRequest decision)
|
||
{
|
||
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 };
|
||
}
|
||
}
|