DevilProMT/MikuSB
1
0
Fork 0
mirror of https://github.com/MikuLeaks/MikuSB.git synced 2026-06-04 04:03:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

SupporterCard Affix can now be changed.

Browse Source
This commit is contained in:
Kei-Luna
2026-05-16 16:20:17 +09:00
parent e628a010be
commit f8f7311997
17 changed files with 549 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
Common/Data/Excel/SupportCardExcel.cs
View File

@@ -1,4 +1,5 @@
using Newtonsoft.Json;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace MikuSB.Data.Excel;
@@ -14,6 +15,9 @@ public class SupportCardExcel : ExcelResource
public uint Color { get; set; }
[JsonProperty("LevelLimitID")] public int LevelLimitId { get; set; }
[JsonProperty("AffixPool")] public List<int> AffixPool { get; set; } = [];
[JsonProperty("AffixCost")] public JToken? AffixCostRaw { get; set; }
[JsonProperty("InitialAffixCost")] public JToken? InitialAffixCostRaw { get; set; }
[JsonProperty("FixedAffixCost")] public JToken? FixedAffixCostRaw { get; set; }
public uint MaxLevel => LevelLimitId switch
{
@@ -23,12 +27,19 @@ public class SupportCardExcel : ExcelResource
_ => 10
};
// Number of affixes granted initially
public int InitialAffixCount => Color >= 5 ? 2 : 1;
// Total maximum affixes (including ones unlocked at max level)
public int TotalAffixCount => Color >= 5 ? 3 : 2;
[JsonIgnore]
public IReadOnlyList<uint> AffixCost => ParseFlatCost(AffixCostRaw);
[JsonIgnore]
public IReadOnlyList<IReadOnlyList<uint>> InitialAffixCost => ParseNestedCost(InitialAffixCostRaw);
[JsonIgnore]
public IReadOnlyList<uint> FixedAffixCost => ParseFlatCost(FixedAffixCostRaw);
public ulong TemplateId => GameResourceTemplateId.FromGdpl(Genre, Detail, Particular, Level);
public override uint GetId() => Icon;
@@ -37,4 +48,23 @@ public class SupportCardExcel : ExcelResource
{
GameData.SupportCardData.Add(this);
}
private static IReadOnlyList<uint> ParseFlatCost(JToken? token)
{
if (token is not JArray array)
return [];
return array.Select(x => x.Value<uint>()).ToArray();
}
private static IReadOnlyList<IReadOnlyList<uint>> ParseNestedCost(JToken? token)
{
if (token is not JArray outer)
return [];
var result = new List<IReadOnlyList<uint>>();
foreach (var entry in outer.OfType<JArray>())
result.Add(entry.Select(x => x.Value<uint>()).ToArray());
return result;
}
}

18
Common/Data/Excel/SupportFixedExcel.cs Normal file
View File

@@ -0,0 +1,18 @@
using Newtonsoft.Json;
namespace MikuSB.Data.Excel;
[ResourceEntity("item/support/fixed.json")]
public class SupportFixedExcel : ExcelResource
{
[JsonProperty("ID")] public int Id { get; set; }
public int Num { get; set; }
public List<uint> Item { get; set; } = [];
public override uint GetId() => (uint)Id;
public override void Loaded()
{
GameData.SupportFixedData[Id] = this;
}
}

1
Common/Data/GameData.cs
View File

@@ -25,6 +25,7 @@ public static class GameData
public static List<SupportCardExcel> SupportCardData { get; private set; } = [];
public static Dictionary<int, SupportAffixExcel> SupportAffixData { get; private set; } = [];
public static Dictionary<int, SupportAffixPoolExcel> SupportAffixPoolData { get; private set; } = [];
public static Dictionary<int, SupportFixedExcel> SupportFixedData { get; private set; } = [];
public static Dictionary<uint, WeaponSkinExcel> WeaponSkinData { get; private set; } = [];
public static Dictionary<uint, DailyLevelExcel> DailyLevelData { get; private set; } = [];
public static Dictionary<uint, ProfileExcel> ProfileData { get; private set; } = [];

