Update version.txt

Common/Data/Excel/BossPvpBossChallengeExcel.cs

@@ -0,0 +1,32 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Globalization;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/bosspvp/boss_challenge.json")]
+public class BossPvpBossChallengeExcel : ExcelResource
+{
+    public uint ID { get; set; }
+    public string StartTime { get; set; } = "";
+    public string EndTime { get; set; } = "";
+    public List<uint> tbTaskID { get; set; } = [];
+
+    [JsonExtensionData] public IDictionary<string, JToken> ExtraData { get; set; } = new Dictionary<string, JToken>();
+
+    [JsonIgnore] public List<uint> BossIds { get; private set; } = [];
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        BossIds = ExtraData
+            .Where(x => x.Key.StartsWith("Boss", StringComparison.Ordinal) && int.TryParse(x.Key[4..], out _))
+            .OrderBy(x => int.Parse(x.Key[4..], CultureInfo.InvariantCulture))
+            .Select(x => x.Value.Type == JTokenType.Integer ? x.Value.Value<uint>() : 0u)
+            .Where(x => x > 0)
+            .ToList();
+
+        GameData.BossPvpBossChallengeData[ID] = this;
+    }
+}

Common/Data/Excel/BossPvpBossExcel.cs

@@ -0,0 +1,17 @@
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/bosspvp/boss.json")]
+public class BossPvpBossExcel : ExcelResource
+{
+    public uint ID { get; set; }
+    public uint LevelID { get; set; }
+    public uint BossID { get; set; }
+    public List<List<int>> BossLevel { get; set; } = [];
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        GameData.BossPvpBossData[ID] = this;
+    }
+}

Common/Data/Excel/BossPvpNumExcel.cs

@@ -0,0 +1,15 @@
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/bosspvp/num.json")]
+public class BossPvpNumExcel : ExcelResource
+{
+    public uint Week { get; set; }
+    public uint Num { get; set; }
+
+    public override uint GetId() => Week;
+
+    public override void Loaded()
+    {
+        GameData.BossPvpNumData[Week] = this;
+    }
+}

Common/Data/Excel/RoleLevelExcel.cs

@@ -0,0 +1,14 @@
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/role/level.json")]
+public class RoleLevelExcel : ExcelResource
+{
+    public uint ID { get; set; }
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        GameData.RoleLevelData[ID] = this;
+    }
+}

Common/Data/Excel/SpecialBreakExcel.cs

@@ -0,0 +1,39 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("item/cardbreak/breaknew.json")]
+public class SpecialBreakExcel : ExcelResource
+{
+    [JsonProperty("ID")] public int Id { get; set; }
+
+    [JsonProperty("1Items1")] public List<List<int>> Items1 { get; set; } = [];
+    [JsonProperty("2Items1")] public List<List<int>> Items2 { get; set; } = [];
+    [JsonProperty("3Items1")] public List<List<int>> Items3 { get; set; } = [];
+    [JsonProperty("4Items1")] public List<List<int>> Items4 { get; set; } = [];
+
+    public List<List<int>> GetItems(uint breakLevel) => breakLevel switch
+    {
+        1 => Items1,
+        2 => Items2,
+        3 => Items3,
+        4 => Items4,
+        _ => []
+    };
+
+    public bool HasBreakLevel(uint breakLevel) => breakLevel switch
+    {
+        1 => Items1.Count > 0,
+        2 => Items2.Count > 0,
+        3 => Items3.Count > 0,
+        4 => Items4.Count > 0,
+        _ => false
+    };
+
+    public override uint GetId() => (uint)Id;
+
+    public override void Loaded()
+    {
+        GameData.SpecialBreakData[Id] = this;
+    }
+}

Common/Data/GameData.cs

@@ -13,6 +13,7 @@ public static class GameData
     public static Dictionary<int, BreakLevelLimitExcel> BreakLevelLimitData { get; private set; } = [];
     public static Dictionary<int, RecycleExcel> RecycleData { get; private set; } = [];
     public static Dictionary<uint, ChapterLevelExcel> ChapterLevelData { get; private set; } = [];
+    public static Dictionary<uint, RoleLevelExcel> RoleLevelData { get; private set; } = [];
     public static Dictionary<uint, ArItemExcel> ArItemData { get; private set; } = [];
     public static Dictionary<uint, ManifestationExcel> ManifestationData { get; private set; } = [];
     public static Dictionary<uint, Rogue3DDifficultExcel> Rogue3DDifficultData { get; private set; } = [];
@@ -20,6 +21,7 @@ public static class GameData
     public static Dictionary<uint, Rogue3DTalentExcel> Rogue3DTalentData { get; private set; } = [];
     public static Dictionary<uint, Rogue3DDailyBuffExcel> Rogue3DDailyBuffData { get; private set; } = [];
     public static Dictionary<int, BreakExcel> BreakData { get; private set; } = [];
+    public static Dictionary<int, SpecialBreakExcel> SpecialBreakData { get; private set; } = [];
     public static Dictionary<uint, SpineExcel> SpineData { get; private set; } = [];
     public static Dictionary<uint, NodeConditionExcel> NodeConditionData { get; private set; } = [];
     public static List<SupportCardExcel> SupportCardData { get; private set; } = [];
@@ -28,6 +30,9 @@ public static class GameData
     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, BossPvpBossChallengeExcel> BossPvpBossChallengeData { get; private set; } = [];
+    public static Dictionary<uint, BossPvpBossExcel> BossPvpBossData { get; private set; } = [];
+    public static Dictionary<uint, BossPvpNumExcel> BossPvpNumData { get; private set; } = [];
     public static Dictionary<uint, ProfileExcel> ProfileData { get; private set; } = [];
     public static Dictionary<uint, CardSkinPartsExcel> CardSkinPartsData { get; private set; } = [];
     public static Dictionary<uint, CallItemExcel> CallItemData { get; private set; } = [];

