221 lines
10 KiB
C#
221 lines
10 KiB
C#
using System.Collections.Immutable;
|
|
using SVSim.BattleNode.Bridge;
|
|
using SVSim.BattleNode.Protocol;
|
|
using SVSim.BattleNode.Protocol.Bodies;
|
|
|
|
namespace SVSim.BattleNode.Lifecycle;
|
|
|
|
/// <summary>
|
|
/// v1 hand-rolled scripted opponent. Static frame builders for the five lifecycle uris
|
|
/// (Matched / BattleStart / Deal / Swap response / Ready) plus a trivial opponent TurnStart
|
|
/// the dispatch pushes after the player's TurnEnd. The values are templated from the TK2
|
|
/// captures at <c>data_dumps/captures/battle-traffic_tk2_regular.ndjson</c> — anything
|
|
/// hardcoded here came from a real prod frame, with names + provenance in
|
|
/// <see cref="ScriptedProfiles"/>. The player-half of Matched/BattleStart now reads from
|
|
/// <see cref="MatchContext"/> instead of <see cref="ScriptedProfiles"/>.
|
|
/// </summary>
|
|
public static class ScriptedLifecycle
|
|
{
|
|
/// <summary>
|
|
/// Viewer id we present as the opponent on every scripted push. Out-of-range vs. real
|
|
/// viewer ids so it can't collide with a real account in the auth pipeline.
|
|
/// </summary>
|
|
public const long FakeOpponentViewerId = 999_999_999L;
|
|
|
|
public static MsgEnvelope BuildMatched(
|
|
MatchContext selfCtx, MatchContext oppoCtx,
|
|
long selfViewerId, long oppoViewerId,
|
|
string battleId, long seed) =>
|
|
EnvelopeForPush(NetworkBattleUri.Matched,
|
|
new MatchedBody(
|
|
SelfInfo: new MatchedSelfInfo(
|
|
CountryCode: selfCtx.CountryCode,
|
|
UserName: selfCtx.UserName,
|
|
SleeveId: selfCtx.SleeveId,
|
|
EmblemId: selfCtx.EmblemId,
|
|
DegreeId: selfCtx.DegreeId,
|
|
FieldId: selfCtx.FieldId,
|
|
IsOfficial: selfCtx.IsOfficial,
|
|
OppoId: oppoViewerId,
|
|
Seed: seed),
|
|
OppoInfo: new MatchedOppoInfo(
|
|
CountryCode: oppoCtx.CountryCode,
|
|
UserName: oppoCtx.UserName,
|
|
SleeveId: oppoCtx.SleeveId,
|
|
EmblemId: oppoCtx.EmblemId,
|
|
DegreeId: oppoCtx.DegreeId,
|
|
FieldId: oppoCtx.FieldId,
|
|
IsOfficial: oppoCtx.IsOfficial,
|
|
OppoId: selfViewerId,
|
|
Seed: seed,
|
|
OppoDeckCount: oppoCtx.SelfDeckCardIds.Count),
|
|
SelfDeck: BuildPlayerDeck(selfCtx.SelfDeckCardIds)),
|
|
bid: battleId);
|
|
|
|
public static MsgEnvelope BuildBattleStart(
|
|
MatchContext selfCtx, MatchContext oppoCtx, long selfViewerId, int turnState) =>
|
|
EnvelopeForPush(NetworkBattleUri.BattleStart,
|
|
new BattleStartBody(
|
|
TurnState: turnState, // 0 = this side goes first, 1 = second. Caller decides.
|
|
BattleType: selfCtx.BattleType,
|
|
SelfInfo: new BattleStartSelfInfo(
|
|
Rank: ScriptedProfiles.PlayerRank,
|
|
BattlePoint: ScriptedProfiles.PlayerBattlePoint,
|
|
ClassId: selfCtx.ClassId,
|
|
CharaId: selfCtx.CharaId,
|
|
CardMasterName: selfCtx.CardMasterName),
|
|
OppoInfo: new BattleStartOppoInfo(
|
|
// Rank/IsMasterRank/BattlePoint/MasterPoint stay hardcoded —
|
|
// PvP rank tracking is deferred (per spec § Out of scope).
|
|
Rank: "1",
|
|
IsMasterRank: "0",
|
|
BattlePoint: 0,
|
|
MasterPoint: "0",
|
|
ClassId: oppoCtx.ClassId,
|
|
CharaId: oppoCtx.CharaId,
|
|
CardMasterName: oppoCtx.CardMasterName)));
|
|
|
|
public static MsgEnvelope BuildDeal() =>
|
|
EnvelopeForPush(NetworkBattleUri.Deal,
|
|
new DealBody(
|
|
Self: new[] { new PosIdx(0, 1), new PosIdx(1, 2), new PosIdx(2, 3) },
|
|
Oppo: new[] { new PosIdx(0, 1), new PosIdx(1, 2), new PosIdx(2, 3) }));
|
|
|
|
/// <summary>
|
|
/// Initial 3-card hand idxs from <see cref="BuildDeal"/>. Each position in this array
|
|
/// is one card; the value is the card's deck idx. <see cref="ImmutableArray{T}"/> enforces
|
|
/// the "read-only constant" contract at the type level — callers cannot mutate it, even
|
|
/// accidentally (the prior <c>long[]</c> allowed in-place modification by anyone with the
|
|
/// field reference).
|
|
/// </summary>
|
|
private static readonly ImmutableArray<long> InitialHand = ImmutableArray.Create<long>(1, 2, 3);
|
|
|
|
/// <summary>
|
|
/// Compute the player's hand after a mulligan. For every idx in <paramref name="swapIndices"/>
|
|
/// that is currently in the hand, replace it with the next unused deck idx (starting at 4,
|
|
/// since 1..3 were dealt). Positions of kept cards are preserved.
|
|
/// </summary>
|
|
public static long[] ComputeHandAfterSwap(IReadOnlyList<long> swapIndices)
|
|
{
|
|
var hand = InitialHand.ToArray();
|
|
var nextDeckIdx = 4L;
|
|
for (var pos = 0; pos < hand.Length; pos++)
|
|
{
|
|
if (swapIndices.Contains(hand[pos]))
|
|
{
|
|
hand[pos] = nextDeckIdx++;
|
|
}
|
|
}
|
|
return hand;
|
|
}
|
|
|
|
public static MsgEnvelope BuildSwapResponse(IReadOnlyList<long> hand) =>
|
|
EnvelopeForPush(NetworkBattleUri.Swap,
|
|
new SwapResponseBody(Self: BuildPosIdxList(hand)));
|
|
|
|
/// <summary>Non-interactive opponent (scripted single / AINetwork): oppo is the
|
|
/// placeholder <see cref="InitialHand"/> (v1 behaviour).</summary>
|
|
public static MsgEnvelope BuildReady(IReadOnlyList<long> hand) => BuildReady(hand, InitialHand);
|
|
|
|
/// <summary>Both hands known (the mulligan barrier supplies the opponent's
|
|
/// post-mulligan hand).</summary>
|
|
public static MsgEnvelope BuildReady(IReadOnlyList<long> selfHand, IReadOnlyList<long> oppoHand) =>
|
|
EnvelopeForPush(NetworkBattleUri.Ready,
|
|
new ReadyBody(
|
|
Self: BuildPosIdxList(selfHand),
|
|
Oppo: BuildPosIdxList(oppoHand),
|
|
IdxChangeSeed: ScriptedProfiles.ReadyIdxChangeSeed,
|
|
Spin: ScriptedProfiles.ReadySpin));
|
|
|
|
// --- Client-shaped emissions used by ScriptedBotParticipant so the session brokers
|
|
// the bot through the same handshake arms as a human. Bodies for the parameterless
|
|
// handshake frames are ignored by the session (it reads from.Context / phase); only
|
|
// Swap's idxList is consumed (empty = keep the dealt hand).
|
|
|
|
public static MsgEnvelope BuildClientInitNetwork() => ClientFrame(NetworkBattleUri.InitNetwork, EmitCategory.General);
|
|
public static MsgEnvelope BuildClientInitBattle() => ClientFrame(NetworkBattleUri.InitBattle, EmitCategory.General);
|
|
public static MsgEnvelope BuildClientLoaded() => ClientFrame(NetworkBattleUri.Loaded, EmitCategory.General);
|
|
|
|
public static MsgEnvelope BuildClientSwap() =>
|
|
new(NetworkBattleUri.Swap,
|
|
ViewerId: FakeOpponentViewerId,
|
|
Uuid: WireConstants.ServerUuid,
|
|
Bid: null,
|
|
Try: 0,
|
|
Cat: EmitCategory.Battle,
|
|
PubSeq: null,
|
|
PlaySeq: null,
|
|
Body: new RawBody(new Dictionary<string, object?> { ["idxList"] = new List<object?>() }));
|
|
|
|
private static MsgEnvelope ClientFrame(NetworkBattleUri uri, EmitCategory cat) =>
|
|
new(uri,
|
|
ViewerId: FakeOpponentViewerId,
|
|
Uuid: WireConstants.ServerUuid,
|
|
Bid: null,
|
|
Try: 0,
|
|
Cat: cat,
|
|
PubSeq: null,
|
|
PlaySeq: null,
|
|
Body: new ResultCodeOnlyBody());
|
|
|
|
/// <summary>
|
|
/// First half of the v1.1 scripted opponent turn cycle: pushed after the player's
|
|
/// TurnEnd, transitions the client into "Opponent's turn…" state. Paired with
|
|
/// <see cref="BuildOpponentTurnEnd"/>, which immediately follows and hands control
|
|
/// back to the player.
|
|
/// </summary>
|
|
public static MsgEnvelope BuildOpponentTurnStart() =>
|
|
EnvelopeForPush(NetworkBattleUri.TurnStart,
|
|
new OpponentTurnStartBody(Spin: ScriptedProfiles.OpponentTurnStartSpin));
|
|
|
|
/// <summary>
|
|
/// Server-pushed TurnEnd transition that closes the opponent's turn and hands control
|
|
/// back to the player. Paired with <see cref="BuildOpponentTurnStart"/> in the v1.1 loop.
|
|
/// Wire shape from prod capture battle-traffic_tk2_regular.ndjson L18:
|
|
/// <c>{"uri":"TurnEnd","turnState":0,"resultCode":1,"playSeq":N}</c>.
|
|
/// </summary>
|
|
public static MsgEnvelope BuildOpponentTurnEnd() =>
|
|
EnvelopeForPush(NetworkBattleUri.TurnEnd, new TurnEndBody(TurnState: 0));
|
|
|
|
/// <summary>
|
|
/// Server-pushed Judge frame that follows the opponent's TurnEnd and unblocks the
|
|
/// client's <c>JudgeOperation</c> → <c>ControlTurnStartPlayer</c>, transitioning to the
|
|
/// player's next turn. Without this frame the client hangs on "Opponent's turn…" —
|
|
/// see <c>data_dumps/captures/battle-traffic.ndjson</c> line 14 (client emits its own
|
|
/// Judge then waits forever).
|
|
/// </summary>
|
|
public static MsgEnvelope BuildOpponentJudge() =>
|
|
EnvelopeForPush(NetworkBattleUri.Judge, new JudgeBody(Spin: ScriptedProfiles.OpponentJudgeSpin));
|
|
|
|
private static IReadOnlyList<PosIdx> BuildPosIdxList(IReadOnlyList<long> hand)
|
|
{
|
|
var list = new List<PosIdx>(hand.Count);
|
|
for (var pos = 0; pos < hand.Count; pos++)
|
|
{
|
|
list.Add(new PosIdx(Pos: pos, Idx: (int)hand[pos]));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
private static IReadOnlyList<DeckCardRef> BuildPlayerDeck(IReadOnlyList<long> cardIds)
|
|
{
|
|
var deck = new List<DeckCardRef>(cardIds.Count);
|
|
for (var i = 0; i < cardIds.Count; i++)
|
|
{
|
|
deck.Add(new DeckCardRef(Idx: i + 1, CardId: cardIds[i]));
|
|
}
|
|
return deck;
|
|
}
|
|
|
|
private static MsgEnvelope EnvelopeForPush(NetworkBattleUri uri, IMsgBody body, string? bid = null) =>
|
|
new(uri,
|
|
ViewerId: FakeOpponentViewerId,
|
|
Uuid: WireConstants.ServerUuid,
|
|
Bid: bid,
|
|
Try: 0,
|
|
Cat: EmitCategory.Battle,
|
|
PubSeq: null,
|
|
PlaySeq: null,
|
|
Body: body);
|
|
}
|