22
Common/Database/Inventory/InventoryData.cs
View File

@@ -1,4 +1,4 @@
using MikuSB.Enums.Item;
using MikuSB.Enums.Item;
using MikuSB.Proto;
using SqlSugar;
@@ -10,19 +10,19 @@ public class InventoryData : BaseDatabaseDataHelper
public uint NextUniqueUid { get; set; } = 100000;
[SugarColumn(IsJson = true)]
public Dictionary<uint, BaseGameItemInfo> Items { get; set; } = []; // Key: UniqueId
public Dictionary<uint, BaseGameItemInfo> Items { get; set; } = [];
[SugarColumn(IsJson = true)]
public Dictionary<uint, GameWeaponInfo> Weapons { get; set; } = []; // Key: UniqueId
public Dictionary<uint, GameWeaponInfo> Weapons { get; set; } = [];
[SugarColumn(IsJson = true)]
public Dictionary<uint, GameSkinInfo> Skins { get; set; } = []; // Key: UniqueId
public Dictionary<uint, GameSkinInfo> Skins { get; set; } = [];
[SugarColumn(IsJson = true)]
public Dictionary<uint, GameSupportCardInfo> SupportCards { get; set; } = []; // Key: UniqueId
public Dictionary<uint, GameSupportCardInfo> SupportCards { get; set; } = [];
[SugarColumn(IsJson = true)]
public Dictionary<uint, uint> SkinTypesBySkinId { get; set; } = []; // Key: nSkinId, Value: client nType
public Dictionary<uint, uint> SkinTypesBySkinId { get; set; } = [];
}
public class BaseGameItemInfo
@@ -63,6 +63,7 @@ public abstract class GrowableItemInfo : BaseGameItemInfo
public class GameWeaponInfo : GrowableItemInfo
{
[SugarColumn(IsJson = true)] public Dictionary<uint, ulong> PartSlots { get; set; } = [];
public override Item ToProto()
{
var proto = new Item
@@ -79,14 +80,17 @@ public class GameWeaponInfo : GrowableItemInfo
Evolue = Evolue
}
};
foreach (var (slot, uid) in PartSlots) proto.Slots[slot] = uid;
foreach (var (slot, uid) in PartSlots)
proto.Slots[slot] = uid;
return proto;
}
}
public class GameSkinInfo : BaseGameItemInfo
{
[SugarColumn(IsJson = true)] public Dictionary<uint, ulong> PartSlots { get; set; } = [];
public uint SkinType { get; set; }
public override Item ToProto()
{
var proto = new Item
@@ -97,12 +101,12 @@ public class GameSkinInfo : BaseGameItemInfo
Flag = (uint)Flag,
};
proto.Slots[(uint)ItemSkinSlotTypeEnum.SLOT_CARD_SKIL_TYPE] = Math.Min(SkinType, 1);
foreach (var (slot, uid) in PartSlots) proto.Slots[slot] = uid;
foreach (var (slot, uid) in PartSlots)
proto.Slots[slot] = uid;
return proto;
}
}
public class GameSupportCardInfo : BaseGameItemInfo
{
public uint AffixId { get; set; }

5
GameServer/Game/Inventory/InventoryManager.cs
View File

@@ -136,7 +136,7 @@ public class InventoryManager(PlayerInstance player) : BasePlayerManager(player)
ItemType = genre,
ItemCount = 1,
Level = cardLevel,
AffixId = 1,
AffixId = 0,
};
var affixCount = cardLevel >= spCard.MaxLevel ? spCard.TotalAffixCount : spCard.InitialAffixCount;
@@ -144,8 +144,7 @@ public class InventoryManager(PlayerInstance player) : BasePlayerManager(player)
{
var (affixId, tier) = SupportAffixService.GenerateRandomAffix(spCard.AffixPool[i]);
if (affixId == 0) continue;
info.Affixs.Add(affixId);
info.Affixs.Add(tier);
SupportAffixStateService.SetAffix(info, i + 1, affixId, tier);
}
InventoryData.SupportCards[info.UniqueId] = info;