GameServer/Game/BossPvp/BossPvpService.cs

@@ -0,0 +1,498 @@
+using MikuSB.Data;
+using MikuSB.Data.Excel;
+using MikuSB.Database.Inventory;
+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.Game.BossPvp;
+
+internal static class BossPvpService
+{
+    private const uint GroupId = 51;
+    private const uint ActivitySubId = 0;
+    private const uint ChallengeNumSid = 1;
+    private const uint DiffStartId = 10;
+    private const uint LevelStartSid = 100;
+    private const uint LevelStride = 10;
+    private const uint BossLineup1 = 15;
+    private const uint BossLineup2 = 16;
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+
+    public static async ValueTask<(object Response, NtfSyncPlayer Sync)> HandleGetOpenIdAsync(PlayerInstance player)
+    {
+        await EnsureBossLineupsAsync(player);
+
+        var sync = new NtfSyncPlayer();
+        var season = GetOpenSeason();
+        var seasonId = season?.ID ?? 1u;
+
+        SetStr(player, ActivitySubId, seasonId.ToString(CultureInfo.InvariantCulture), sync);
+        SetStr(player, ChallengeNumSid, GetDailyChallengeNum().ToString(CultureInfo.InvariantCulture), sync);
+
+        if (season != null)
+        {
+            for (var index = 0; index < season.BossIds.Count; index++)
+            {
+                var bossLevelId = season.BossIds[index];
+                EnsureStr(player, DiffStartId + (uint)(index + 1), "0", sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 1), EmptySnapshotJson(), sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 2), EmptySnapshotJson(), sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 3), EmptySnapshotJson(), sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 4), "0", sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 5), "0", sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 6), "0", sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 7), "0", sync);
+                EnsureStr(player, GetBossSid(bossLevelId, 8), "0", sync);
+            }
+        }
+
+        var response = new
+        {
+            nID = seasonId,
+            tbTimeCfg = new[]
+            {
+                new
+                {
+                    nStartTime = -1,
+                    nEndTime = -1
+                }
+            }
+        };
+
+        return (response, sync);
+    }
+
+    public static object HandleEnterLevel(string? param)
+    {
+        var req = Deserialize<EnterLevelParam>(param);
+        return new
+        {
+            nSeed = Random.Shared.Next(1, int.MaxValue),
+            nID = req?.NId ?? 0
+        };
+    }
+
+    public static (object Response, NtfSyncPlayer Sync) HandleRecord(PlayerInstance player, string? param)
+    {
+        var req = Deserialize<RecordParam>(param);
+        if (req == null)
+        {
+            return (new { bRecord = false }, new NtfSyncPlayer());
+        }
+
+        var sync = new NtfSyncPlayer();
+        if (req.BRecord)
+        {
+            var historyScore = ReadInt(player, GetBossSid(req.NId, 4));
+            var currentScore = ComputeIntegral(req.NId, req.NDiff, req.ResidueTime);
+            if (currentScore >= historyScore)
+            {
+                WriteBestRun(player, req.NId, req.NTeamId, req.NTime, currentScore, sync);
+            }
+        }
+
+        return (new { bRecord = req.BRecord }, sync);
+    }
+
+    public static (JsonNode Response, NtfSyncPlayer Sync) HandleSettlement(PlayerInstance player, JsonNode? param)
+    {
+        var req = param?.Deserialize<SettlementParam>(JsonOptions);
+        var sync = new NtfSyncPlayer();
+        if (req == null)
+        {
+            return (new JsonObject(), sync);
+        }
+
+        var totalSid = GetBossSid(req.NId, 7);
+        var successSid = GetBossSid(req.NId, 6);
+        var diffSid = GetBossSid(req.NId, 8);
+
+        SetStr(player, totalSid, (ReadInt(player, totalSid) + 1).ToString(CultureInfo.InvariantCulture), sync);
+        SetStr(player, successSid, (ReadInt(player, successSid) + 1).ToString(CultureInfo.InvariantCulture), sync);
+
+        var clearedDiff = Math.Max(ReadInt(player, diffSid), req.NDiff);
+        SetStr(player, diffSid, clearedDiff.ToString(CultureInfo.InvariantCulture), sync);
+
+        var positionSid = TryGetPositionDiffSid(req.NId);
+        if (positionSid != null)
+        {
+            var newPositionDiff = Math.Max(ReadInt(player, positionSid.Value), req.NDiff);
+            SetStr(player, positionSid.Value, newPositionDiff.ToString(CultureInfo.InvariantCulture), sync);
+        }
+
+        var score = ComputeIntegral(req.NId, req.NDiff, req.ResidueTime);
+        if (score > ReadInt(player, GetBossSid(req.NId, 4)))
+        {
+            WriteBestRun(player, req.NId, req.NTeamId, req.NTime, score, sync);
+        }
+
+        return (new JsonObject(), sync);
+    }
+
+    public static (JsonNode Response, NtfSyncPlayer Sync) HandleFail(PlayerInstance player, JsonNode? param)
+    {
+        var req = param?.Deserialize<FailParam>(JsonOptions);
+        var sync = new NtfSyncPlayer();
+        if (req == null)
+        {
+            return (new JsonObject(), sync);
+        }
+
+        var totalSid = GetBossSid(req.NId, 7);
+        SetStr(player, totalSid, (ReadInt(player, totalSid) + 1).ToString(CultureInfo.InvariantCulture), sync);
+
+        return (new JsonObject(), sync);
+    }
+
+    public static (object Response, NtfSyncPlayer Sync) HandleMopup(PlayerInstance player, string? param)
+    {
+        var req = Deserialize<MopupParam>(param);
+        var sync = new NtfSyncPlayer();
+        if (req == null)
+        {
+            return (new { }, sync);
+        }
+
+        var totalSid = GetBossSid(req.NId, 7);
+        var successSid = GetBossSid(req.NId, 6);
+        var diffSid = GetBossSid(req.NId, 8);
+
+        SetStr(player, totalSid, (ReadInt(player, totalSid) + 1).ToString(CultureInfo.InvariantCulture), sync);
+        SetStr(player, successSid, (ReadInt(player, successSid) + 1).ToString(CultureInfo.InvariantCulture), sync);
+
+        var clearedDiff = Math.Max(ReadInt(player, diffSid), req.NDiff);
+        SetStr(player, diffSid, clearedDiff.ToString(CultureInfo.InvariantCulture), sync);
+
+        var positionSid = TryGetPositionDiffSid(req.NId);
+        if (positionSid != null)
+        {
+            var newPositionDiff = Math.Max(ReadInt(player, positionSid.Value), req.NDiff + 1);
+            SetStr(player, positionSid.Value, newPositionDiff.ToString(CultureInfo.InvariantCulture), sync);
+        }
+
+        var score = ComputeIntegral(req.NId, req.NDiff, 0);
+        if (score > ReadInt(player, GetBossSid(req.NId, 4)))
+        {
+            WriteBestRun(player, req.NId, 0, 0, score, sync);
+        }
+
+        return (new { }, sync);
+    }
+
+    public static object HandleGetReward(string? param)
+    {
+        _ = Deserialize<RewardParam>(param);
+        return new { tbAward = Array.Empty<object>() };
+    }
+
+    private static async ValueTask EnsureBossLineupsAsync(PlayerInstance player)
+    {
+        var lineups = player.LineupManager.LineupData.LineupInfo;
+        var baseLineup = lineups.GetValueOrDefault(1) ?? lineups.Values.FirstOrDefault();
+        if (baseLineup == null)
+        {
+            return;
+        }
+
+        if (!lineups.ContainsKey((int)BossLineup1))
+        {
+            await player.LineupManager.UpdateLineup((int)BossLineup1, baseLineup.Member1, baseLineup.Member2, baseLineup.Member3, true);
+        }
+
+        if (!lineups.ContainsKey((int)BossLineup2))
+        {
+            await player.LineupManager.UpdateLineup((int)BossLineup2, baseLineup.Member1, baseLineup.Member2, baseLineup.Member3, true);
+        }
+    }
+
+    private static void WriteBestRun(PlayerInstance player, uint bossLevelId, uint lineupId, double finishTime, int score, NtfSyncPlayer sync)
+    {
+        var snapshots = CaptureLineupSnapshots(player, lineupId);
+        SetStr(player, GetBossSid(bossLevelId, 1), System.Text.Json.JsonSerializer.Serialize(snapshots[0], JsonOptions), sync);
+        SetStr(player, GetBossSid(bossLevelId, 2), System.Text.Json.JsonSerializer.Serialize(snapshots[1], JsonOptions), sync);
+        SetStr(player, GetBossSid(bossLevelId, 3), System.Text.Json.JsonSerializer.Serialize(snapshots[2], JsonOptions), sync);
+        SetStr(player, GetBossSid(bossLevelId, 4), score.ToString(CultureInfo.InvariantCulture), sync);
+        SetStr(player, GetBossSid(bossLevelId, 5), Math.Max(0, (int)Math.Floor(finishTime)).ToString(CultureInfo.InvariantCulture), sync);
+    }
+
+    private static BossPvpRoleSnapshot[] CaptureLineupSnapshots(PlayerInstance player, uint lineupId)
+    {
+        var lineups = player.LineupManager.LineupData.LineupInfo;
+        var lineup = lineups.GetValueOrDefault((int)lineupId)
+            ?? lineups.GetValueOrDefault((int)BossLineup1)
+            ?? lineups.GetValueOrDefault(1)
+            ?? lineups.Values.FirstOrDefault();
+
+        if (lineup == null)
+        {
+            return [new(), new(), new()];
+        }
+
+        return
+        [
+            CaptureRoleSnapshot(player, lineup.Member1),
+            CaptureRoleSnapshot(player, lineup.Member2),
+            CaptureRoleSnapshot(player, lineup.Member3)
+        ];
+    }
+
+    private static BossPvpRoleSnapshot CaptureRoleSnapshot(PlayerInstance player, uint characterGuid)
+    {
+        if (characterGuid == 0)
+        {
+            return new BossPvpRoleSnapshot();
+        }
+
+        var character = player.CharacterManager.GetCharacterByGUID(characterGuid);
+        if (character == null)
+        {
+            return new BossPvpRoleSnapshot();
+        }
+
+        var snapshot = new BossPvpRoleSnapshot
+        {
+            Role = character.Guid,
+            Weapon = character.WeaponUniqueId
+        };
+
+        var weapon = player.InventoryManager.GetWeaponItem(character.WeaponUniqueId);
+        if (weapon != null)
+        {
+            snapshot.Wgdpl = BuildWeaponGdpl(weapon);
+            snapshot.Wslot = weapon.PartSlots;
+        }
+
+        var supports = character.SupportSlots
+            .OrderBy(x => x.Key)
+            .Select(x => x.Value)
+            .Where(x => x != 0)
+            .Take(3)
+            .ToArray();
+
+        if (supports.Length > 0)
+        {
+            snapshot.S1 = supports[0];
+            snapshot.Sgdpl1 = BuildSupportGdpl(player.InventoryManager.GetSupportCardItem(supports[0]));
+        }
+
+        if (supports.Length > 1)
+        {
+            snapshot.S2 = supports[1];
+            snapshot.Sgdpl2 = BuildSupportGdpl(player.InventoryManager.GetSupportCardItem(supports[1]));
+        }
+
+        if (supports.Length > 2)
+        {
+            snapshot.S3 = supports[2];
+            snapshot.Sgdpl3 = BuildSupportGdpl(player.InventoryManager.GetSupportCardItem(supports[2]));
+        }
+
+        return snapshot;
+    }
+
+    private static List<uint> BuildWeaponGdpl(GameWeaponInfo weapon)
+    {
+        var gdpl = DecodeGdpl(weapon.TemplateId);
+        gdpl.Add(weapon.Level);
+        gdpl.Add(weapon.Evolue);
+        return gdpl;
+    }
+
+    private static List<uint> BuildSupportGdpl(GameSupportCardInfo? support)
+    {
+        if (support == null)
+        {
+            return [];
+        }
+
+        var gdpl = DecodeGdpl(support.TemplateId);
+        gdpl.Add(support.Level);
+        gdpl.Add(0);
+        return gdpl;
+    }
+
+    private static List<uint> DecodeGdpl(ulong templateId)
+    {
+        return
+        [
+            (uint)(templateId & 0xFFFF),
+            (uint)((templateId >> 16) & 0xFFFF),
+            (uint)((templateId >> 32) & 0xFFFF),
+            (uint)((templateId >> 48) & 0xFFFF)
+        ];
+    }
+
+    private static int ComputeIntegral(uint bossLevelId, int diff, int residueTime)
+    {
+        if (!GameData.BossPvpBossData.TryGetValue(bossLevelId, out var boss) || diff <= 0 || diff > boss.BossLevel.Count)
+        {
+            return 0;
+        }
+
+        var info = boss.BossLevel[diff - 1];
+        if (info.Count == 0)
+        {
+            return 0;
+        }
+
+        var multiplier = info.Count > 2 ? info[2] : 0;
+        var baseScore = info.Count > 3 ? info[3] : 0;
+        var residueScore = info.Count > 4 ? info[4] : 0;
+        var total = (baseScore + residueScore * Math.Max(0, residueTime)) * multiplier;
+        return (int)Math.Floor(total + 0.5);
+    }
+
+    private static uint? TryGetPositionDiffSid(uint bossLevelId)
+    {
+        var season = GetOpenSeason();
+        if (season == null)
+        {
+            return null;
+        }
+
+        var index = season.BossIds.FindIndex(x => x == bossLevelId);
+        return index >= 0 ? DiffStartId + (uint)(index + 1) : null;
+    }
+
+    private static BossPvpBossChallengeExcel? GetOpenSeason()
+    {
+        var now = DateTimeOffset.Now;
+        var current = GameData.BossPvpBossChallengeData.Values
+            .OrderBy(x => x.ID)
+            .FirstOrDefault(x =>
+            {
+                var startAt = ParseBossTime(x.StartTime);
+                var endAt = ParseBossTime(x.EndTime);
+                return startAt != null && endAt != null && now >= startAt && now <= endAt;
+            });
+
+        return current ?? GameData.BossPvpBossChallengeData.Values.OrderBy(x => x.ID).FirstOrDefault();
+    }
+
+    private static uint GetDailyChallengeNum()
+    {
+        var now = DateTime.Now;
+        if (now.Hour < 4)
+        {
+            now = now.AddHours(-4);
+        }
+
+        var week = now.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)now.DayOfWeek;
+        return GameData.BossPvpNumData.TryGetValue((uint)week, out var count) ? count.Num : 8;
+    }
+
+    private static int ReadInt(PlayerInstance player, uint sid)
+    {
+        var attr = player.Data.StrAttrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == sid)?.Val;
+        return int.TryParse(attr, NumberStyles.Integer, CultureInfo.InvariantCulture, out var value) ? value : 0;
+    }
+
+    private static void EnsureStr(PlayerInstance player, uint sid, string value, NtfSyncPlayer sync)
+    {
+        var attr = player.Data.StrAttrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == sid);
+        if (attr != null)
+        {
+            return;
+        }
+
+        SetStr(player, sid, value, sync);
+    }
+
+    private static void SetStr(PlayerInstance player, uint sid, string value, NtfSyncPlayer sync)
+    {
+        player.SetStrAttr(GroupId, sid, value);
+        sync.CustomStr[player.ToShiftedAttrKey(GroupId, sid)] = value;
+    }
+
+    private static uint GetBossSid(uint bossLevelId, uint offset) => (LevelStride * bossLevelId) + LevelStartSid + offset;
+
+    private static string EmptySnapshotJson() => System.Text.Json.JsonSerializer.Serialize(new BossPvpRoleSnapshot(), JsonOptions);
+
+    private static T? Deserialize<T>(string? param)
+    {
+        if (string.IsNullOrWhiteSpace(param))
+        {
+            return default;
+        }
+
+        return System.Text.Json.JsonSerializer.Deserialize<T>(param, JsonOptions);
+    }
+
+    private static DateTimeOffset? ParseBossTime(string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return null;
+        }
+
+        var raw = value.Trim().Trim('[', ']');
+        if (!DateTime.TryParseExact(raw, "yyyyMMddHHmm", CultureInfo.InvariantCulture, DateTimeStyles.None, out var localTime))
+        {
+            return null;
+        }
+
+        return new DateTimeOffset(localTime);
+    }
+
+    private sealed class EnterLevelParam
+    {
+        [JsonPropertyName("nID")] public uint NId { get; set; }
+    }
+
+    private sealed class RecordParam
+    {
+        [JsonPropertyName("nID")] public uint NId { get; set; }
+        [JsonPropertyName("nDiff")] public int NDiff { get; set; }
+        [JsonPropertyName("nTime")] public double NTime { get; set; }
+        [JsonPropertyName("ResidueTime")] public int ResidueTime { get; set; }
+        [JsonPropertyName("bRecord")] public bool BRecord { get; set; }
+        [JsonPropertyName("nTeamID")] public uint NTeamId { get; set; }
+    }
+
+    private sealed class SettlementParam
+    {
+        [JsonPropertyName("nID")] public uint NId { get; set; }
+        [JsonPropertyName("nDiff")] public int NDiff { get; set; }
+        [JsonPropertyName("nTime")] public double NTime { get; set; }
+        [JsonPropertyName("ResidueTime")] public int ResidueTime { get; set; }
+        [JsonPropertyName("nTeamID")] public uint NTeamId { get; set; }
+    }
+
+    private sealed class FailParam
+    {
+        [JsonPropertyName("nID")] public uint NId { get; set; }
+    }
+
+    private sealed class MopupParam
+    {
+        [JsonPropertyName("nID")] public uint NId { get; set; }
+        [JsonPropertyName("nDiff")] public int NDiff { get; set; }
+    }
+
+    private sealed class RewardParam
+    {
+        [JsonPropertyName("tbTaskID")] public List<uint> TaskIds { get; set; } = [];
+    }
+
+    private sealed class BossPvpRoleSnapshot
+    {
+        [JsonPropertyName("role")] public uint Role { get; set; }
+        [JsonPropertyName("weapon")] public uint Weapon { get; set; }
+        [JsonPropertyName("s1")] public uint S1 { get; set; }
+        [JsonPropertyName("s2")] public uint S2 { get; set; }
+        [JsonPropertyName("s3")] public uint S3 { get; set; }
+        [JsonPropertyName("wgdpl")] public List<uint> Wgdpl { get; set; } = [];
+        [JsonPropertyName("wslot")] public Dictionary<uint, ulong> Wslot { get; set; } = [];
+        [JsonPropertyName("sgdpl1")] public List<uint> Sgdpl1 { get; set; } = [];
+        [JsonPropertyName("sgdpl2")] public List<uint> Sgdpl2 { get; set; } = [];
+        [JsonPropertyName("sgdpl3")] public List<uint> Sgdpl3 { get; set; } = [];
+    }
+}

