516 lines
19 KiB
C#
516 lines
19 KiB
C#
using System.Text.Json;
|
||
using Ananta.Server.Configuration;
|
||
|
||
namespace Ananta.Server.ClientData.Client4229938;
|
||
|
||
/// <summary>
|
||
/// Client economy tables (mall commodities, drops, gacha pools/contents/tier rules) imported from the
|
||
/// 4229938 config dump into <c>paths.clientConfigs</c>.
|
||
///
|
||
/// Unlike ClientConfigRepository these tables are optional: a missing or malformed file only disables
|
||
/// the matching feature (mall purchase / gacha draw) instead of refusing to start, because the rest of
|
||
/// the server must keep working when a dump is incomplete.
|
||
/// </summary>
|
||
internal static class EconomyConfigRepository
|
||
{
|
||
private static readonly Lazy<Data> Cache = new(Load);
|
||
|
||
/// <summary>Forces the (optional) tables to load so the startup log reports what was imported.</summary>
|
||
internal static void Warmup()
|
||
=> _ = Cache.Value;
|
||
|
||
internal static bool TryMallCommodity(uint id, out MallCommodity commodity)
|
||
=> Cache.Value.Mall.TryGetValue(id, out commodity!);
|
||
|
||
internal static bool TryDrop(uint id, out DropRow drop)
|
||
=> Cache.Value.Drops.TryGetValue(id, out drop!);
|
||
|
||
internal static bool TryPool(uint id, out GachaPool pool)
|
||
=> Cache.Value.Pools.TryGetValue(id, out pool!);
|
||
|
||
internal static bool TryTierRule(uint id, out GachaTierRule rule)
|
||
=> Cache.Value.TierRules.TryGetValue(id, out rule!);
|
||
|
||
internal static bool TryTradeItem(uint id, out TradeItem item)
|
||
=> Cache.Value.TradeItems.TryGetValue(id, out item!);
|
||
|
||
internal static IReadOnlyList<GachaContent> PoolContents(uint poolId)
|
||
=> Cache.Value.ContentsByPool.TryGetValue(poolId, out var contents) ? contents : [];
|
||
|
||
/// <summary>One mall shelf row. Price is the list price, DiscountPrice the current charge (0 = none).</summary>
|
||
internal sealed record MallCommodity(
|
||
uint Id,
|
||
uint MallId,
|
||
uint Type,
|
||
uint BindId,
|
||
uint ConsumeItemId,
|
||
double Price,
|
||
double DiscountPrice,
|
||
uint DropId,
|
||
uint LimitNum,
|
||
IReadOnlyList<uint> CommodityBindIds)
|
||
{
|
||
internal double UnitPrice => DiscountPrice > 0 ? DiscountPrice : Price;
|
||
}
|
||
|
||
/// <summary>
|
||
/// One drop row. <paramref name="Guaranteed"/> items are always granted, <paramref name="Ranged"/>
|
||
/// picks one entry and a random count in [Min, Max], <paramref name="Weighted"/> picks one entry by
|
||
/// relative weight (Item3 carries fractional weights, so they are doubles).
|
||
/// </summary>
|
||
internal sealed record DropRow(
|
||
uint Id,
|
||
double Money,
|
||
double BindingGold,
|
||
IReadOnlyList<(uint Id, uint Count)> Guaranteed,
|
||
IReadOnlyList<(uint Id, uint Min, uint Max)> Ranged,
|
||
IReadOnlyList<(uint Id, double Weight)> Weighted)
|
||
{
|
||
internal bool IsEmpty => Guaranteed.Count == 0 && Ranged.Count == 0 && Weighted.Count == 0
|
||
&& Money == 0 && BindingGold == 0;
|
||
}
|
||
|
||
internal sealed record GachaPool(
|
||
uint Id,
|
||
bool IsDrop,
|
||
uint MoneyId,
|
||
uint CommodityId,
|
||
uint GrandTierRuleId,
|
||
IReadOnlyList<(uint DrawCount, uint Cost)> Costs)
|
||
{
|
||
/// <summary>Authored cost for the requested draw count, falling back to per-draw cost × count.</summary>
|
||
internal double CostFor(uint drawCount)
|
||
{
|
||
foreach (var (count, cost) in Costs)
|
||
{
|
||
if (count == drawCount)
|
||
return cost;
|
||
}
|
||
|
||
foreach (var (count, cost) in Costs)
|
||
{
|
||
if (count == 1)
|
||
return cost * drawCount;
|
||
}
|
||
|
||
return Costs.Count > 0 ? Costs[0].Cost : 0;
|
||
}
|
||
}
|
||
|
||
internal sealed record GachaContent(
|
||
uint Id,
|
||
uint PoolId,
|
||
uint TierRarity,
|
||
uint DropId,
|
||
double Weight,
|
||
uint Quantity,
|
||
uint Quality,
|
||
uint DuplicateReturnDropId,
|
||
uint DuplicateReturnCount)
|
||
{
|
||
/// <summary>SS-tier row: the UI plays the extra grand-prize video for these draws.</summary>
|
||
internal bool IsGrandPrize => TierRarity >= 4 || Quality >= 5;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Pity ramp for one tier rule. <paramref name="RuleType"/> 1 pools ramp their grand-prize chance
|
||
/// from <paramref name="BaseProbability"/> by <paramref name="ProbabilityIncrement"/> every draw
|
||
/// once <paramref name="RampStartDraw"/> is reached and guarantee it at <paramref name="PityThreshold"/>.
|
||
/// <paramref name="RuleType"/> 0 pools instead pick a tier from the cumulative
|
||
/// <paramref name="GrandPrizeProbability"/> table (scale 100000) with no pity at all.
|
||
/// </summary>
|
||
internal sealed record GachaTierRule(
|
||
uint Id,
|
||
uint RuleType,
|
||
uint PityThreshold,
|
||
uint RampStartDraw,
|
||
uint BaseProbability,
|
||
uint ProbabilityIncrement,
|
||
IReadOnlyList<uint> GrandPrizeProbability);
|
||
|
||
/// <summary>
|
||
/// One trading-post row. <paramref name="ItemType"/> 0 hands out <paramref name="ItemId"/> as an
|
||
/// ordinary backpack item, 1 unlocks the wardrobe piece <paramref name="FashionId"/>, 3 is a
|
||
/// household collectible (also <paramref name="ItemId"/>) and 2 is a fashion suit that retail only
|
||
/// trades through the order book.
|
||
/// </summary>
|
||
internal sealed record TradeItem(
|
||
uint Id,
|
||
uint ItemType,
|
||
uint ItemId,
|
||
uint Tab,
|
||
uint FashionId,
|
||
uint FashionSuitId,
|
||
uint MinPrice,
|
||
uint MaxPrice,
|
||
IReadOnlyList<uint> BucketRanges)
|
||
{
|
||
/// <summary>Cheapest price the row is offered at - the floor of its authored bucket ranges.</summary>
|
||
internal uint MarketPrice
|
||
{
|
||
get
|
||
{
|
||
if (MinPrice > 0)
|
||
return MinPrice;
|
||
|
||
foreach (var bucket in BucketRanges)
|
||
{
|
||
if (bucket > 0)
|
||
return bucket;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
private sealed class Data
|
||
{
|
||
internal Dictionary<uint, MallCommodity> Mall { get; init; } = [];
|
||
internal Dictionary<uint, DropRow> Drops { get; init; } = [];
|
||
internal Dictionary<uint, GachaPool> Pools { get; init; } = [];
|
||
internal Dictionary<uint, GachaTierRule> TierRules { get; init; } = [];
|
||
internal Dictionary<uint, List<GachaContent>> ContentsByPool { get; init; } = [];
|
||
internal Dictionary<uint, TradeItem> TradeItems { get; init; } = [];
|
||
internal Dictionary<uint, ConsumableItem> Items { get; init; } = [];
|
||
}
|
||
|
||
private static Data Load()
|
||
{
|
||
var cfg = PrivateServerConfigStore.Current;
|
||
var root = PrivateServerConfigStore.ResolveProjectPath(cfg.Paths.ClientConfigs);
|
||
var warnings = new List<string>();
|
||
|
||
var mall = new Dictionary<uint, MallCommodity>();
|
||
foreach (var row in ReadRecords(Path.Combine(root, "MallCommodityConfig.json"), warnings))
|
||
{
|
||
if (!TryUInt32(row, "Id", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryUInt32(row, "BelongMallId", out var mallId);
|
||
TryUInt32(row, "Type", out var type);
|
||
TryUInt32(row, "BindId", out var bindId);
|
||
TryUInt32(row, "ConsumeItemId", out var consumeItemId);
|
||
TryDouble(row, "Price", out var price);
|
||
TryDouble(row, "DiscountPrice", out var discountPrice);
|
||
TryUInt32(row, "DropId", out var dropId);
|
||
TryUInt32(row, "LimitNum", out var limitNum);
|
||
|
||
mall[id] = new MallCommodity(
|
||
id, mallId, type, bindId, consumeItemId, price, discountPrice, dropId, limitNum,
|
||
ReadUInt32Array(row, "CommodityBindId"));
|
||
}
|
||
|
||
var drops = new Dictionary<uint, DropRow>();
|
||
foreach (var row in ReadRecords(Path.Combine(root, "DropConfig.json"), warnings))
|
||
{
|
||
if (!TryUInt32(row, "Id", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryDouble(row, "Money", out var money);
|
||
TryDouble(row, "BindingGold", out var bindingGold);
|
||
|
||
drops[id] = new DropRow(
|
||
id, money, bindingGold, ReadItemList(row, "Item1"), ReadItemRangeList(row, "Item2"),
|
||
ReadItemWeightList(row, "Item3"));
|
||
}
|
||
|
||
var pools = new Dictionary<uint, GachaPool>();
|
||
foreach (var row in ReadRecords(Path.Combine(root, "GachaPoolConfig.json"), warnings))
|
||
{
|
||
if (!TryUInt32(row, "Id", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryUInt32(row, "MoneyId", out var moneyId);
|
||
TryUInt32(row, "CommodityId", out var commodityId);
|
||
TryUInt32(row, "SS_TierRuleId", out var grandTierRuleId);
|
||
|
||
pools[id] = new GachaPool(
|
||
id, ReadBool(row, "isDrop"), moneyId, commodityId, grandTierRuleId, ReadCostList(row, "CostCount"));
|
||
}
|
||
|
||
var tierRules = new Dictionary<uint, GachaTierRule>();
|
||
foreach (var row in ReadRecords(Path.Combine(root, "GachaPoolTierRuleConfig.json"), warnings))
|
||
{
|
||
if (!TryUInt32(row, "Id", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryUInt32(row, "RuleType", out var ruleType);
|
||
TryUInt32(row, "PityThreshold", out var pityThreshold);
|
||
TryUInt32(row, "RampStartDraw", out var rampStartDraw);
|
||
TryUInt32(row, "BaseProbability", out var baseProbability);
|
||
TryUInt32(row, "ProbabilityIncrement", out var probabilityIncrement);
|
||
tierRules[id] = new GachaTierRule(
|
||
id, ruleType, pityThreshold, rampStartDraw, baseProbability, probabilityIncrement,
|
||
ReadUInt32Array(row, "GrandPrizeProbability"));
|
||
}
|
||
|
||
var contentsByPool = new Dictionary<uint, List<GachaContent>>();
|
||
foreach (var row in ReadRecords(Path.Combine(root, "GachaPoolContentConfig.json"), warnings))
|
||
{
|
||
if (!TryUInt32(row, "Id", out var id) || id == 0)
|
||
continue;
|
||
if (!TryUInt32(row, "PoolId", out var poolId) || poolId == 0)
|
||
continue;
|
||
|
||
TryUInt32(row, "PoolTierRarity", out var tierRarity);
|
||
TryUInt32(row, "dropId", out var dropId);
|
||
TryDouble(row, "weight", out var weight);
|
||
TryUInt32(row, "Quantity", out var quantity);
|
||
TryUInt32(row, "Quality", out var quality);
|
||
TryUInt32(row, "duplicateReturnDropId", out var duplicateDropId);
|
||
TryUInt32(row, "duplicateReturnCount", out var duplicateCount);
|
||
|
||
if (!contentsByPool.TryGetValue(poolId, out var list))
|
||
{
|
||
list = [];
|
||
contentsByPool[poolId] = list;
|
||
}
|
||
|
||
list.Add(new GachaContent(
|
||
id, poolId, tierRarity, dropId, weight < 0 ? 0 : weight, quantity, quality,
|
||
duplicateDropId, duplicateCount));
|
||
}
|
||
|
||
var tradeItems = new Dictionary<uint, TradeItem>();
|
||
foreach (var row in ReadRecords(Path.Combine(root, "TradeItemConfig.json"), warnings))
|
||
{
|
||
if (!TryUInt32(row, "Id", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryUInt32(row, "ItemType", out var itemType);
|
||
TryUInt32(row, "ItemId", out var itemId);
|
||
TryUInt32(row, "Tab", out var tab);
|
||
TryUInt32(row, "FashionId", out var fashionId);
|
||
TryUInt32(row, "FashionSuitId", out var fashionSuitId);
|
||
TryUInt32(row, "MinPrice", out var minPrice);
|
||
TryUInt32(row, "MaxPrice", out var maxPrice);
|
||
|
||
tradeItems[id] = new TradeItem(
|
||
id, itemType, itemId, tab, fashionId, fashionSuitId, minPrice, maxPrice,
|
||
ReadUInt32Array(row, "BucketRanges"));
|
||
}
|
||
|
||
foreach (var message in warnings)
|
||
Console.WriteLine($"[ECONOMY] {message}");
|
||
|
||
Console.WriteLine(
|
||
$"[ECONOMY] mall={mall.Count} drops={drops.Count} pools={pools.Count} " +
|
||
$"gachaContents={contentsByPool.Values.Sum(x => x.Count)} tierRules={tierRules.Count} " +
|
||
$"tradeItems={tradeItems.Count} source={root}");
|
||
|
||
|
||
var items = new Dictionary<uint, ConsumableItem>();
|
||
foreach (var row in ReadRecords(Path.Combine(root, "ConsumableConfig.json"), warnings))
|
||
{
|
||
if (!TryUInt32(row, "Id", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryUInt32(row, "Type", out var subType);
|
||
TryUInt32(row, "Quality", out var quality);
|
||
var name = ReadString(row, "Name");
|
||
items[id] = new ConsumableItem(id, name, subType, quality);
|
||
}
|
||
|
||
return new Data
|
||
{
|
||
Items = items,
|
||
Mall = mall,
|
||
Drops = drops,
|
||
Pools = pools,
|
||
TierRules = tierRules,
|
||
ContentsByPool = contentsByPool,
|
||
TradeItems = tradeItems,
|
||
};
|
||
}
|
||
|
||
private static JsonElement[] ReadRecords(string path, List<string> warnings)
|
||
{
|
||
if (!File.Exists(path))
|
||
{
|
||
warnings.Add($"optional client config is missing: {path}");
|
||
return [];
|
||
}
|
||
|
||
try
|
||
{
|
||
using var doc = JsonDocument.Parse(File.ReadAllText(path));
|
||
if (!doc.RootElement.TryGetProperty("records", out var records) || records.ValueKind != JsonValueKind.Array)
|
||
{
|
||
warnings.Add($"client config has no 'records' array: {path}");
|
||
return [];
|
||
}
|
||
|
||
return records.EnumerateArray().Select(x => x.Clone()).ToArray();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
warnings.Add($"client config failed to parse ({ex.GetType().Name}: {ex.Message}): {path}");
|
||
return [];
|
||
}
|
||
}
|
||
|
||
// Dump records may carry fully qualified keys ("LT.ConfigGen.IFoo.Id"), so match on the leaf name.
|
||
private static bool TryProperty(JsonElement row, string name, out JsonElement value)
|
||
{
|
||
if (row.TryGetProperty(name, out value))
|
||
return true;
|
||
|
||
foreach (var property in row.EnumerateObject())
|
||
{
|
||
if (property.Name.AsSpan()[(property.Name.LastIndexOf('.') + 1)..].SequenceEqual(name))
|
||
{
|
||
value = property.Value;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
value = default;
|
||
return false;
|
||
}
|
||
|
||
private static bool TryUInt32(JsonElement row, string name, out uint result)
|
||
{
|
||
result = 0;
|
||
return TryProperty(row, name, out var value) && value.TryGetUInt32(out result);
|
||
}
|
||
|
||
private static bool TryDouble(JsonElement row, string name, out double result)
|
||
{
|
||
result = 0;
|
||
return TryProperty(row, name, out var value) && value.TryGetDouble(out result);
|
||
}
|
||
|
||
|
||
private static string ReadString(JsonElement row, string name)
|
||
=> TryProperty(row, name, out var value) && value.ValueKind == JsonValueKind.String
|
||
? value.GetString() ?? string.Empty
|
||
: string.Empty;
|
||
|
||
private static bool ReadBool(JsonElement row, string name)
|
||
=> TryProperty(row, name, out var value) && value.ValueKind == JsonValueKind.True;
|
||
|
||
private static IReadOnlyList<uint> ReadUInt32Array(JsonElement row, string name)
|
||
{
|
||
if (!TryProperty(row, name, out var value) || value.ValueKind != JsonValueKind.Array)
|
||
return [];
|
||
|
||
return value.EnumerateArray()
|
||
.Where(x => x.TryGetUInt32(out _))
|
||
.Select(x => x.GetUInt32())
|
||
.ToArray();
|
||
}
|
||
|
||
// Item1: [{ "id1": 36211010, "count": 10 }, ...] - every entry is granted.
|
||
private static IReadOnlyList<(uint Id, uint Count)> ReadItemList(JsonElement row, string name)
|
||
{
|
||
if (!TryProperty(row, name, out var value) || value.ValueKind != JsonValueKind.Array)
|
||
return [];
|
||
|
||
var result = new List<(uint, uint)>();
|
||
foreach (var entry in value.EnumerateArray())
|
||
{
|
||
if (!TryUInt32(entry, "id1", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryUInt32(entry, "count", out var count);
|
||
result.Add((id, count == 0 ? 1u : count));
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// Item2: [{ "id2": .., "min": .., "max": .. }] - one entry is chosen and rolled inside [min, max].
|
||
private static IReadOnlyList<(uint Id, uint Min, uint Max)> ReadItemRangeList(JsonElement row, string name)
|
||
{
|
||
if (!TryProperty(row, name, out var value) || value.ValueKind != JsonValueKind.Array)
|
||
return [];
|
||
|
||
var result = new List<(uint, uint, uint)>();
|
||
foreach (var entry in value.EnumerateArray())
|
||
{
|
||
if (!TryUInt32(entry, "id2", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryUInt32(entry, "min", out var min);
|
||
TryUInt32(entry, "max", out var max);
|
||
if (max < min)
|
||
max = min;
|
||
result.Add((id, min, max));
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// Item3: [{ "id3": .., "count": 0.00075 }] - 'count' is a relative probability weight.
|
||
private static IReadOnlyList<(uint Id, double Weight)> ReadItemWeightList(JsonElement row, string name)
|
||
{
|
||
if (!TryProperty(row, name, out var value) || value.ValueKind != JsonValueKind.Array)
|
||
return [];
|
||
|
||
var result = new List<(uint, double)>();
|
||
foreach (var entry in value.EnumerateArray())
|
||
{
|
||
if (!TryUInt32(entry, "id3", out var id) || id == 0)
|
||
continue;
|
||
|
||
TryDouble(entry, "count", out var weight);
|
||
if (weight <= 0)
|
||
continue;
|
||
result.Add((id, weight));
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// CostCount: [{ "drawCount": 1, "cost": 100 }, ...]
|
||
private static IReadOnlyList<(uint DrawCount, uint Cost)> ReadCostList(JsonElement row, string name)
|
||
{
|
||
if (!TryProperty(row, name, out var value) || value.ValueKind != JsonValueKind.Array)
|
||
return [];
|
||
|
||
var result = new List<(uint, uint)>();
|
||
foreach (var entry in value.EnumerateArray())
|
||
{
|
||
if (!TryUInt32(entry, "drawCount", out var drawCount) || drawCount == 0)
|
||
continue;
|
||
|
||
TryUInt32(entry, "cost", out var cost);
|
||
result.Add((drawCount, cost));
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
internal static IReadOnlyCollection<uint> GachaTicketItemIds()
|
||
=> Cache.Value.Pools.Values
|
||
.Select(p => p.MoneyId)
|
||
.Where(id => id != 0)
|
||
.Distinct()
|
||
.OrderBy(id => id)
|
||
.ToArray();
|
||
|
||
internal static bool TryConsumableItem(uint id, out ConsumableItem item)
|
||
=> Cache.Value.Items.TryGetValue(id, out item!);
|
||
|
||
internal static bool HasConsumableItems => Cache.Value.Items.Count > 0;
|
||
|
||
internal static IReadOnlyCollection<ConsumableItem> ConsumableItems => Cache.Value.Items.Values;
|
||
|
||
internal static IReadOnlyList<ConsumableItem> SearchConsumableItems(string? query, int limit)
|
||
{
|
||
IEnumerable<ConsumableItem> matches = Cache.Value.Items.Values;
|
||
if (!string.IsNullOrWhiteSpace(query))
|
||
{
|
||
var text = query.Trim();
|
||
matches = matches.Where(x =>
|
||
x.Id.ToString().Contains(text, StringComparison.Ordinal) ||
|
||
x.Name.Contains(text, StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
|
||
return matches.OrderBy(x => x.Id).Take(limit).ToArray();
|
||
}
|
||
|
||
internal sealed record ConsumableItem(uint Id, string Name, uint SubType, uint Quality);
|
||
|
||
} |