16
GameServer/Game/Support/SupportAffixService.cs
View File

@@ -4,8 +4,7 @@ namespace MikuSB.GameServer.Game.Support;
public static class SupportAffixService
{
// Returns (affixId, tier) - both 1-based. Returns (0,0) if pool not found.
public static (uint AffixId, uint Tier) GenerateRandomAffix(int poolId)
public static (uint AffixId, uint Tier) GenerateRandomAffix(int poolId, IEnumerable<uint>? excludedAffixIds = null)
{
if (!GameData.SupportAffixPoolData.TryGetValue(poolId, out var pool))
return (0, 0);
@@ -32,9 +31,20 @@ public static class SupportAffixService
if (selectedAffixs.Count == 0)
return (0, 0);
var affixId = selectedAffixs[Random.Shared.Next(selectedAffixs.Count)];
var excluded = excludedAffixIds?.ToHashSet() ?? [];
var candidates = selectedAffixs.Where(x => !excluded.Contains((uint)x)).ToList();
if (candidates.Count == 0)
candidates = selectedAffixs.ToList();
var affixId = candidates[Random.Shared.Next(candidates.Count)];
var tierCount = GameData.SupportAffixData.GetValueOrDefault(affixId)?.TierCount ?? 5;
var tier = (uint)(Random.Shared.Next(tierCount) + 1);
return ((uint)affixId, tier);
}
public static uint GenerateTier(uint affixId)
{
var tierCount = GameData.SupportAffixData.GetValueOrDefault((int)affixId)?.TierCount ?? 5;
return (uint)(Random.Shared.Next(tierCount) + 1);
}
}

70
GameServer/Game/Support/SupportAffixStateService.cs Normal file
View File

@@ -0,0 +1,70 @@
using MikuSB.Database.Inventory;
namespace MikuSB.GameServer.Game.Support;
public static class SupportAffixStateService
{
public const int PairSize = 2;
public const int MaxLogicalSlots = 5;
public const int ActiveThirdAffixSlot = 3;
public const int PendingMaxAffixSlot = 4;
public const int PendingInitialAffixSlot = 5;
public static void EnsureCapacity(GameSupportCardInfo card, int logicalSlot = MaxLogicalSlots)
{
var minCount = Math.Clamp(logicalSlot, 1, MaxLogicalSlots) * PairSize;
while (card.Affixs.Count < minCount)
card.Affixs.Add(0);
}
public static (uint AffixId, uint Tier) GetAffix(GameSupportCardInfo card, int logicalSlot)
{
if (logicalSlot < 1 || logicalSlot > MaxLogicalSlots)
return (0, 0);
var index = (logicalSlot - 1) * PairSize;
if (card.Affixs.Count <= index + 1)
return (0, 0);
return (card.Affixs[index], card.Affixs[index + 1]);
}
public static bool HasAffix(GameSupportCardInfo card, int logicalSlot)
{
var (affixId, tier) = GetAffix(card, logicalSlot);
return affixId > 0 && tier > 0;
}
public static void SetAffix(GameSupportCardInfo card, int logicalSlot, uint affixId, uint tier)
{
if (logicalSlot < 1 || logicalSlot > MaxLogicalSlots)
return;
EnsureCapacity(card, logicalSlot);
var index = (logicalSlot - 1) * PairSize;
card.Affixs[index] = affixId;
card.Affixs[index + 1] = tier;
}
public static void ClearAffix(GameSupportCardInfo card, int logicalSlot)
{
SetAffix(card, logicalSlot, 0, 0);
}
public static void CopyAffix(GameSupportCardInfo card, int fromSlot, int toSlot)
{
var (affixId, tier) = GetAffix(card, fromSlot);
SetAffix(card, toSlot, affixId, tier);
}
public static uint GetVisibleInitialAffixIndex(GameSupportCardInfo card)
{
return HasAffix(card, PendingInitialAffixSlot) ? card.AffixId : 0;
}
public static void NormalizePendingState(GameSupportCardInfo card)
{
if (!HasAffix(card, PendingInitialAffixSlot))
card.AffixId = 0;
}
}