GameServer/Game/Player/PlayerInstance.cs

@@ -196,7 +196,7 @@ public class PlayerInstance(PlayerGameData data)
         return proto;
     }
 
-    public Proto.Player ToPlayerProto()
+    public Proto.Player ToPlayerProto(bool includeSupportCards = true)
     {
         BuildPlayerAttr();
         var displayName = PlayerGameData.NormalizeDisplayName(Data.Name);
@@ -217,7 +217,10 @@ public class PlayerInstance(PlayerGameData data)
         foreach (var item in InventoryManager.InventoryData.Items.Values) proto.Items.Add(item.ToProto());
         foreach (var skin in InventoryManager.InventoryData.Skins.Values) proto.Items.Add(skin.ToProto());
         foreach (var weapon in InventoryManager.InventoryData.Weapons.Values) proto.Items.Add(weapon.ToProto());
-        foreach (var card in InventoryManager.InventoryData.SupportCards.Values) proto.Items.Add(card.ToProto());
+        if (includeSupportCards)
+        {
+            foreach (var card in InventoryManager.InventoryData.SupportCards.Values) proto.Items.Add(card.ToProto());
+        }
         foreach (var x in Data.Attrs)
         {
             uint gid = x.Gid;
@@ -422,6 +425,14 @@ public class PlayerInstance(PlayerGameData data)
             yield return (22, levelId, 1_700_000_000);
         }
 
+        // Role fragment chapters use Condition.PRE_LEVEL against Launch.GPASSID as well.
+        // Mark every role level as cleared so character-specific stages beyond the first one unlock.
+        foreach (var levelId in GameData.RoleLevelData.Keys)
+        {
+            yield return (21, levelId, 7);
+            yield return (22, levelId, 1_700_000_000);
+        }
+
         foreach (var guide in GameData.GuideData.Values)
         {
             yield return (4, guide.ID, 999);

GameServer/Server/CallGS/Handlers/BossPvp/BossPvpLogic_EnterLevel.cs

@@ -0,0 +1,13 @@
+using MikuSB.GameServer.Game.BossPvp;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+
+[CallGSApi("BossPvpLogic_EnterLevel")]
+public class BossPvpLogic_EnterLevel : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var response = BossPvpService.HandleEnterLevel(param);
+        await CallGSRouter.SendScript(connection, "BossPvpLogic_EnterLevel", System.Text.Json.JsonSerializer.Serialize(response));
+    }
+}

