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

feat(pack): gacha-point catalog read (legendaries + leader cards)

Browse Source
This commit is contained in:
gamer147
2026-05-28 23:11:48 -04:00
parent ef1af8259e
commit 66c0b1c951
4 changed files with 345 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
SVSim.EmulatedEntrypoint/Program.cs
View File

@@ -81,6 +81,7 @@ public class Program
builder.Services.AddScoped<SVSim.Database.Services.IGameConfigService, GameConfigService>();
builder.Services.AddScoped<ICardPoolProvider, DbCardPoolProvider>();
builder.Services.AddScoped<PackOpenService>();
builder.Services.AddScoped<IGachaPointService, GachaPointService>();
builder.Services.AddScoped<ICardAcquisitionService, CardAcquisitionService>();
builder.Services.AddScoped<RewardGrantService>();
builder.Services.AddScoped<SVSim.Database.Repositories.BattlePass.IBattlePassRepository,

121
SVSim.EmulatedEntrypoint/Services/GachaPointService.cs Normal file
View File

@@ -0,0 +1,121 @@
using Microsoft.EntityFrameworkCore;
using SVSim.Database;
using SVSim.Database.Enums;
using SVSim.Database.Models;
using SVSim.Database.Services;
using SVSim.EmulatedEntrypoint.Models.Dtos;
namespace SVSim.EmulatedEntrypoint.Services;
public sealed class GachaPointService : IGachaPointService
{
private readonly SVSimDbContext _db;
private readonly ICardPoolProvider _pools;
private readonly RewardGrantService _grants;
public GachaPointService(SVSimDbContext db, ICardPoolProvider pools, RewardGrantService grants)
{
_db = db;
_pools = pools;
_grants = grants;
}
public async Task<IReadOnlyList<GachaPointRewardDto>> GetRewardsAsync(int packId, long viewerId)
{
var pack = await _db.Packs.FirstOrDefaultAsync(p => p.Id == packId);
if (pack?.GachaPointConfig is null) return Array.Empty<GachaPointRewardDto>();
var pool = _pools.GetPool(pack);
var receivedCardIds = (await _db.Viewers
.Where(v => v.Id == viewerId)
.SelectMany(v => v.GachaPointReceived)
.Where(r => r.PackId == packId)
.Select(r => r.CardId)
.ToListAsync()).ToHashSet();
var legendaryCardIds = pool
.Where(c => c.Rarity == Rarity.Legendary && !c.IsFoil)
.Select(c => c.Id)
.ToHashSet();
// Pull both cosmetic types in one trip. Group by card_id for O(1) lookup below.
var cosmeticsByCard = await _db.CardCosmeticRewards
.Where(r => legendaryCardIds.Contains(r.CardId)
&& (r.Type == CosmeticType.Emblem || r.Type == CosmeticType.Skin))
.ToListAsync();
var cosmeticLookup = cosmeticsByCard
.GroupBy(r => r.CardId)
.ToDictionary(g => g.Key, g => g.ToList());
var standard = new List<GachaPointRewardDto>();
var leader = new List<GachaPointRewardDto>();
foreach (var card in pool
.Where(c => c.Rarity == Rarity.Legendary && !c.IsFoil)
.OrderBy(c => c.Class?.Id ?? 0).ThenBy(c => c.Id))
{
if (!cosmeticLookup.TryGetValue(card.Id, out var cosmetics)) continue;
var emblem = cosmetics.FirstOrDefault(c => c.Type == CosmeticType.Emblem);
var skin = cosmetics.FirstOrDefault(c => c.Type == CosmeticType.Skin);
if (emblem is null) continue; // every gacha-point entry has an emblem
var classId = (card.Class?.Id ?? 0).ToString();
var isReceived = receivedCardIds.Contains(card.Id);
if (skin is null)
{
standard.Add(new GachaPointRewardDto
{
ClassId = classId, CardId = card.Id, IsReceived = isReceived,
RewardList =
{
new GachaPointRewardDetailEntry
{
RewardType = (int)UserGoodsType.Emblem,
RewardDetailId = emblem.CosmeticId,
RewardNumber = 1,
},
},
});
}
else
{
// Leader card — 3 entries in capture order: Sleeve/Card-cosmetic (type 6),
// Skin (type 10), Emblem (type 7). The reward_type=6 entry's detail id is the
// card_id itself, mirroring the prod capture exactly.
leader.Add(new GachaPointRewardDto
{
ClassId = classId, CardId = card.Id, IsReceived = isReceived,
RewardList =
{
new GachaPointRewardDetailEntry
{
RewardType = (int)UserGoodsType.Sleeve, RewardDetailId = card.Id, RewardNumber = 1,
},
new GachaPointRewardDetailEntry
{
RewardType = (int)UserGoodsType.Skin,
RewardDetailId = skin.CosmeticId, RewardNumber = 1,
},
new GachaPointRewardDetailEntry
{
RewardType = (int)UserGoodsType.Emblem,
RewardDetailId = emblem.CosmeticId, RewardNumber = 1,
},
},
});
}
}
// Standard first, then leader — matches the prod capture order for pack 10008.
standard.AddRange(leader);
return standard;
}
public void Accrue(Viewer viewer, PackConfigEntry pack, PackChildGachaEntry child, int packNumber)
=> throw new NotImplementedException();
public Task<ExchangeOutcome> TryExchangeAsync(Viewer viewer, int packId, long cardId)
=> throw new NotImplementedException();
}