153
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCardAffixShared.cs Normal file
View File

@@ -0,0 +1,153 @@
using MikuSB.Data;
using MikuSB.Data.Excel;
using MikuSB.Database;
using MikuSB.Database.Inventory;
using MikuSB.Database.Player;
using MikuSB.GameServer.Game.Support;
using MikuSB.Proto;
using System.Text.Json.Serialization;
namespace MikuSB.GameServer.Server.CallGS.Handlers.SupporterCard;
internal static class SupporterCardAffixShared
{
public const uint BaseGid = 150;
public const uint FixedResetSid = 1;
public static SupportCardExcel? GetExcel(GameSupportCardInfo card)
{
return GameData.SupportCardData.FirstOrDefault(x => x.TemplateId == card.TemplateId);
}
public static async Task SendResetResponse(Connection connection, NtfSyncPlayer? sync = null)
{
await CallGSRouter.SendScript(connection, "SupporterCard_ResetAffix", "null", sync!);
}
public static async Task SendSelectResponse(Connection connection, NtfSyncPlayer? sync = null)
{
await CallGSRouter.SendScript(connection, "SupporterCard_SelectAffix", "null", sync!);
}
public static List<Item> ConsumeCostItems(Connection connection, IEnumerable<IReadOnlyList<uint>> costs)
{
var player = connection.Player!;
var syncItems = new List<Item>();
foreach (var cost in costs)
{
if (cost.Count < 5)
continue;
var templateId = GameResourceTemplateId.FromGdpl(cost);
var item = player.InventoryManager.InventoryData.Items.Values.FirstOrDefault(x => x.TemplateId == templateId);
if (item == null || item.ItemCount < cost[4])
throw new InvalidOperationException("support affix material not enough");
item.ItemCount -= cost[4];
var proto = item.ToProto();
if (item.ItemCount == 0)
{
player.InventoryManager.InventoryData.Items.Remove(item.UniqueId);
proto.Count = 0;
}
syncItems.Add(proto);
}
return syncItems;
}
public static bool HasEnoughItems(Connection connection, IEnumerable<IReadOnlyList<uint>> costs)
{
var items = connection.Player!.InventoryManager.InventoryData.Items.Values;
return costs.All(cost =>
{
if (cost.Count < 5)
return false;
var templateId = GameResourceTemplateId.FromGdpl(cost);
var item = items.FirstOrDefault(x => x.TemplateId == templateId);
return item != null && item.ItemCount >= cost[4];
});
}
public static PlayerAttr GetOrCreateAttr(PlayerGameData data, uint gid, uint sid)
{
var attr = data.Attrs.FirstOrDefault(x => x.Gid == gid && x.Sid == sid);
if (attr != null)
return attr;
attr = new PlayerAttr { Gid = gid, Sid = sid, Val = 0 };
data.Attrs.Add(attr);
return attr;
}
public static void SetAttr(Connection connection, NtfSyncPlayer sync, uint gid, uint sid, uint value)
{
var player = connection.Player!;
var attr = GetOrCreateAttr(player.Data, gid, sid);
attr.Val = value;
sync.Custom[player.ToPackedAttrKey(gid, sid)] = value;
sync.Custom[player.ToShiftedAttrKey(gid, sid)] = value;
}
public static IEnumerable<uint> GetActiveAffixIds(GameSupportCardInfo card, params int[] ignoreSlots)
{
var ignored = ignoreSlots.ToHashSet();
for (var slot = 1; slot <= SupportAffixStateService.ActiveThirdAffixSlot; slot++)
{
if (ignored.Contains(slot))
continue;
var (affixId, _) = SupportAffixStateService.GetAffix(card, slot);
if (affixId > 0)
yield return affixId;
}
}
public static void Save(Connection connection)
{
var player = connection.Player!;
DatabaseHelper.SaveDatabaseType(player.InventoryManager.InventoryData);
DatabaseHelper.SaveDatabaseType(player.Data);
}
}
internal sealed class SupporterCardIdParam
{
[JsonPropertyName("Id")]
public int SupportCardUid { get; set; }
}
internal sealed class SupporterCardSelectParam
{
[JsonPropertyName("Id")]
public int SupportCardUid { get; set; }
[JsonPropertyName("SelectNew")]
public bool SelectNew { get; set; }
}
internal sealed class SupporterCardResetInitialParam
{
[JsonPropertyName("Id")]
public int SupportCardUid { get; set; }
[JsonPropertyName("Index")]
public int Index { get; set; }
[JsonPropertyName("FixedId")]
public uint FixedId { get; set; }
}
internal sealed class SupporterCardSelectInitialParam
{
[JsonPropertyName("Id")]
public int SupportCardUid { get; set; }
[JsonPropertyName("Index")]
public int Index { get; set; }
[JsonPropertyName("SelectNew")]
public bool SelectNew { get; set; }
}