GameServer/Server/CallGS/Handlers/BossPvp/BossPvpLogic_GetOpenID.cs

@@ -0,0 +1,13 @@
+using MikuSB.GameServer.Game.BossPvp;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+
+[CallGSApi("BossPvpLogic_GetOpenID")]
+public class BossPvpLogic_GetOpenID : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var (response, sync) = await BossPvpService.HandleGetOpenIdAsync(connection.Player!);
+        await CallGSRouter.SendScript(connection, "BossPvpLogic_GetOpenID", System.Text.Json.JsonSerializer.Serialize(response), sync);
+    }
+}

GameServer/Server/CallGS/Handlers/BossPvp/BossPvpLogic_GetReward.cs

@@ -0,0 +1,13 @@
+using MikuSB.GameServer.Game.BossPvp;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+
+[CallGSApi("BossPvpLogic_GetReward")]
+public class BossPvpLogic_GetReward : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var response = BossPvpService.HandleGetReward(param);
+        await CallGSRouter.SendScript(connection, "BossPvpLogic_GetReward", System.Text.Json.JsonSerializer.Serialize(response));
+    }
+}

GameServer/Server/CallGS/Handlers/BossPvp/BossPvpLogic_LevelFail.cs

@@ -0,0 +1,14 @@
+using MikuSB.GameServer.Game.BossPvp;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+
+[CallGSApi("BossPvpLogic_LevelFail")]
+public class BossPvpLogic_LevelFail : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var node = System.Text.Json.Nodes.JsonNode.Parse(param);
+        var (response, sync) = BossPvpService.HandleFail(connection.Player!, node);
+        await CallGSRouter.SendScript(connection, "BossPvpLogic_LevelFail", response.ToJsonString(), sync);
+    }
+}

