SVSim/SVSimServer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(arena-colosseum): playable bracket + rank-match promotion (phase 2)

Browse Source 
Closes 4 more arena-colosseum spec shapes (6/16 → 10/16): the dual-prefix
battle URLs (colosseum_battle/* and colosseum_rank_battle/*) for both
do_matching and per-match finish, plus the bracket-end /finish + /retire
pair on /arena_colosseum.

* ColosseumProgressionService: pure-logic decisions for win-threshold
  advancement, 3008 promotion trigger, and per-round reward bundles.
  Extends ColosseumRoundsConfig with FinishRewards/RetireRewards per
  round + a top-level ChampionRewards list.
* MatchContextBuilder.BuildForColosseumAsync: lifts the registered deck
  via IDeckRepository (NOT viewer-graph) per project_ef_nav_include_pitfall.
* ArenaColosseumBattleController: dual route prefixes off one controller
  via explicit absolute [HttpPost("/...")] routes — does NOT extend
  SVSimController's [Route("[controller]")]. Same pattern as FreeBattle.
  URL-vs-IsRankMatching mismatch returns 400 with a phase-mismatch error;
  no-deck triggers the standard 3001 matchmaking-illegal state. 3008
  flips run.IsRankMatching exactly once via the progression service.
* /arena_colosseum/finish + /retire share FinishResponse (rewards +
  reward_list + colosseum_status). Champion finish appends ChampionRewards
  and surfaces colosseum_status.is_champion = true. Both delete the run
  row after granting via IInventoryTransaction.GrantAsync.
* DI: ModePolicy entries for "colosseum_battle" and "colosseum_rank_battle".
* Tests: 8 progression-service unit tests (pure logic), 5 battle-controller
  HTTP tests, 5 bracket-terminate HTTP tests, 2 full-bracket E2E walks
  (champion path + retire mid-round). Full suite: 1331/1331.
This commit is contained in:
gamer147
2026-06-13 12:32:56 -04:00
parent 110867358c
commit cbee0f9a50
16 changed files with 1436 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
SVSim.EmulatedEntrypoint/Controllers/ArenaColosseumBattleController.cs Normal file
View File

@@ -0,0 +1,175 @@
using System.Text.Json;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SVSim.BattleNode.Bridge;
using SVSim.Database.Repositories.Viewer;
using SVSim.EmulatedEntrypoint.Constants;
using SVSim.EmulatedEntrypoint.Matching;
using SVSim.EmulatedEntrypoint.Models.Dtos.ArenaColosseum;
using SVSim.EmulatedEntrypoint.Security;
using SVSim.EmulatedEntrypoint.Security.SteamSessionAuthentication;
using SVSim.EmulatedEntrypoint.Services;
using SVSim.EmulatedEntrypoint.Services.ArenaColosseum;
namespace SVSim.EmulatedEntrypoint.Controllers;
/// <summary>
/// Per-match URLs for the Colosseum bracket — the dual <c>colosseum_battle/*</c> +
/// <c>colosseum_rank_battle/*</c> route family. Does NOT extend <see cref="SVSimController"/>'s
/// <c>[Route("[controller]")]</c> because we need explicit absolute routes for two prefixes
/// off one controller (same pattern as <see cref="FreeBattleController"/>).
/// <para>
/// The URL is the bracket-phase signal per do-matching.md §"server-side bidirectional
/// mapping"; <see cref="ViewerArenaColosseumRun.IsRankMatching"/> flips to true once the
/// node has signalled <c>matching_state == 3008</c> on a prior <c>do_matching</c>.
/// </para>
/// </summary>
[ApiController]
[Authorize(AuthenticationSchemes = SteamAuthenticationConstants.SchemeName)]
public sealed class ArenaColosseumBattleController : ControllerBase
{
/// <summary>Per FinishTaskBase.IsEffectiveErrorCode — code 3502 ("battle already finished")
/// is tolerated as a non-error retry, parsed the same as 1.</summary>
private const int BattleAlreadyFinishedResultCode = 3502;
private readonly IMatchContextBuilder _ctxBuilder;
private readonly IMatchingResolver _resolver;
private readonly IArenaColosseumRunRepository _runs;
private readonly IColosseumProgressionService _progression;
private readonly ILogger<ArenaColosseumBattleController> _log;
public ArenaColosseumBattleController(
IMatchContextBuilder ctxBuilder,
IMatchingResolver resolver,
IArenaColosseumRunRepository runs,
IColosseumProgressionService progression,
ILogger<ArenaColosseumBattleController> log)
{
_ctxBuilder = ctxBuilder;
_resolver = resolver;
_runs = runs;
_progression = progression;
_log = log;
}
private bool TryGetViewerId(out long viewerId)
{
viewerId = 0;
var claim = User.Claims.FirstOrDefault(c => c.Type == ShadowverseClaimTypes.ViewerIdClaim)?.Value;
return claim is not null && long.TryParse(claim, out viewerId);
}
[HttpPost("/colosseum_battle/do_matching")]
public Task<IActionResult> DoMatchingPreRank(
[FromBody] ColosseumDoMatchingRequestDto req, CancellationToken ct)
=> DoMatchingInternal(isRankUrl: false, req, ct);
[HttpPost("/colosseum_rank_battle/do_matching")]
public Task<IActionResult> DoMatchingPostRank(
[FromBody] ColosseumDoMatchingRequestDto req, CancellationToken ct)
=> DoMatchingInternal(isRankUrl: true, req, ct);
[HttpPost("/colosseum_battle/finish")]
public Task<IActionResult> FinishPreRank(
[FromBody] ColosseumBattleFinishRequestDto req, CancellationToken ct)
=> FinishInternal(isRankUrl: false, req, ct);
[HttpPost("/colosseum_rank_battle/finish")]
public Task<IActionResult> FinishPostRank(
[FromBody] ColosseumBattleFinishRequestDto req, CancellationToken ct)
=> FinishInternal(isRankUrl: true, req, ct);
private async Task<IActionResult> DoMatchingInternal(
bool isRankUrl, ColosseumDoMatchingRequestDto req, CancellationToken ct)
{
if (!TryGetViewerId(out var vid)) return Unauthorized();
var run = await _runs.GetByViewerIdAsync(vid);
if (run is null)
{
return BadRequest(new { error = "arena_colosseum_no_active_run" });
}
if (isRankUrl != run.IsRankMatching)
{
return BadRequest(new
{
error = "colosseum_url_phase_mismatch",
is_rank_matching = run.IsRankMatching,
requested_rank_url = isRankUrl,
});
}
MatchContext ctx;
try
{
ctx = await _ctxBuilder.BuildForColosseumAsync(vid);
}
catch (InvalidOperationException ex)
{
_log.LogWarning(ex,
"Colosseum BuildForColosseumAsync failed for viewer {Vid}; returning 3001.", vid);
return Ok(new Models.Dtos.FreeBattle.DoMatchingResponseDto
{
MatchingState = 3001,
NodeServerUrl = "",
});
}
var mode = isRankUrl ? "colosseum_rank_battle" : "colosseum_battle";
var resolution = await _resolver.ResolveAsync(mode, new BattlePlayer(vid, ctx), ct);
// Promotion: server flips IsRankMatching once on the 3008 signal. Subsequent battle
// URLs must use the rank prefix. (Plan §"matching_state == 3008 is the promotion trigger".)
if (_progression.ShouldPromoteToRankMatching(run, resolution.MatchingState))
{
run.IsRankMatching = true;
await _runs.UpsertAsync(run);
}
return Ok(new Models.Dtos.FreeBattle.DoMatchingResponseDto
{
MatchingState = resolution.MatchingState,
BattleId = resolution.BattleId,
NodeServerUrl = resolution.NodeServerUrl,
});
}
private async Task<IActionResult> FinishInternal(
bool isRankUrl, ColosseumBattleFinishRequestDto req, CancellationToken ct)
{
if (!TryGetViewerId(out var vid)) return Unauthorized();
var run = await _runs.GetByViewerIdAsync(vid);
if (run is null)
{
return BadRequest(new { error = "arena_colosseum_no_active_run" });
}
// Match-result tracking: 1 = win, 2 = loss, 0 = draw/abort. Record_list mirrors
// ColosseumTopTask.battle_results.result_list (1=win, 0=loss). is_retire surfaces
// as a non-counted result — does not advance the bracket.
bool counts = req.IsRetire == 0;
if (counts)
{
bool isWin = req.BattleResult == 1;
run.BattleCountThisRound += 1;
if (isWin) run.WinCount += 1;
else run.LossCount += 1;
var resultList = ParseIntList(run.ResultListJson);
resultList.Add(isWin ? 1 : 0);
run.ResultListJson = JsonSerializer.Serialize(resultList);
await _runs.UpsertAsync(run);
}
// result_code 3502 ("battle already finished") is the idempotent-retry tolerance per
// FinishTaskBase.IsEffectiveErrorCode. Server emits standard data; the translation
// middleware sets the wire result_code via data_headers from the response envelope.
return Ok(new ColosseumBattleFinishResponseDto { BattleResult = req.BattleResult });
}
private static List<int> ParseIntList(string json) =>
string.IsNullOrEmpty(json)
? new()
: JsonSerializer.Deserialize<List<int>>(json) ?? new();
}

104
SVSim.EmulatedEntrypoint/Controllers/ArenaColosseumController.cs
View File

@@ -12,6 +12,7 @@ using SVSim.EmulatedEntrypoint.Models.Dtos.Common.ArenaTwoPick;
using SVSim.EmulatedEntrypoint.Models.Dtos.Requests;
using SVSim.EmulatedEntrypoint.Models.Dtos.Requests.ArenaColosseum;
using SVSim.EmulatedEntrypoint.Models.Dtos.Responses.ArenaColosseum;
using SVSim.EmulatedEntrypoint.Services.ArenaColosseum;
namespace SVSim.EmulatedEntrypoint.Controllers;
@@ -28,17 +29,20 @@ public class ArenaColosseumController : SVSimController
private readonly IArenaColosseumRunRepository _runs;
private readonly IInventoryService _inventory;
private readonly IDeckRepository _decks;
private readonly IColosseumProgressionService _progression;
public ArenaColosseumController(
IGameConfigService config,
IArenaColosseumRunRepository runs,
IInventoryService inventory,
IDeckRepository decks)
IDeckRepository decks,
IColosseumProgressionService progression)
{
_config = config;
_runs = runs;
_inventory = inventory;
_decks = decks;
_progression = progression;
}
[HttpPost("top")]
@@ -247,6 +251,104 @@ public class ArenaColosseumController : SVSimController
return Ok(new { });
}
[HttpPost("finish")]
public async Task<IActionResult> Finish([FromBody] BaseRequest _)
{
if (!TryGetViewerId(out var vid)) return Unauthorized();
var run = await _runs.GetByViewerIdAsync(vid);
if (run is null) return BadRequest(new { error = "no_active_run" });
var rounds = _config.Get<ColosseumRoundsConfig>();
var decision = _progression.DecideAdvancement(run, rounds);
if (!decision.IsBracketEnd)
{
return BadRequest(new { error = "bracket_not_finished" });
}
run.IsChampion = decision.IsChampion;
var rewardEntries = _progression.BuildFinishRewards(run, rounds);
var (wireRewards, wireRewardList) = await GrantRewardsAsync(vid, rewardEntries);
await _runs.DeleteAsync(vid);
return Ok(new FinishResponse
{
Rewards = wireRewards,
RewardList = wireRewardList,
ColosseumStatus = new ColosseumOwnStatus
{
NowRoundId = run.RoundId,
IsChampion = decision.IsChampion ? true : null,
ColosseumName = decision.IsChampion ? rounds.Rounds.Count > 0
? _config.Get<ColosseumSeasonConfig>().ColosseumName
: null : null,
},
});
}
[HttpPost("retire")]
public async Task<IActionResult> Retire([FromBody] BaseRequest _)
{
if (!TryGetViewerId(out var vid)) return Unauthorized();
var run = await _runs.GetByViewerIdAsync(vid);
if (run is null) return BadRequest(new { error = "no_active_run" });
var rounds = _config.Get<ColosseumRoundsConfig>();
var rewardEntries = _progression.BuildRetireRewards(run, rounds);
var (wireRewards, wireRewardList) = await GrantRewardsAsync(vid, rewardEntries);
await _runs.DeleteAsync(vid);
return Ok(new FinishResponse
{
Rewards = wireRewards,
RewardList = wireRewardList,
ColosseumStatus = new ColosseumOwnStatus
{
NowRoundId = run.RoundId,
RestEntryNum = 0,
},
});
}
/// <summary>
/// Grant the bundle through <c>IInventoryTransaction.GrantAsync</c> per
/// <c>feedback_reward_grant_service</c> — single dispatch table for every UserGoodsType.
/// Returns the two wire forms (rich <c>rewards</c> receipt + wallet-delta <c>reward_list</c>).
/// </summary>
private async Task<(List<ColosseumReceivedReward>, List<RewardEntryDto>)> GrantRewardsAsync(
long viewerId, IReadOnlyList<ColosseumRoundsConfig.RewardEntry> bundle)
{
var receipts = new List<ColosseumReceivedReward>();
var deltas = new List<RewardEntryDto>();
if (bundle.Count == 0) return (receipts, deltas);
await using var tx = await _inventory.BeginAsync(viewerId);
foreach (var entry in bundle)
{
var granted = await tx.GrantAsync(entry.Type, entry.DetailId, entry.Count);
receipts.Add(new ColosseumReceivedReward
{
RewardNumber = entry.Count,
RewardType = (int)entry.Type,
RewardDetailId = entry.DetailId,
Name = entry.Name,
});
// GrantAsync returns one or more (RewardType, RewardId, RewardNum) tuples — the
// post-state-total semantics are owned by the inventory commit, which the wallet-delta
// reflection inherits via tx.CommitAsync below.
var first = granted.FirstOrDefault();
deltas.Add(new RewardEntryDto
{
RewardType = first is null ? (int)entry.Type : (int)first.RewardType,
RewardId = first?.RewardId ?? entry.DetailId,
RewardNum = first?.RewardNum ?? entry.Count,
});
}
await tx.CommitAsync();
return (receipts, deltas);
}
private static int ResolveServerRoundId(ColosseumSeasonConfig season) => 1;
private async Task<RewardEntryDto> DebitCrystalAsync(IInventoryTransaction tx, int cost)