10
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_FixedResetInitialAffix.cs Normal file
View File

@@ -0,0 +1,10 @@
namespace MikuSB.GameServer.Server.CallGS.Handlers.SupporterCard;
[CallGSApi("SupporterCard_FixedResetInitialAffix")]
public class SupporterCard_FixedResetInitialAffix : ICallGSHandler
{
public async Task Handle(Connection connection, string param, ushort seqNo)
{
await SupporterCard_ResetInitialAffix.Reset(connection, param, fixedMode: true);
}
}

57
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_ReceiveFixedItem.cs Normal file
View File

@@ -0,0 +1,57 @@
using MikuSB.Data;
using MikuSB.Proto;
using System.Text.Json.Nodes;
namespace MikuSB.GameServer.Server.CallGS.Handlers.SupporterCard;
[CallGSApi("SupporterCard_ReceiveFixedItem")]
public class SupporterCard_ReceiveFixedItem : ICallGSHandler
{
public async Task Handle(Connection connection, string param, ushort seqNo)
{
var player = connection.Player!;
if (!GameData.SupportFixedData.TryGetValue(1, out var fixedCfg) || fixedCfg.Item.Count < 5 || fixedCfg.Num <= 0)
{
await CallGSRouter.SendScript(connection, "SupporterCard_ReceiveFixedItem", "{}");
return;
}
var attr = SupporterCardAffixShared.GetOrCreateAttr(player.Data, SupporterCardAffixShared.BaseGid, SupporterCardAffixShared.FixedResetSid);
var claimCount = attr.Val / (uint)fixedCfg.Num;
if (claimCount == 0)
{
await CallGSRouter.SendScript(connection, "SupporterCard_ReceiveFixedItem", "{}");
return;
}
attr.Val %= (uint)fixedCfg.Num;
var rewardTemplateId = (uint)GameResourceTemplateId.FromGdpl(fixedCfg.Item);
var rewardItem = GameData.SuppliesData.GetValueOrDefault(rewardTemplateId);
if (rewardItem == null)
{
await CallGSRouter.SendScript(connection, "SupporterCard_ReceiveFixedItem", "{}");
return;
}
var granted = await player.InventoryManager.AddSuppliesItem(rewardItem, claimCount * fixedCfg.Item[4], sendPacket: false);
var sync = new NtfSyncPlayer();
if (granted != null)
sync.Items.Add(granted.ToProto());
SupporterCardAffixShared.SetAttr(connection, sync, SupporterCardAffixShared.BaseGid, SupporterCardAffixShared.FixedResetSid, attr.Val);
SupporterCardAffixShared.Save(connection);
var arg = new JsonObject
{
["tbRewards"] = new JsonArray(
(int)fixedCfg.Item[0],
(int)fixedCfg.Item[1],
(int)fixedCfg.Item[2],
(int)fixedCfg.Item[3],
(int)(claimCount * fixedCfg.Item[4]))
}.ToJsonString();
await CallGSRouter.SendScript(connection, "SupporterCard_ReceiveFixedItem", arg, sync);
}
}

