314 lines
13 KiB
C#
314 lines
13 KiB
C#
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.EntityFrameworkCore.Storage;
|
|
using Microsoft.Extensions.Logging;
|
|
using SVSim.Database.Enums;
|
|
using SVSim.Database.Models;
|
|
using SVSim.Database.Models.Config;
|
|
|
|
namespace SVSim.Database.Services.Inventory;
|
|
|
|
internal sealed class InventoryTransaction : IInventoryTransaction
|
|
{
|
|
private readonly SVSimDbContext _db;
|
|
private readonly IDbContextTransaction _dbTx;
|
|
private readonly ILogger _log;
|
|
private readonly FreeplayConfig _freeplay;
|
|
private bool _committed;
|
|
|
|
public Viewer Viewer { get; }
|
|
public bool IsFreeplay => _freeplay.Enabled;
|
|
|
|
private readonly List<InventoryOp> _ops = new();
|
|
|
|
internal abstract record InventoryOp;
|
|
internal sealed record SpendOp(SpendCurrency Currency, long Cost, long PostState) : InventoryOp;
|
|
internal sealed record GrantOp(UserGoodsType Type, long DetailId, int Num, int PostStateOrCount, bool IsCascade) : InventoryOp;
|
|
|
|
public InventoryTransaction(
|
|
SVSimDbContext db,
|
|
IDbContextTransaction dbTx,
|
|
Viewer viewer,
|
|
FreeplayConfig freeplay,
|
|
ILogger log)
|
|
{
|
|
_db = db;
|
|
_dbTx = dbTx;
|
|
Viewer = viewer;
|
|
_freeplay = freeplay;
|
|
_log = log;
|
|
}
|
|
|
|
public Task<SpendResult> TrySpendAsync(SpendCurrency currency, long cost, CancellationToken ct = default)
|
|
{
|
|
ThrowIfCommitted();
|
|
if (cost < 0) cost = 0;
|
|
|
|
if (_freeplay.Enabled && currency != SpendCurrency.SpotPoint)
|
|
{
|
|
long amount = checked((long)_freeplay.CurrencyAmount);
|
|
_ops.Add(new SpendOp(currency, cost, amount));
|
|
return Task.FromResult(new SpendResult(SpendOutcome.Success, amount));
|
|
}
|
|
|
|
ulong current = ReadBalance(currency);
|
|
if (current < (ulong)cost)
|
|
return Task.FromResult(new SpendResult(SpendOutcome.Insufficient, (long)current));
|
|
|
|
ulong post = current - (ulong)cost;
|
|
WriteBalance(currency, post);
|
|
_ops.Add(new SpendOp(currency, cost, (long)post));
|
|
return Task.FromResult(new SpendResult(SpendOutcome.Success, (long)post));
|
|
}
|
|
|
|
private ulong ReadBalance(SpendCurrency c) => c switch
|
|
{
|
|
SpendCurrency.Crystal => Viewer.Currency.Crystals,
|
|
SpendCurrency.Rupee => Viewer.Currency.Rupees,
|
|
SpendCurrency.RedEther => Viewer.Currency.RedEther,
|
|
SpendCurrency.SpotPoint => Viewer.Currency.SpotPoints,
|
|
_ => throw new ArgumentOutOfRangeException(nameof(c)),
|
|
};
|
|
|
|
private void WriteBalance(SpendCurrency c, ulong value)
|
|
{
|
|
switch (c)
|
|
{
|
|
case SpendCurrency.Crystal: Viewer.Currency.Crystals = value; break;
|
|
case SpendCurrency.Rupee: Viewer.Currency.Rupees = value; break;
|
|
case SpendCurrency.RedEther: Viewer.Currency.RedEther = value; break;
|
|
case SpendCurrency.SpotPoint: Viewer.Currency.SpotPoints = value; break;
|
|
default: throw new ArgumentOutOfRangeException(nameof(c));
|
|
}
|
|
}
|
|
|
|
public Task<SpendResult> TryDebitAsync(UserGoodsType type, long detailId, int num, CancellationToken ct = default)
|
|
{
|
|
ThrowIfCommitted();
|
|
return type switch
|
|
{
|
|
UserGoodsType.Crystal => TrySpendAsync(SpendCurrency.Crystal, num, ct),
|
|
UserGoodsType.Rupy => TrySpendAsync(SpendCurrency.Rupee, num, ct),
|
|
UserGoodsType.RedEther => TrySpendAsync(SpendCurrency.RedEther, num, ct),
|
|
UserGoodsType.SpotCardPoint => TrySpendAsync(SpendCurrency.SpotPoint, num, ct),
|
|
UserGoodsType.Item => Task.FromResult(DebitItem(detailId, num)),
|
|
_ => throw new NotSupportedException($"Debit not supported for {type}"),
|
|
};
|
|
}
|
|
|
|
private SpendResult DebitItem(long detailId, int num)
|
|
{
|
|
var owned = Viewer.Items.FirstOrDefault(i => i.Item.Id == (int)detailId);
|
|
if (owned is null)
|
|
throw new InventoryCatalogException($"Item {detailId} not owned by viewer");
|
|
if (owned.Count < num)
|
|
return new SpendResult(SpendOutcome.Insufficient, owned.Count);
|
|
owned.Count -= num;
|
|
// Item debit logged as a synthetic SpendOp so CommitAsync can track it.
|
|
// Sentinel currency (int)-1 is filtered out by CommitAsync's currency-collision loop.
|
|
_ops.Add(new SpendOp((SpendCurrency)(-1) /* sentinel */, num, owned.Count));
|
|
// IsCascade: true so this GrantOp is excluded from BuildDeltas output.
|
|
_ops.Add(new GrantOp(UserGoodsType.Item, detailId, 0, owned.Count, IsCascade: true));
|
|
return new SpendResult(SpendOutcome.Success, owned.Count);
|
|
}
|
|
|
|
public async Task<IReadOnlyList<GrantedReward>> GrantAsync(UserGoodsType type, long detailId, int num, CancellationToken ct = default)
|
|
{
|
|
ThrowIfCommitted();
|
|
|
|
switch (type)
|
|
{
|
|
case UserGoodsType.Rupy:
|
|
Viewer.Currency.Rupees += (ulong)num;
|
|
var rupy = checked((int)Viewer.Currency.Rupees);
|
|
_ops.Add(new GrantOp(type, detailId, num, rupy, false));
|
|
return Single(type, detailId, rupy);
|
|
|
|
case UserGoodsType.Crystal:
|
|
Viewer.Currency.Crystals += (ulong)num;
|
|
var crystal = checked((int)Viewer.Currency.Crystals);
|
|
_ops.Add(new GrantOp(type, detailId, num, crystal, false));
|
|
return Single(type, detailId, crystal);
|
|
|
|
case UserGoodsType.RedEther:
|
|
Viewer.Currency.RedEther += (ulong)num;
|
|
var red = checked((int)Viewer.Currency.RedEther);
|
|
_ops.Add(new GrantOp(type, detailId, num, red, false));
|
|
return Single(type, detailId, red);
|
|
|
|
case UserGoodsType.SpotCardPoint:
|
|
Viewer.Currency.SpotPoints += (ulong)num;
|
|
var spot = checked((int)Viewer.Currency.SpotPoints);
|
|
_ops.Add(new GrantOp(type, detailId, num, spot, false));
|
|
return Single(type, detailId, spot);
|
|
|
|
case UserGoodsType.Sleeve:
|
|
AddCosmeticIfMissing(Viewer.Sleeves, detailId, _db.Sleeves);
|
|
_ops.Add(new GrantOp(type, detailId, num, 1, false));
|
|
return Single(type, detailId, 1);
|
|
|
|
case UserGoodsType.Emblem:
|
|
AddCosmeticIfMissing(Viewer.Emblems, detailId, _db.Emblems);
|
|
_ops.Add(new GrantOp(type, detailId, num, 1, false));
|
|
return Single(type, detailId, 1);
|
|
|
|
case UserGoodsType.Skin:
|
|
AddCosmeticIfMissing(Viewer.LeaderSkins, detailId, _db.LeaderSkins);
|
|
_ops.Add(new GrantOp(type, detailId, num, 1, false));
|
|
return Single(type, detailId, 1);
|
|
|
|
case UserGoodsType.Degree:
|
|
AddCosmeticIfMissing(Viewer.Degrees, detailId, _db.Degrees);
|
|
_ops.Add(new GrantOp(type, detailId, num, 1, false));
|
|
return Single(type, detailId, 1);
|
|
|
|
case UserGoodsType.MyPageBG:
|
|
AddCosmeticIfMissing(Viewer.MyPageBackgrounds, detailId, _db.MyPageBackgrounds);
|
|
_ops.Add(new GrantOp(type, detailId, num, 1, false));
|
|
return Single(type, detailId, 1);
|
|
|
|
case UserGoodsType.Item:
|
|
{
|
|
var owned = Viewer.Items.FirstOrDefault(i => i.Item.Id == (int)detailId);
|
|
int post;
|
|
if (owned is null)
|
|
{
|
|
var item = _db.Items.Find((int)detailId)
|
|
?? throw new InventoryCatalogException($"Item {detailId} not in catalog");
|
|
Viewer.Items.Add(new OwnedItemEntry { Item = item, Count = num, Viewer = Viewer });
|
|
post = num;
|
|
}
|
|
else
|
|
{
|
|
owned.Count += num;
|
|
post = owned.Count;
|
|
}
|
|
_ops.Add(new GrantOp(type, detailId, num, post, false));
|
|
return Single(type, detailId, post);
|
|
}
|
|
|
|
case UserGoodsType.Card:
|
|
return await ApplyCardAsync(detailId, num, ct);
|
|
|
|
case UserGoodsType.SpotCard:
|
|
case UserGoodsType.SpotCardOnlyLatestCardPack:
|
|
throw new NotSupportedException(
|
|
$"{type} rewards are not yet supported — emitters use Card=5 instead.");
|
|
|
|
default:
|
|
throw new NotImplementedException(
|
|
$"UserGoodsType {type} grant lands in a subsequent task");
|
|
}
|
|
}
|
|
|
|
public Task<int> BackfillCardCosmeticsAsync(CancellationToken ct = default)
|
|
=> throw new NotImplementedException();
|
|
|
|
public long EffectiveBalance(SpendCurrency currency) => throw new NotImplementedException();
|
|
public bool OwnsCard(long cardId) => throw new NotImplementedException();
|
|
public bool OwnsCosmetic(CosmeticType type, int id) => throw new NotImplementedException();
|
|
|
|
public Task<InventoryCommitResult> CommitAsync(CancellationToken ct = default)
|
|
=> throw new NotImplementedException();
|
|
|
|
private static IReadOnlyList<GrantedReward> Single(UserGoodsType type, long id, int num)
|
|
=> new[] { new GrantedReward((int)type, id, num) };
|
|
|
|
private void ThrowIfCommitted()
|
|
{
|
|
if (_committed)
|
|
throw new InvalidOperationException("Inventory transaction already committed");
|
|
}
|
|
|
|
private async Task<IReadOnlyList<GrantedReward>> ApplyCardAsync(long cardId, int num, CancellationToken ct)
|
|
{
|
|
var owned = Viewer.Cards.FirstOrDefault(c => c.Card.Id == cardId);
|
|
int postCount;
|
|
if (owned is null)
|
|
{
|
|
var card = await _db.Cards.FirstOrDefaultAsync(c => c.Id == cardId, ct)
|
|
?? throw new InventoryCatalogException($"Card {cardId} not in catalog");
|
|
owned = new OwnedCardEntry { Card = card, Count = num, IsProtected = false };
|
|
Viewer.Cards.Add(owned);
|
|
postCount = num;
|
|
}
|
|
else
|
|
{
|
|
owned.Count += num;
|
|
postCount = owned.Count;
|
|
}
|
|
|
|
var results = new List<GrantedReward>
|
|
{
|
|
new((int)UserGoodsType.Card, cardId, postCount),
|
|
};
|
|
_ops.Add(new GrantOp(UserGoodsType.Card, cardId, num, postCount, false));
|
|
|
|
long lookupId = owned.Card.IsFoil ? cardId - 1 : cardId;
|
|
var cascade = await _db.CardCosmeticRewards
|
|
.Where(r => r.CardId == lookupId)
|
|
.ToListAsync(ct);
|
|
|
|
foreach (var reward in cascade)
|
|
{
|
|
if (TryAddCascadeCosmetic(reward, lookupId))
|
|
{
|
|
results.Add(new GrantedReward((int)reward.Type, reward.CosmeticId, 1));
|
|
_ops.Add(new GrantOp((UserGoodsType)(int)reward.Type, reward.CosmeticId, 1, 1, true));
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
private bool TryAddCascadeCosmetic(CardCosmeticReward reward, long forCardId)
|
|
{
|
|
try
|
|
{
|
|
return reward.Type switch
|
|
{
|
|
CosmeticType.Sleeve => AddCosmeticIfMissing(Viewer.Sleeves, reward.CosmeticId, _db.Sleeves),
|
|
CosmeticType.Emblem => AddCosmeticIfMissing(Viewer.Emblems, reward.CosmeticId, _db.Emblems),
|
|
CosmeticType.Skin => AddCosmeticIfMissing(Viewer.LeaderSkins, reward.CosmeticId, _db.LeaderSkins),
|
|
CosmeticType.Degree => AddCosmeticIfMissing(Viewer.Degrees, reward.CosmeticId, _db.Degrees),
|
|
CosmeticType.MyPageBG => AddCosmeticIfMissing(Viewer.MyPageBackgrounds, reward.CosmeticId, _db.MyPageBackgrounds),
|
|
_ => false,
|
|
};
|
|
}
|
|
catch (InventoryCatalogException ex)
|
|
{
|
|
_log.LogWarning(ex,
|
|
"Card cascade: cosmetic {Type} {Id} for card {CardId} skipped (master row missing)",
|
|
reward.Type, reward.CosmeticId, forCardId);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static bool AddCosmeticIfMissing<T>(List<T> collection, long detailId, Microsoft.EntityFrameworkCore.DbSet<T> catalog) where T : class
|
|
{
|
|
if (collection.Any(e => GetId(e) == detailId)) return false;
|
|
var entity = catalog.Find(checked((int)detailId))
|
|
?? throw new InventoryCatalogException(
|
|
$"Cosmetic id {detailId} not in catalog for type {typeof(T).Name}");
|
|
collection.Add(entity);
|
|
return true;
|
|
}
|
|
|
|
private static long GetId<T>(T e)
|
|
{
|
|
var prop = typeof(T).GetProperty("Id")
|
|
?? throw new InvalidOperationException($"Type {typeof(T).Name} missing Id property");
|
|
var val = prop.GetValue(e);
|
|
return val switch { long l => l, int i => i, _ => 0 };
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
if (!_committed)
|
|
{
|
|
await _dbTx.RollbackAsync();
|
|
_db.ChangeTracker.Clear();
|
|
}
|
|
await _dbTx.DisposeAsync();
|
|
}
|
|
}
|