37
SVSim.EmulatedEntrypoint/Services/IGachaPointService.cs Normal file
View File

@@ -0,0 +1,37 @@
using SVSim.Database.Models;
using SVSim.EmulatedEntrypoint.Models.Dtos;
namespace SVSim.EmulatedEntrypoint.Services;
public interface IGachaPointService
{
/// <summary>
/// Build the gacha-point exchange catalog for one pack, with per-viewer is_received
/// resolved. Returns an empty list if the pack has no gacha-point config or no eligible
/// cards in its pool — callers should treat the empty result as a valid response, not
/// an error. Order: standard legendaries first (class_id ASC, card_id ASC), then leader
/// cards (class_id ASC, card_id ASC).
/// </summary>
Task<IReadOnlyList<GachaPointRewardDto>> GetRewardsAsync(int packId, long viewerId);
/// <summary>
/// Increment the viewer's balance for <paramref name="pack"/> by
/// <c>child.OverrideIncreaseGachaPoint ?? pack.GachaPointConfig.IncreaseGachaPoint</c>
/// times <paramref name="packNumber"/>. No-op when the pack lacks a GachaPointConfig.
/// Caller is responsible for SaveChangesAsync.
/// </summary>
void Accrue(Viewer viewer, PackConfigEntry pack, PackChildGachaEntry child, int packNumber);
/// <summary>
/// Validate + execute an exchange. Returns the grant outcome on success (reward_list
/// entries the controller will return in <see cref="Dtos.Responses.Pack.ExchangeGachaPointResponse"/>),
/// or a failure result describing why. Mutates the in-memory graph; caller saves.
/// </summary>
Task<ExchangeOutcome> TryExchangeAsync(Viewer viewer, int packId, long cardId);
}
public sealed record ExchangeOutcome(bool Success, string? Error, IReadOnlyList<RewardListEntry> RewardList)
{
public static ExchangeOutcome Fail(string error) => new(false, error, Array.Empty<RewardListEntry>());
public static ExchangeOutcome Ok(IReadOnlyList<RewardListEntry> rewards) => new(true, null, rewards);
}

186
SVSim.UnitTests/Services/GachaPointServiceTests.cs Normal file
View File