38
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_ResetAffix.cs Normal file
View File

@@ -0,0 +1,38 @@
using MikuSB.GameServer.Game.Support;
using MikuSB.Proto;
using System.Text.Json;
namespace MikuSB.GameServer.Server.CallGS.Handlers.SupporterCard;
[CallGSApi("SupporterCard_ResetAffix")]
public class SupporterCard_ResetAffix : ICallGSHandler
{
public async Task Handle(Connection connection, string param, ushort seqNo)
{
var req = JsonSerializer.Deserialize<SupporterCardIdParam>(param);
var card = req == null ? null : connection.Player!.InventoryManager.GetSupportCardItem((uint)req.SupportCardUid);
var excel = card == null ? null : SupporterCardAffixShared.GetExcel(card);
if (card == null || excel == null || excel.AffixCost.Count < 5 || !SupportAffixStateService.HasAffix(card, SupportAffixStateService.ActiveThirdAffixSlot))
{
await SupporterCardAffixShared.SendResetResponse(connection);
return;
}
var costs = new[] { excel.AffixCost };
if (!SupporterCardAffixShared.HasEnoughItems(connection, costs))
{
await SupporterCardAffixShared.SendResetResponse(connection);
return;
}
var sync = new NtfSyncPlayer();
sync.Items.AddRange(SupporterCardAffixShared.ConsumeCostItems(connection, costs));
var excluded = SupporterCardAffixShared.GetActiveAffixIds(card, SupportAffixStateService.ActiveThirdAffixSlot);
var (affixId, tier) = SupportAffixService.GenerateRandomAffix(excel.AffixPool[SupportAffixStateService.ActiveThirdAffixSlot - 1], excluded);
SupportAffixStateService.SetAffix(card, SupportAffixStateService.PendingMaxAffixSlot, affixId, tier);
sync.Items.Add(card.ToProto());
SupporterCardAffixShared.Save(connection);
await SupporterCardAffixShared.SendResetResponse(connection, sync);
}
}

60
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_ResetInitialAffix.cs Normal file
View File