GameServer/Server/CallGS/Handlers/BossPvp/BossPvpLogic_LevelMopup.cs

@@ -0,0 +1,13 @@
+using MikuSB.GameServer.Game.BossPvp;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+
+[CallGSApi("BossPvpLogic_LevelMopup")]
+public class BossPvpLogic_LevelMopup : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var (response, sync) = BossPvpService.HandleMopup(connection.Player!, param);
+        await CallGSRouter.SendScript(connection, "BossPvpLogic_LevelMopup", System.Text.Json.JsonSerializer.Serialize(response), sync);
+    }
+}

GameServer/Server/CallGS/Handlers/BossPvp/BossPvpLogic_LevelSettlement.cs

@@ -0,0 +1,14 @@
+using MikuSB.GameServer.Game.BossPvp;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+
+[CallGSApi("BossPvpLogic_LevelSettlement")]
+public class BossPvpLogic_LevelSettlement : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var node = System.Text.Json.Nodes.JsonNode.Parse(param);
+        var (response, sync) = BossPvpService.HandleSettlement(connection.Player!, node);
+        await CallGSRouter.SendScript(connection, "BossPvpLogic_LevelSettlement", response.ToJsonString(), sync);
+    }
+}

GameServer/Server/CallGS/Handlers/BossPvp/BossPvpLogic_Record.cs