@@ -0,0 +1,186 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using NUnit.Framework;
using SVSim.Database;
using SVSim.Database.Enums;
using SVSim.Database.Models;
using SVSim.EmulatedEntrypoint.Services;
using SVSim.UnitTests.Infrastructure;
namespace SVSim.UnitTests.Services;
public class GachaPointServiceTests
{
[Test]
public async Task GetRewards_returns_empty_when_pack_has_no_gacha_point_config()
{
using var factory = new SVSimTestFactory();
long viewerId = await factory.SeedViewerAsync();
using var scope = factory.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
db.Packs.Add(new PackConfigEntry
{
Id = 10001, BasePackId = 10001, PackCategory = PackCategory.LegendCardPack,
CommenceDate = DateTime.UtcNow.AddDays(-1), CompleteDate = DateTime.UtcNow.AddDays(30),
GachaPointConfig = null,
});
await db.SaveChangesAsync();
var svc = scope.ServiceProvider.GetRequiredService<IGachaPointService>();
var result = await svc.GetRewardsAsync(10001, viewerId);
Assert.That(result, Is.Empty);
}
[Test]
public async Task GetRewards_emits_standard_legendaries_with_emblem_reward()
{
using var factory = new SVSimTestFactory();
long viewerId = await factory.SeedViewerAsync();
using var scope = factory.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
// Seed: a card set, two legendary cards in it (class 0/neutral and class 1/forest),
// and a bronze card to confirm the rarity filter. Neutral cards have Class = null
// (per ShadowverseCardEntry.Class XML doc); Forestcraft (id=1) is already seeded by
// the ReferenceDataImporter, so we look it up rather than re-insert.
var classForest = await db.Classes.FirstAsync(c => c.Id == 1);
var set = new ShadowverseCardSetEntry { Id = 10008, IsInRotation = true };
db.CardSets.Add(set);
var legNeutral = new ShadowverseCardEntry
{
Id = 108041010, Name = "leg-neutral", Rarity = Rarity.Legendary,
Class = null, IsFoil = false,
};
var legForest = new ShadowverseCardEntry
{
Id = 108141010, Name = "leg-forest", Rarity = Rarity.Legendary,
Class = classForest, IsFoil = false,
};
var bronze = new ShadowverseCardEntry
{
Id = 108041020, Name = "bronze-neutral", Rarity = Rarity.Bronze,
Class = null, IsFoil = false,
};
set.Cards.AddRange(new[] { legNeutral, legForest, bronze });
db.CardCosmeticRewards.AddRange(
new CardCosmeticReward { CardId = 108041010, Type = CosmeticType.Emblem, CosmeticId = 1080410100 },
new CardCosmeticReward { CardId = 108141010, Type = CosmeticType.Emblem, CosmeticId = 1081410100 });
db.Packs.Add(new PackConfigEntry
{
Id = 10008, BasePackId = 10008, PackCategory = PackCategory.LegendCardPack,
CommenceDate = DateTime.UtcNow.AddDays(-1), CompleteDate = DateTime.UtcNow.AddDays(30),
GachaPointConfig = new PackGachaPointConfig { ExchangeablePoint = 400, IncreaseGachaPoint = 1 },
});
await db.SaveChangesAsync();
var svc = scope.ServiceProvider.GetRequiredService<IGachaPointService>();
var result = await svc.GetRewardsAsync(10008, viewerId);
Assert.That(result, Has.Count.EqualTo(2));
var first = result[0];
Assert.That(first.ClassId, Is.EqualTo("0"));
Assert.That(first.CardId, Is.EqualTo(108041010));
Assert.That(first.IsReceived, Is.False);
Assert.That(first.RewardList, Has.Count.EqualTo(1));
Assert.That(first.RewardList[0].RewardType, Is.EqualTo(7)); // Emblem
Assert.That(first.RewardList[0].RewardDetailId, Is.EqualTo(1080410100));
Assert.That(first.RewardList[0].RewardNumber, Is.EqualTo(1));
}
[Test]
public async Task GetRewards_emits_leader_cards_with_three_reward_entries()
{
using var factory = new SVSimTestFactory();
long viewerId = await factory.SeedViewerAsync();
using var scope = factory.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
var classForest = await db.Classes.FirstAsync(c => c.Id == 1);
var set = new ShadowverseCardSetEntry { Id = 10008, IsInRotation = true };
db.CardSets.Add(set);
// Leader card in pool — identified by presence of a Type=Skin cosmetic reward.
var leader = new ShadowverseCardEntry
{
Id = 704141010, Name = "leader-forest", Rarity = Rarity.Legendary,
Class = classForest, IsFoil = false,
};
set.Cards.Add(leader);
db.CardCosmeticRewards.AddRange(
new CardCosmeticReward { CardId = 704141010, Type = CosmeticType.Skin, CosmeticId = 401 },
new CardCosmeticReward { CardId = 704141010, Type = CosmeticType.Emblem, CosmeticId = 704141010 });
db.Packs.Add(new PackConfigEntry
{
Id = 10008, BasePackId = 10008, PackCategory = PackCategory.LegendCardPack,
CommenceDate = DateTime.UtcNow.AddDays(-1), CompleteDate = DateTime.UtcNow.AddDays(30),
GachaPointConfig = new PackGachaPointConfig { ExchangeablePoint = 400, IncreaseGachaPoint = 1 },
});
await db.SaveChangesAsync();
var svc = scope.ServiceProvider.GetRequiredService<IGachaPointService>();
var result = await svc.GetRewardsAsync(10008, viewerId);
Assert.That(result, Has.Count.EqualTo(1));
var leaderEntry = result[0];
Assert.That(leaderEntry.CardId, Is.EqualTo(704141010));
Assert.That(leaderEntry.RewardList, Has.Count.EqualTo(3));
// Order verified against prod capture: type=6 (Sleeve in enum, "Card cosmetic" in this
// context), type=10 (Skin), type=7 (Emblem).
Assert.That(leaderEntry.RewardList[0].RewardType, Is.EqualTo(6));
Assert.That(leaderEntry.RewardList[0].RewardDetailId, Is.EqualTo(704141010));
Assert.That(leaderEntry.RewardList[1].RewardType, Is.EqualTo(10));
Assert.That(leaderEntry.RewardList[1].RewardDetailId, Is.EqualTo(401));
Assert.That(leaderEntry.RewardList[2].RewardType, Is.EqualTo(7));
Assert.That(leaderEntry.RewardList[2].RewardDetailId, Is.EqualTo(704141010));
}
[Test]
public async Task GetRewards_marks_already_received_cards()
{
using var factory = new SVSimTestFactory();
long viewerId = await factory.SeedViewerAsync();
using var scope = factory.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
var set = new ShadowverseCardSetEntry { Id = 10008, IsInRotation = true };
db.CardSets.Add(set);
var leg = new ShadowverseCardEntry
{
Id = 108041010, Name = "leg", Rarity = Rarity.Legendary,
Class = null, IsFoil = false,
};
set.Cards.Add(leg);
db.CardCosmeticRewards.Add(new CardCosmeticReward
{
CardId = 108041010, Type = CosmeticType.Emblem, CosmeticId = 1080410100,
});
db.Packs.Add(new PackConfigEntry
{
Id = 10008, BasePackId = 10008, PackCategory = PackCategory.LegendCardPack,
CommenceDate = DateTime.UtcNow.AddDays(-1), CompleteDate = DateTime.UtcNow.AddDays(30),
GachaPointConfig = new PackGachaPointConfig { ExchangeablePoint = 400, IncreaseGachaPoint = 1 },
});
var viewer = await db.Viewers.FirstAsync(v => v.Id == viewerId);
viewer.GachaPointReceived.Add(new ViewerGachaPointReceived
{
PackId = 10008, CardId = 108041010, ReceivedAt = DateTime.UtcNow,
});
await db.SaveChangesAsync();
var svc = scope.ServiceProvider.GetRequiredService<IGachaPointService>();
var result = await svc.GetRewardsAsync(10008, viewerId);
Assert.That(result, Has.Count.EqualTo(1));
Assert.That(result[0].IsReceived, Is.True);
}
}