@@ -0,0 +1,60 @@
using MikuSB.GameServer.Game.Support;
using MikuSB.Proto;
using System.Text.Json;
namespace MikuSB.GameServer.Server.CallGS.Handlers.SupporterCard;
[CallGSApi("SupporterCard_ResetInitialAffix")]
public class SupporterCard_ResetInitialAffix : ICallGSHandler
{
public async Task Handle(Connection connection, string param, ushort seqNo)
{
await Reset(connection, param, fixedMode: false);
}
internal static async Task Reset(Connection connection, string param, bool fixedMode)
{
var req = JsonSerializer.Deserialize<SupporterCardResetInitialParam>(param);
var card = req == null ? null : connection.Player!.InventoryManager.GetSupportCardItem((uint)req.SupportCardUid);
var excel = card == null ? null : SupporterCardAffixShared.GetExcel(card);
if (req == null || card == null || excel == null || req.Index is < 1 or > 2 || excel.AffixPool.Count < req.Index)
{
await SupporterCardAffixShared.SendResetResponse(connection);
return;
}
var costs = fixedMode ? new[] { excel.FixedAffixCost } : excel.InitialAffixCost;
if (!costs.Any() || !SupporterCardAffixShared.HasEnoughItems(connection, costs))
{
await SupporterCardAffixShared.SendResetResponse(connection);
return;
}
var sync = new NtfSyncPlayer();
sync.Items.AddRange(SupporterCardAffixShared.ConsumeCostItems(connection, costs));
uint affixId;
uint tier;
if (fixedMode && req.FixedId > 0)
{
affixId = req.FixedId;
tier = SupportAffixService.GenerateTier(affixId);
}
else
{
var excluded = SupporterCardAffixShared.GetActiveAffixIds(card, req.Index);
(affixId, tier) = SupportAffixService.GenerateRandomAffix(excel.AffixPool[req.Index - 1], excluded);
}
SupportAffixStateService.SetAffix(card, SupportAffixStateService.PendingInitialAffixSlot, affixId, tier);
card.AffixId = (uint)req.Index;
var attr = SupporterCardAffixShared.GetOrCreateAttr(connection.Player!.Data, SupporterCardAffixShared.BaseGid, SupporterCardAffixShared.FixedResetSid);
attr.Val += 1;
SupporterCardAffixShared.SetAttr(connection, sync, SupporterCardAffixShared.BaseGid, SupporterCardAffixShared.FixedResetSid, attr.Val);
sync.Items.Add(card.ToProto());
SupporterCardAffixShared.Save(connection);
await SupporterCardAffixShared.SendResetResponse(connection, sync);
}
}

30
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_SelectAffix.cs Normal file
View File

@@ -0,0 +1,30 @@
using MikuSB.GameServer.Game.Support;
using MikuSB.Proto;
using System.Text.Json;
namespace MikuSB.GameServer.Server.CallGS.Handlers.SupporterCard;
[CallGSApi("SupporterCard_SelectAffix")]
public class SupporterCard_SelectAffix : ICallGSHandler
{
public async Task Handle(Connection connection, string param, ushort seqNo)
{
var req = JsonSerializer.Deserialize<SupporterCardSelectParam>(param);
var card = req == null ? null : connection.Player!.InventoryManager.GetSupportCardItem((uint)req.SupportCardUid);
if (card == null || !SupportAffixStateService.HasAffix(card, SupportAffixStateService.PendingMaxAffixSlot))
{
await SupporterCardAffixShared.SendSelectResponse(connection);
return;
}
if (req!.SelectNew)
SupportAffixStateService.CopyAffix(card, SupportAffixStateService.PendingMaxAffixSlot, SupportAffixStateService.ActiveThirdAffixSlot);
SupportAffixStateService.ClearAffix(card, SupportAffixStateService.PendingMaxAffixSlot);
var sync = new NtfSyncPlayer();
sync.Items.Add(card.ToProto());
SupporterCardAffixShared.Save(connection);
await SupporterCardAffixShared.SendSelectResponse(connection, sync);
}
}

31
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_SelectInitialAffix.cs Normal file
View File

@@ -0,0 +1,31 @@
using MikuSB.GameServer.Game.Support;
using MikuSB.Proto;
using System.Text.Json;
namespace MikuSB.GameServer.Server.CallGS.Handlers.SupporterCard;
[CallGSApi("SupporterCard_SelectInitialAffix")]
public class SupporterCard_SelectInitialAffix : ICallGSHandler
{
public async Task Handle(Connection connection, string param, ushort seqNo)
{
var req = JsonSerializer.Deserialize<SupporterCardSelectInitialParam>(param);
var card = req == null ? null : connection.Player!.InventoryManager.GetSupportCardItem((uint)req.SupportCardUid);
if (req == null || card == null || req.Index is < 1 or > 2 || card.AffixId != req.Index || !SupportAffixStateService.HasAffix(card, SupportAffixStateService.PendingInitialAffixSlot))
{
await SupporterCardAffixShared.SendSelectResponse(connection);
return;
}
if (req.SelectNew)
SupportAffixStateService.CopyAffix(card, SupportAffixStateService.PendingInitialAffixSlot, req.Index);
SupportAffixStateService.ClearAffix(card, SupportAffixStateService.PendingInitialAffixSlot);
card.AffixId = 0;
var sync = new NtfSyncPlayer();
sync.Items.Add(card.ToProto());
SupporterCardAffixShared.Save(connection);
await SupporterCardAffixShared.SendSelectResponse(connection, sync);
}
}