@@ -0,0 +1,13 @@
+using MikuSB.GameServer.Game.BossPvp;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+
+[CallGSApi("BossPvpLogic_Record")]
+public class BossPvpLogic_Record : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var (response, sync) = BossPvpService.HandleRecord(connection.Player!, param);
+        await CallGSRouter.SendScript(connection, "BossPvpLogic_Record", System.Text.Json.JsonSerializer.Serialize(response), sync);
+    }
+}

GameServer/Server/CallGS/Handlers/Chapter/Chapter_DealLevelSettlement.cs

@@ -1,6 +1,8 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
+using MikuSB.GameServer.Game.BossPvp;
+using MikuSB.Proto;
 
 namespace MikuSB.GameServer.Server.CallGS.Handlers.Chapter;
 
@@ -10,17 +12,20 @@ public class Chapter_DealLevelSettlement : ICallGSHandler
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
         var req = JsonSerializer.Deserialize<DealLevelSettlementParam>(param);
+        NtfSyncPlayer? extraSync = null;
         var response = new JsonObject
         {
             ["sCmd"] = req?.SCmd ?? "Chapter_LevelSettlement",
-            ["tbParam"] = BuildSettlementPayload(req?.SCmd, req?.TbParam)
+            ["tbParam"] = BuildSettlementPayload(connection, req?.SCmd, req?.TbParam, out extraSync)
         };
 
-        await CallGSRouter.SendScript(connection, "Chapter_DealLevelSettlement", response.ToJsonString());
+        await CallGSRouter.SendScript(connection, "Chapter_DealLevelSettlement", response.ToJsonString(), extraSync!);
     }
 
-    private static JsonNode BuildSettlementPayload(string? sCmd, JsonNode? tbParam)
+    private static JsonNode BuildSettlementPayload(Connection connection, string? sCmd, JsonNode? tbParam, out NtfSyncPlayer? extraSync)
     {
+        extraSync = null;
+
         if (string.Equals(sCmd, "Chapter_LevelSettlement", StringComparison.Ordinal))
         {
             return new JsonArray();
@@ -37,6 +42,20 @@ public class Chapter_DealLevelSettlement : ICallGSHandler
             return result;
         }
 
+        if (string.Equals(sCmd, "BossPvpLogic_LevelSettlement", StringComparison.Ordinal))
+        {
+            var (response, sync) = BossPvpService.HandleSettlement(connection.Player!, tbParam);
+            extraSync = sync;
+            return response;
+        }
+
+        if (string.Equals(sCmd, "BossPvpLogic_LevelFail", StringComparison.Ordinal))
+        {
+            var (response, sync) = BossPvpService.HandleFail(connection.Player!, tbParam);
+            extraSync = sync;
+            return response;
+        }
+
         return tbParam?.DeepClone() ?? new JsonObject();
     }
 }

GameServer/Server/CallGS/Handlers/Girl/GirlCard_UpBySpecialBreak.cs

