mirror of
https://github.com/MikuLeaks/MikuSB.git
synced 2026-06-04 06:43:57 +00:00
452 lines
16 KiB
C#
452 lines
16 KiB
C#
using MikuSB.Data;
|
|
using MikuSB.Data.Excel;
|
|
using MikuSB.Database;
|
|
using MikuSB.Database.Inventory;
|
|
using MikuSB.Database.Player;
|
|
using MikuSB.Enums.Item;
|
|
using MikuSB.GameServer.Game.Player;
|
|
using MikuSB.Proto;
|
|
using System.Globalization;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
using System.Text.Json.Serialization;
|
|
|
|
namespace MikuSB.GameServer.Server.CallGS.Handlers.Shop;
|
|
|
|
[CallGSApi("IBLogic_BuyGoods")]
|
|
public class IBLogic_BuyGoods : ICallGSHandler
|
|
{
|
|
private const uint BuyGroupId = 26;
|
|
private const uint RedGroupId = 113;
|
|
private const uint CashGroupId = 1;
|
|
private const uint BattlePassGroupId = 25;
|
|
private const uint BattlePassCurIdSid = 1;
|
|
private const uint BattlePassStatusSid = 2;
|
|
|
|
public async Task Handle(Connection connection, string param, ushort seqNo)
|
|
{
|
|
var req = JsonSerializer.Deserialize<IbBuyGoodsParam>(param);
|
|
var player = connection.Player!;
|
|
if (req?.Type == 3 && req.GoodsId > 0 && req.Count > 0)
|
|
{
|
|
await HandleBattlePassPurchase(connection, player, req);
|
|
return;
|
|
}
|
|
|
|
if (req == null ||
|
|
req.GoodsId == 0 ||
|
|
req.Count == 0 ||
|
|
!GameData.IbGoodsData.TryGetValue(req.GoodsId, out var goods))
|
|
{
|
|
await CallGSRouter.SendScript(connection, "IBLogic_BuyGoods", "{\"sErr\":\"error.BadParam\"}");
|
|
return;
|
|
}
|
|
|
|
if (goods.LimitTimes > 0)
|
|
{
|
|
var buyAttr = GetOrCreateAttr(player, BuyGroupId, req.GoodsId);
|
|
if (buyAttr.Val >= goods.LimitTimes)
|
|
{
|
|
await CallGSRouter.SendScript(connection, "IBLogic_BuyGoods", "{\"sErr\":\"tip.Mall_Limit_Buy\"}");
|
|
return;
|
|
}
|
|
}
|
|
|
|
var rewardItems = BuildRewardItems(goods, req);
|
|
if (rewardItems.Count == 0)
|
|
{
|
|
await CallGSRouter.SendScript(connection, "IBLogic_BuyGoods", "{\"sErr\":\"error.BadParam\"}");
|
|
return;
|
|
}
|
|
|
|
var sync = new NtfSyncPlayer();
|
|
foreach (var reward in rewardItems)
|
|
await GrantRewardAsync(player, sync, reward);
|
|
|
|
var buyCountAttr = GetOrCreateAttr(player, BuyGroupId, req.GoodsId);
|
|
buyCountAttr.Val += req.Count;
|
|
SyncAttr(player, sync, buyCountAttr);
|
|
|
|
var redAttr = GetOrCreateAttr(player, RedGroupId, req.GoodsId);
|
|
if (redAttr.Val == 0)
|
|
{
|
|
redAttr.Val = 1;
|
|
SyncAttr(player, sync, redAttr);
|
|
}
|
|
|
|
DatabaseHelper.SaveDatabaseType(player.Data);
|
|
DatabaseHelper.SaveDatabaseType(player.InventoryManager.InventoryData);
|
|
DatabaseHelper.SaveDatabaseType(player.CharacterManager.CharacterData);
|
|
|
|
var responseGoods = new JsonArray();
|
|
foreach (var reward in rewardItems)
|
|
{
|
|
var row = new JsonArray();
|
|
foreach (var value in reward)
|
|
row.Add((int)value);
|
|
responseGoods.Add(row);
|
|
}
|
|
|
|
var rsp = new JsonObject
|
|
{
|
|
["nGoodsId"] = (int)req.GoodsId,
|
|
["tbGoods"] = responseGoods
|
|
};
|
|
|
|
var productId = goods.GetProductId();
|
|
if (!string.IsNullOrWhiteSpace(productId))
|
|
rsp["sProductId"] = productId;
|
|
|
|
var cost = req.Index == 2 ? goods.Cost2 : goods.Cost;
|
|
if (cost.Count >= 2)
|
|
rsp["nTotalPrice"] = (int)cost[1];
|
|
|
|
await CallGSRouter.SendScript(connection, "IBLogic_BuyGoods", rsp.ToJsonString(), sync);
|
|
}
|
|
|
|
private static async Task HandleBattlePassPurchase(Connection connection, PlayerInstance player, IbBuyGoodsParam req)
|
|
{
|
|
var sync = new NtfSyncPlayer();
|
|
var battlePassId = ResolveCurrentBattlePassId();
|
|
if (battlePassId > 0)
|
|
{
|
|
var curIdAttr = GetOrCreateAttr(player, BattlePassGroupId, BattlePassCurIdSid);
|
|
curIdAttr.Val = battlePassId;
|
|
SyncAttr(player, sync, curIdAttr);
|
|
}
|
|
|
|
var statusAttr = GetOrCreateAttr(player, BattlePassGroupId, BattlePassStatusSid);
|
|
if (statusAttr.Val < 2)
|
|
{
|
|
statusAttr.Val = 2;
|
|
SyncAttr(player, sync, statusAttr);
|
|
}
|
|
|
|
var buyCountAttr = GetOrCreateAttr(player, BuyGroupId, req.GoodsId);
|
|
buyCountAttr.Val += req.Count;
|
|
SyncAttr(player, sync, buyCountAttr);
|
|
|
|
var redAttr = GetOrCreateAttr(player, RedGroupId, req.GoodsId);
|
|
if (redAttr.Val == 0)
|
|
{
|
|
redAttr.Val = 1;
|
|
SyncAttr(player, sync, redAttr);
|
|
}
|
|
|
|
DatabaseHelper.SaveDatabaseType(player.Data);
|
|
|
|
var rsp = new JsonObject
|
|
{
|
|
["nGoodsId"] = (int)req.GoodsId,
|
|
["tbGoods"] = new JsonArray()
|
|
};
|
|
|
|
await CallGSRouter.SendScript(connection, "IBLogic_BuyGoods", rsp.ToJsonString(), sync);
|
|
}
|
|
|
|
private static List<List<uint>> BuildRewardItems(IbGoodsExcel goods, IbBuyGoodsParam req)
|
|
{
|
|
var rewards = new List<List<uint>>();
|
|
|
|
if (goods.Item.Count >= 4)
|
|
rewards.Add(WithCount(goods.Item, req.Count));
|
|
|
|
if (req.SelectItem1?.Count >= 4)
|
|
rewards.Add(WithCount(req.SelectItem1, req.Count));
|
|
|
|
if (req.SelectItem2?.Count >= 4)
|
|
rewards.Add(WithCount(req.SelectItem2, req.Count));
|
|
|
|
return rewards;
|
|
}
|
|
|
|
private static List<uint> WithCount(IReadOnlyList<uint> item, uint buyCount)
|
|
{
|
|
var reward = item.Take(5).ToList();
|
|
while (reward.Count < 5)
|
|
reward.Add(1);
|
|
|
|
reward[4] = Math.Max(1u, reward[4]) * Math.Max(1u, buyCount);
|
|
return reward;
|
|
}
|
|
|
|
private static async Task GrantRewardAsync(PlayerInstance player, NtfSyncPlayer sync, IReadOnlyList<uint> reward)
|
|
{
|
|
if (reward.Count < 5)
|
|
return;
|
|
|
|
var itemType = (ItemTypeEnum)reward[0];
|
|
var detail = reward[1];
|
|
var particular = reward[2];
|
|
var level = reward[3];
|
|
var count = Math.Max(1u, reward[4]);
|
|
|
|
switch (itemType)
|
|
{
|
|
case ItemTypeEnum.TYPE_CARD:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var character = await player.CharacterManager.AddCharacter(itemType, detail, particular, level, sendPacket: false);
|
|
if (character != null)
|
|
sync.Items.Add(character.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_WEAPON:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var weapon = await player.InventoryManager.AddWeaponItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (weapon != null)
|
|
sync.Items.Add(weapon.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_SUPPORT:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var support = await player.InventoryManager.AddSupportCardItem(detail, particular, level, sendPacket: false);
|
|
if (support != null)
|
|
sync.Items.Add(support.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_SUPPLIES:
|
|
{
|
|
var templateId = (uint)GameResourceTemplateId.FromGdpl(reward[0], detail, particular, level);
|
|
if (!GameData.SuppliesData.TryGetValue(templateId, out var supplies))
|
|
break;
|
|
|
|
var item = await player.InventoryManager.AddSuppliesItem(supplies, count, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
break;
|
|
}
|
|
case ItemTypeEnum.TYPE_USEABLE:
|
|
{
|
|
if (!TryGrantCashBox(player, sync, detail, particular, level, count))
|
|
{
|
|
var item = AddOtherItem(player.InventoryManager.InventoryData, reward[0], detail, particular, level, count);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
}
|
|
case ItemTypeEnum.TYPE_WEAPON_PART:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddWeaponPartItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_CARD_SKIN:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddSkinItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_HOUSE:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddHouseFurnitureItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_PROFILE:
|
|
case ItemTypeEnum.TYPE_FRAME:
|
|
case ItemTypeEnum.TYPE_BADGE:
|
|
case ItemTypeEnum.TYPE_COVER:
|
|
case ItemTypeEnum.TYPE_NAMECARD:
|
|
case ItemTypeEnum.TYPE_EXPRESSION:
|
|
case ItemTypeEnum.TYPE_BUBBLE:
|
|
case ItemTypeEnum.TYPE_ANALYST:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddProfileItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_WEAPON_SKIN:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddWeaponSkinItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_MANIFESTATION:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddManifestationItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_CARD_SKIN_PART:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddSkinPartItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_AR:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddArItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
case ItemTypeEnum.TYPE_CALL:
|
|
for (var i = 0u; i < count; i++)
|
|
{
|
|
var item = await player.InventoryManager.AddCallItem(itemType, detail, particular, level, sendPacket: false);
|
|
if (item != null)
|
|
sync.Items.Add(item.ToProto());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static BaseGameItemInfo? AddOtherItem(InventoryData inventory, uint genre, uint detail, uint particular, uint level, uint count)
|
|
{
|
|
var templateId = (uint)GameResourceTemplateId.FromGdpl(genre, detail, particular, level);
|
|
if (!GameData.OtherItemData.TryGetValue(templateId, out var otherItem))
|
|
return null;
|
|
|
|
var maxCount = otherItem.GMnum > 0 ? otherItem.GMnum : 99999u;
|
|
var existing = inventory.Items.Values.FirstOrDefault(x => x.TemplateId == templateId);
|
|
if (existing != null)
|
|
{
|
|
existing.ItemCount = Math.Min(existing.ItemCount + count, maxCount);
|
|
return existing;
|
|
}
|
|
|
|
var item = new BaseGameItemInfo
|
|
{
|
|
TemplateId = templateId,
|
|
UniqueId = inventory.NextUniqueUid++,
|
|
ItemType = ItemTypeEnum.TYPE_USEABLE,
|
|
ItemCount = Math.Min(count, maxCount)
|
|
};
|
|
inventory.Items[item.UniqueId] = item;
|
|
return item;
|
|
}
|
|
|
|
private static bool TryGrantCashBox(PlayerInstance player, NtfSyncPlayer sync, uint detail, uint particular, uint level, uint count)
|
|
{
|
|
var templateId = (uint)GameResourceTemplateId.FromGdpl((uint)ItemTypeEnum.TYPE_USEABLE, detail, particular, level);
|
|
if (!GameData.OtherItemData.TryGetValue(templateId, out var otherItem))
|
|
return false;
|
|
|
|
uint moneyType = otherItem.LuaType switch
|
|
{
|
|
"money_box" => 1,
|
|
"gold_box" => 2,
|
|
"silver_box" => 3,
|
|
"vigor_box" => 4,
|
|
_ => 0
|
|
};
|
|
|
|
if (moneyType == 0 || otherItem.Param1 == 0)
|
|
return false;
|
|
|
|
var amount = checked(otherItem.Param1 * count);
|
|
var sid = moneyType * 2 + 1;
|
|
var attr = GetOrCreateAttr(player, CashGroupId, sid);
|
|
attr.Val += amount;
|
|
SyncAttr(player, sync, attr);
|
|
if (moneyType == 1)
|
|
{
|
|
foreach (var (key, value) in player.BuildMoneySync())
|
|
sync.Money[key] = value;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static uint ResolveCurrentBattlePassId()
|
|
{
|
|
var now = DateTime.Now;
|
|
var parsed = GameData.BattlePassTimeData.Values
|
|
.Select(x => new
|
|
{
|
|
Config = x,
|
|
Start = ParseConfigTime(x.StartTime),
|
|
End = ParseConfigTime(x.EndTime)
|
|
})
|
|
.Where(x => x.Start.HasValue && x.End.HasValue)
|
|
.OrderBy(x => x.Start)
|
|
.ToList();
|
|
|
|
var current = parsed.FirstOrDefault(x => x.Start <= now && now < x.End);
|
|
if (current != null)
|
|
return current.Config.Id;
|
|
|
|
var latestStarted = parsed.LastOrDefault(x => x.Start <= now && x.End > x.Start);
|
|
return latestStarted?.Config.Id ?? 0;
|
|
}
|
|
|
|
private static DateTime? ParseConfigTime(string? raw)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(raw))
|
|
return null;
|
|
|
|
var normalized = raw.Trim().Trim('[', ']');
|
|
if (normalized.Length != 12)
|
|
return null;
|
|
|
|
return DateTime.TryParseExact(
|
|
normalized,
|
|
"yyyyMMddHHmm",
|
|
CultureInfo.InvariantCulture,
|
|
DateTimeStyles.None,
|
|
out var value)
|
|
? value
|
|
: null;
|
|
}
|
|
|
|
private static PlayerAttr GetOrCreateAttr(PlayerInstance player, uint gid, uint sid)
|
|
{
|
|
var attr = player.Data.Attrs.FirstOrDefault(x => x.Gid == gid && x.Sid == sid);
|
|
if (attr != null)
|
|
return attr;
|
|
|
|
attr = new PlayerAttr
|
|
{
|
|
Gid = gid,
|
|
Sid = sid
|
|
};
|
|
player.Data.Attrs.Add(attr);
|
|
return attr;
|
|
}
|
|
|
|
private static void SyncAttr(PlayerInstance player, NtfSyncPlayer sync, PlayerAttr attr)
|
|
{
|
|
sync.Custom[player.ToPackedAttrKey(attr.Gid, attr.Sid)] = attr.Val;
|
|
sync.Custom[player.ToShiftedAttrKey(attr.Gid, attr.Sid)] = attr.Val;
|
|
}
|
|
}
|
|
|
|
internal sealed class IbBuyGoodsParam
|
|
{
|
|
[JsonPropertyName("nType")]
|
|
public int Type { get; set; }
|
|
|
|
[JsonPropertyName("nGoodsId")]
|
|
public uint GoodsId { get; set; }
|
|
|
|
[JsonPropertyName("nCount")]
|
|
public uint Count { get; set; }
|
|
|
|
[JsonPropertyName("nIndex")]
|
|
public int Index { get; set; }
|
|
|
|
[JsonPropertyName("tbSelectItem1")]
|
|
public List<uint>? SelectItem1 { get; set; }
|
|
|
|
[JsonPropertyName("tbSelectItem2")]
|
|
public List<uint>? SelectItem2 { get; set; }
|
|
}
|