8
GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_Upgrade.cs
View File

@@ -86,17 +86,15 @@ public class SupporterCard_Upgrade : ICallGSHandler
// Unlock next affix slot when reaching max level for the first time
if (supportCardExcel != null)
{
var currentSlots = supportCard.Affixs.Count / 2;
var currentSlots = Enumerable.Range(1, SupportAffixStateService.ActiveThirdAffixSlot)
.Count(slot => SupportAffixStateService.HasAffix(supportCard, slot));
var totalSlots = supportCardExcel.TotalAffixCount;
if (currentSlots < totalSlots && currentSlots < supportCardExcel.AffixPool.Count)
{
var poolId = supportCardExcel.AffixPool[currentSlots];
var (affixId, tier) = SupportAffixService.GenerateRandomAffix(poolId);
if (affixId > 0)
{
supportCard.Affixs.Add(affixId);
supportCard.Affixs.Add(tier);
}
SupportAffixStateService.SetAffix(supportCard, currentSlots + 1, affixId, tier);
}
}
}

22
GameServer/Server/Packet/Send/Misc/PacketNtfCallScript.cs
View File

@@ -1,6 +1,8 @@
using MikuSB.Database.Character;
using MikuSB.Database.Character;
using MikuSB.Database.Inventory;
using MikuSB.Enums.Item;
using MikuSB.GameServer.Game.Player;
using MikuSB.GameServer.Game.Support;
using MikuSB.Proto;
using MikuSB.TcpSharp;
@@ -10,14 +12,14 @@ public class PacketNtfCallScript : BasePacket
{
public PacketNtfCallScript(List<CharacterInfo> characters) : base(CmdIds.NtfScript)
{
var proto = new NtfCallScript
{
var proto = new NtfCallScript
{
Api = "",
Arg = "{}",
ExtraSync = new NtfSyncPlayer
{
Items = { characters.Select(x => x.ToProto()) }
}
}
};
SetData(proto);
@@ -61,7 +63,7 @@ public class PacketNtfCallScript : BasePacket
Arg = "{}",
ExtraSync = new NtfSyncPlayer
{
Items = { cards.Select(x => x.ToProto()) }
Items = { cards.Select(ToSupportCardProto) }
}
};
@@ -95,7 +97,7 @@ public class PacketNtfCallScript : BasePacket
foreach (var item in inventory.Items.Values) extraSync.Items.Add(item.ToProto());
foreach (var skin in inventory.Skins.Values) extraSync.Items.Add(skin.ToProto());
foreach (var weapon in inventory.Weapons.Values) extraSync.Items.Add(weapon.ToProto());
foreach (var supportCard in inventory.SupportCards.Values) extraSync.Items.Add(supportCard.ToProto());
foreach (var supportCard in inventory.SupportCards.Values) extraSync.Items.Add(ToSupportCardProto(supportCard));
proto.ExtraSync = extraSync;
SetData(proto);
}
@@ -128,4 +130,12 @@ public class PacketNtfCallScript : BasePacket
SetData(proto);
}
private static Item ToSupportCardProto(GameSupportCardInfo card)
{
SupportAffixStateService.NormalizePendingState(card);
var proto = card.ToProto();
proto.Slots[(uint)ItemSupportCardSlotTypeEnum.SLOT_AFFIXINDEX] = SupportAffixStateService.GetVisibleInitialAffixIndex(card);
return proto;
}
}

2
version.txt
View File

@@ -1 +1 @@
v=3.1
v=3.2