@@ -0,0 +1,127 @@
+using MikuSB.Data;
+using MikuSB.Database;
+using MikuSB.Database.Inventory;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Girl;
+
+[CallGSApi("GirlCard_UpBySpecialBreak")]
+public class GirlCard_UpBySpecialBreak : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var player = connection.Player!;
+        var req = JsonSerializer.Deserialize<GirlCardUpBySpecialBreakParam>(param);
+        if (req == null || req.CardId == 0)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var card = player.CharacterManager.GetCharacterByGUID((uint)req.CardId);
+        if (card == null)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var cardTemplate = GameData.CardData.Values.FirstOrDefault(x =>
+            GameResourceTemplateId.FromGdpl(x.Genre, x.Detail, x.Particular, x.Level) == card.TemplateId);
+        if (cardTemplate == null)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        if (cardTemplate.BreakMatID <= 10000 ||
+            !GameData.SpecialBreakData.TryGetValue(cardTemplate.BreakMatID, out var specialBreakExcel))
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var nextBreak = card.Break + 1;
+        if (!specialBreakExcel.HasBreakLevel(nextBreak))
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{\"sErr\":\"tip.already_max_break\"}");
+            return;
+        }
+
+        var requestedMaterials = new Dictionary<ulong, uint>();
+        foreach (var row in specialBreakExcel.GetItems(nextBreak))
+        {
+            if (row.Count < 5)
+                continue;
+
+            var templateId = GameResourceTemplateId.FromGdpl(
+                (uint)Math.Max(0, row[0]),
+                (uint)Math.Max(0, row[1]),
+                (uint)Math.Max(0, row[2]),
+                (uint)Math.Max(0, row[3]));
+            var count = (uint)Math.Max(0, row[4]);
+            if (templateId == 0 || count == 0)
+                continue;
+
+            requestedMaterials[templateId] = requestedMaterials.GetValueOrDefault(templateId) + count;
+        }
+
+        if (requestedMaterials.Count == 0)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{\"sErr\":\"tip.not_material_for_break\"}");
+            return;
+        }
+
+        foreach (var (templateId, count) in requestedMaterials)
+        {
+            var item = player.InventoryManager.InventoryData.Items.Values.FirstOrDefault(x => x.TemplateId == templateId);
+            if (item == null || item.ItemCount < count)
+            {
+                await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{\"sErr\":\"tip.not_material_for_break\"}");
+                return;
+            }
+        }
+
+        var syncItems = new List<Item>();
+        foreach (var (templateId, count) in requestedMaterials)
+        {
+            var item = player.InventoryManager.InventoryData.Items.Values.First(x => x.TemplateId == templateId);
+            item.ItemCount -= count;
+
+            if (item.ItemCount == 0)
+            {
+                player.InventoryManager.InventoryData.Items.Remove(item.UniqueId);
+                syncItems.Add(BuildRemovedProto(item));
+            }
+            else
+            {
+                syncItems.Add(item.ToProto());
+            }
+        }
+
+        card.Break = nextBreak;
+        syncItems.Add(card.ToProto());
+
+        DatabaseHelper.SaveDatabaseType(player.InventoryManager.InventoryData);
+        DatabaseHelper.SaveDatabaseType(player.CharacterManager.CharacterData);
+
+        var sync = new NtfSyncPlayer();
+        sync.Items.AddRange(syncItems);
+
+        await CallGSRouter.SendScript(connection, "GirlCard_UpBySpecialBreak", "{}", sync);
+    }
+
+    private static Item BuildRemovedProto(BaseGameItemInfo item)
+    {
+        var proto = item.ToProto();
+        proto.Count = 0;
+        return proto;
+    }
+}
+
+internal sealed class GirlCardUpBySpecialBreakParam
+{
+    [JsonPropertyName("nCardId")]
+    public int CardId { get; set; }
+}

GameServer/Server/CallGS/Handlers/Rogue3D/Rogue3D_EnterSeasonLevel.cs

@@ -0,0 +1,71 @@
+using MikuSB.Data;
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Rogue3D;
+
+// Enters the Rogue3D season level. Returns a random seed used by the client for map generation.
+// Persists SeasonGameplayId (sid=1006) and SeasonEnterFlag (sid=1008) as player attributes (GroupId=124).
+// param: {"nDiffId", "nTeamID", "tbTeam", "tbBuffList", "tbLog"}
+// Response: {"nSeed": int} on success, {"sErr": "key"} on failure
+[CallGSApi("Rogue3D_EnterSeasonLevel")]
+public class Rogue3D_EnterSeasonLevel : ICallGSHandler
+{
+    private const uint GroupId = 124;
+    private const uint SeasonGameplayIdSid = 1006;
+    private const uint SeasonEnterFlagSid = 1008;
+    private static readonly Random Random = new();
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<EnterSeasonLevelParam>(param);
+        if (req == null)
+        {
+            await CallGSRouter.SendScript(connection, "Rogue3D_EnterSeasonLevel", "{\"nSeed\":0}");
+            return;
+        }
+
+        if (!GameData.Rogue3DDifficultData.TryGetValue(req.DiffId, out var cfg) || cfg.GameplayGroup.Count == 0)
+        {
+            await CallGSRouter.SendScript(connection, "Rogue3D_EnterSeasonLevel", "{\"sErr\":\"rogue3.massage_gameProcessError\"}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+
+        SetAttr(player, SeasonGameplayIdSid, cfg.GameplayGroup[0], sync);
+        SetAttr(player, SeasonEnterFlagSid, 1, sync);
+
+        var seed = Random.Next(1, 1_000_000_000);
+        await CallGSRouter.SendScript(connection, "Rogue3D_EnterSeasonLevel", $"{{\"nSeed\":{seed}}}", sync);
+    }
+
+    private static void SetAttr(PlayerInstance player, uint sid, uint val, NtfSyncPlayer sync)
+    {
+        var attr = player.Data.Attrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == sid);
+        if (attr == null)
+        {
+            attr = new PlayerAttr { Gid = GroupId, Sid = sid };
+            player.Data.Attrs.Add(attr);
+        }
+
+        if (attr.Val == val)
+        {
+            return;
+        }
+
+        attr.Val = val;
+        sync.Custom[player.ToPackedAttrKey(GroupId, sid)] = val;
+        sync.Custom[player.ToShiftedAttrKey(GroupId, sid)] = val;
+    }
+}
+
+internal sealed class EnterSeasonLevelParam
+{
+    [JsonPropertyName("nDiffId")]
+    public uint DiffId { get; set; }
+}

GameServer/Server/CallGS/Handlers/Rogue3D/Rogue3D_SelectSeasonTalent.cs

@@ -0,0 +1,47 @@
+using MikuSB.Database.Player;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Rogue3D;
+
+// Selects the Rogue3D season talent and persists it as player attribute (GroupId=124, TalentId=1007).
+// param: {"nTalentId": int}
+// Response: {} on success, {"sErr": "key"} on failure
+[CallGSApi("Rogue3D_SelectSeasonTalent")]
+public class Rogue3D_SelectSeasonTalent : ICallGSHandler
+{
+    private const uint GroupId = 124;
+    private const uint SeasonTalentIdSid = 1007;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<SelectSeasonTalentParam>(param);
+        if (req == null)
+        {
+            await CallGSRouter.SendScript(connection, "Rogue3D_SelectSeasonTalent", "{}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var attr = player.Data.Attrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == SeasonTalentIdSid);
+        if (attr == null)
+        {
+            attr = new PlayerAttr { Gid = GroupId, Sid = SeasonTalentIdSid };
+            player.Data.Attrs.Add(attr);
+        }
+        attr.Val = req.TalentId;
+
+        var sync = new NtfSyncPlayer();
+        sync.Custom[player.ToPackedAttrKey(GroupId, SeasonTalentIdSid)] = attr.Val;
+        sync.Custom[player.ToShiftedAttrKey(GroupId, SeasonTalentIdSid)] = attr.Val;
+
+        await CallGSRouter.SendScript(connection, "Rogue3D_SelectSeasonTalent", "{}", sync);
+    }
+}
+
+internal sealed class SelectSeasonTalentParam
+{
+    [JsonPropertyName("nTalentId")]
+    public uint TalentId { get; set; }
+}

GameServer/Server/Packet/Recv/Login/HandlerReqLogin.cs

@@ -21,6 +21,7 @@ namespace MikuSB.GameServer.Server.Packet.Recv.Login;
 public class HandlerReqLogin : Handler
 {
     private static readonly Logger Logger = new("ReqLogin");
+    private const int SupportCardLoginSplitThreshold = 2000;
 
     private static string? ExtractSdkAuthToken(string? token)
     {
@@ -80,7 +81,10 @@ public class HandlerReqLogin : Handler
             $"Debug-{DateTime.Now:yyyy-MM-dd HH-mm-ss}.log");
         await connection.Player.OnEnterGame();
         connection.Player.Connection = connection;
-        await connection.SendPacket(new PacketRspLogin(connection.Player!));
+        var splitSupportCards = connection.Player.InventoryManager.InventoryData.SupportCards.Count > SupportCardLoginSplitThreshold;
+        await connection.SendPacket(new PacketRspLogin(connection.Player!, !splitSupportCards));
+        if (splitSupportCards)
+            await SendSupportCardsOnLogin(connection);
         await connection.SendPacket(new PacketNtfCallScript(connection.Player!));
         await SendDebugLoginState(connection);
 
@@ -90,6 +94,22 @@ public class HandlerReqLogin : Handler
         await SendGirlSkinTypeOnLogin(connection);
     }
 
+    private static async Task SendSupportCardsOnLogin(Connection connection)
+    {
+        var player = connection.Player;
+        if (player == null)
+            return;
+
+        var supportCards = player.InventoryManager.InventoryData.SupportCards.Values.ToList();
+        Logger.Info($"Split support card sync on login: total={supportCards.Count}, chunkSize={SupportCardLoginSplitThreshold}");
+
+        foreach (var chunk in supportCards.Chunk(SupportCardLoginSplitThreshold))
+        {
+            var packet = new PacketNtfCallScript(chunk.ToList());
+            await connection.SendPacket(packet);
+        }
+    }
+
     private static void ApplySavedGirlSkinTypes(PlayerInstance player)
     {
         var inventoryData = player.InventoryManager.InventoryData;

GameServer/Server/Packet/Send/Login/PacketRspLogin.cs

@@ -10,18 +10,41 @@ public class PacketRspLogin : BasePacket
 {
     private static readonly Logger Logger = new("RspLogin");
 
-    public PacketRspLogin(PlayerInstance player) : base(CmdIds.RspLogin)
+    public PacketRspLogin(PlayerInstance player, bool includeSupportCards = true) : base(CmdIds.RspLogin)
     {
+        var characterCount = player.CharacterManager.CharacterData.Characters.Count;
+        var itemCount = player.InventoryManager.InventoryData.Items.Count;
+        var skinCount = player.InventoryManager.InventoryData.Skins.Count;
+        var weaponCount = player.InventoryManager.InventoryData.Weapons.Count;
+        var supportCardCount = player.InventoryManager.InventoryData.SupportCards.Count;
+        var attrCount = player.Data.Attrs.Count;
+        var strAttrCount = player.Data.StrAttrs.Count;
+        var showItemCount = player.Data.ShowItems.Count;
+
         var proto = new RspLogin
         {
             Timestamp = (uint)Extensions.GetUnixSec(),
             WorldChannel = 1,
             AreaId = 1,
-            Data = player.ToPlayerProto(),
+            Data = player.ToPlayerProto(includeSupportCards),
             NeedRename = false
         };
 
         var bytes = Google.Protobuf.MessageExtensions.ToByteArray(proto);
+        Logger.Info(
+            "RspLogin content: " +
+            $"characters={characterCount}, " +
+            $"items={itemCount}, " +
+            $"skins={skinCount}, " +
+            $"weapons={weaponCount}, " +
+            $"supportCards={supportCardCount}, " +
+            $"supportCardsInRspLogin={(includeSupportCards ? supportCardCount : 0)}, " +
+            $"attrs={attrCount}, " +
+            $"strAttrs={strAttrCount}, " +
+            $"showItems={showItemCount}, " +
+            $"protoItems={proto.Data.Items.Count}, " +
+            $"protoAttrs={proto.Data.Attrs.Count}, " +
+            $"protoStrAttrs={proto.Data.StrAttrs.Count}");
         Logger.Info($"RspLogin proto size: {bytes.Length} bytes");
 
         SetData(bytes);

version.txt

@@ -1 +1 @@
-v=3.4
+v=3.9