Update version.txt

Common/Data/Excel/ClimbTowerAwardExcel.cs

@@ -0,0 +1,56 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/climbtower/climb_tower_award.json")]
+public class ClimbTowerAwardExcel : ExcelResource
+{
+    [JsonProperty("ID")] public uint ID { get; set; }
+    [JsonProperty("Diff")] public JToken? DiffRaw { get; set; }
+    [JsonProperty("FirstAward")] public List<List<uint>> FirstAward { get; set; } = [];
+    [JsonProperty("StarCount1")] public int StarCount1 { get; set; }
+    [JsonProperty("StarAward1")] public List<List<uint>> StarAward1 { get; set; } = [];
+    [JsonProperty("StarCount2")] public int StarCount2 { get; set; }
+    [JsonProperty("StarAward2")] public List<List<uint>> StarAward2 { get; set; } = [];
+    [JsonProperty("StarCount3")] public int StarCount3 { get; set; }
+    [JsonProperty("StarAward3")] public List<List<uint>> StarAward3 { get; set; } = [];
+
+    [JsonIgnore]
+    public int Diff => DiffRaw?.Type switch
+    {
+        JTokenType.Integer => Math.Max(1, DiffRaw.Value<int>()),
+        JTokenType.String when int.TryParse(DiffRaw.Value<string>(), out var value) => Math.Max(1, value),
+        _ => 1
+    };
+
+    public override uint GetId() => (ID * 10u) + (uint)Diff;
+
+    public override void Loaded()
+    {
+        if (!GameData.ClimbTowerAwardData.TryGetValue(ID, out var diffMap))
+        {
+            diffMap = [];
+            GameData.ClimbTowerAwardData[ID] = diffMap;
+        }
+
+        diffMap[Diff] = this;
+    }
+
+    public int GetStarCount(int group) => group switch
+    {
+        1 => StarCount1,
+        2 => StarCount2,
+        3 => StarCount3,
+        _ => 0
+    };
+
+    public IReadOnlyList<IReadOnlyList<uint>> GetRewards(int group) => group switch
+    {
+        0 => FirstAward,
+        1 => StarAward1,
+        2 => StarAward2,
+        3 => StarAward3,
+        _ => []
+    };
+}

Common/Data/Excel/ClimbTowerDiffExcel.cs

@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/climbtower/climb_tower_diff.json")]
+public class ClimbTowerDiffExcel : ExcelResource
+{
+    [JsonProperty("ID")] public uint ID { get; set; }
+    [JsonProperty("Level1")] public int Level1 { get; set; }
+    [JsonProperty("Level2")] public int Level2 { get; set; }
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        GameData.ClimbTowerDiffData[ID] = this;
+    }
+}

Common/Data/Excel/ClimbTowerLevelOrderExcel.cs

@@ -0,0 +1,17 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/climbtower/climb_tower_levelorder.json")]
+public class ClimbTowerLevelOrderExcel : ExcelResource
+{
+    [JsonProperty("ID")] public uint ID { get; set; }
+    [JsonProperty("LevelID")] public uint LevelID { get; set; }
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        GameData.ClimbTowerLevelOrderData[ID] = this;
+    }
+}

Common/Data/Excel/ClimbTowerTimeExcel.cs

@@ -0,0 +1,57 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Globalization;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/climbtower/climb_tower_time.json")]
+public class ClimbTowerTimeExcel : ExcelResource
+{
+    [JsonProperty("ID")] public uint ID { get; set; }
+    [JsonProperty("StartTime")] public string StartTime { get; set; } = "";
+    [JsonProperty("EndTime")] public string EndTime { get; set; } = "";
+    [JsonProperty("Level1")] public List<List<uint>> Level1 { get; set; } = [];
+    [JsonProperty("Level2")] public JToken? Level2Raw { get; set; }
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        GameData.ClimbTowerTimeData[ID] = this;
+    }
+
+    public IReadOnlyList<IReadOnlyList<uint>> GetLevelGroups(int type)
+    {
+        if (type == 1)
+            return Level1;
+
+        if (Level2Raw == null)
+            return [];
+
+        if (Level2Raw.Type == JTokenType.Array)
+        {
+            return Level2Raw
+                .Children()
+                .OfType<JArray>()
+                .Select(x => (IReadOnlyList<uint>)x.Values<uint>().ToList())
+                .ToList();
+        }
+
+        if (Level2Raw.Type == JTokenType.Object)
+        {
+            return Level2Raw
+                .Children<JProperty>()
+                .Select(x => new
+                {
+                    Key = uint.TryParse(x.Name, CultureInfo.InvariantCulture, out var key) ? key : 0u,
+                    Value = x.Value.Type == JTokenType.Integer ? x.Value.Value<uint>() : 0u
+                })
+                .Where(x => x.Key > 0 && x.Value > 0)
+                .OrderBy(x => x.Key)
+                .Select(x => (IReadOnlyList<uint>)new List<uint> { x.Key, x.Value })
+                .ToList();
+        }
+
+        return [];
+    }
+}

Common/Data/Excel/OtherItemExcel.cs

@@ -0,0 +1,38 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("item/templates/others.json")]
+public class OtherItemExcel : ExcelResource
+{
+    public uint Genre { get; set; }
+    public uint Detail { get; set; }
+    public uint Particular { get; set; }
+    public uint Level { get; set; }
+    [JsonProperty("GMnum")] public JToken? GMnumRaw { get; set; }
+
+    [JsonIgnore]
+    public uint GMnum => ReadUInt(GMnumRaw);
+
+    public override uint GetId() => (uint)GameResourceTemplateId.FromGdpl(Genre, Detail, Particular, Level);
+
+    public override void Loaded()
+    {
+        GameData.OtherItemData[GetId()] = this;
+    }
+
+    private static uint ReadUInt(JToken? token)
+    {
+        if (token == null)
+            return 0;
+
+        return token.Type switch
+        {
+            JTokenType.Integer => token.Value<uint>(),
+            JTokenType.Float => (uint)Math.Max(0, token.Value<decimal>()),
+            JTokenType.String when uint.TryParse(token.Value<string>(), out var value) => value,
+            _ => 0
+        };
+    }
+}

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/Excel/TowerEventLevelExcel.cs

@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/tower_event/level.json")]
+public class TowerEventLevelExcel : ExcelResource
+{
+    [JsonProperty("ID")] public uint ID { get; set; }
+    [JsonProperty("MapID")] public uint MapID { get; set; }
+    [JsonProperty("FightID")] public uint FightID { get; set; }
+    [JsonProperty("TaskPath")] public string TaskPath { get; set; } = "";
+    [JsonProperty("ConsumeVigor")] public List<int> ConsumeVigor { get; set; } = [];
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        GameData.TowerEventLevelData[ID] = this;
+    }
+}

Common/Data/Excel/TowerLevelExcel.cs

@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("challenge/climbtower/level.json")]
+public class TowerLevelExcel : ExcelResource
+{
+    [JsonProperty("ID")] public uint ID { get; set; }
+    [JsonProperty("MapID")] public uint MapID { get; set; }
+    [JsonProperty("FightID")] public uint FightID { get; set; }
+    [JsonProperty("TaskPath")] public string TaskPath { get; set; } = "";
+    [JsonProperty("ConsumeVigor")] public List<int> ConsumeVigor { get; set; } = [];
+
+    public override uint GetId() => ID;
+
+    public override void Loaded()
+    {
+        GameData.TowerLevelData[ID] = this;
+    }
+}

Common/Data/GameData.cs

@@ -21,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; } = [];
@@ -32,6 +33,13 @@ public static class GameData
     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, ClimbTowerTimeExcel> ClimbTowerTimeData { get; private set; } = [];
+    public static Dictionary<uint, ClimbTowerDiffExcel> ClimbTowerDiffData { get; private set; } = [];
+    public static Dictionary<uint, Dictionary<int, ClimbTowerAwardExcel>> ClimbTowerAwardData { get; private set; } = [];
+    public static Dictionary<uint, ClimbTowerLevelOrderExcel> ClimbTowerLevelOrderData { get; private set; } = [];
+    public static Dictionary<uint, TowerLevelExcel> TowerLevelData { get; private set; } = [];
+    public static Dictionary<uint, TowerEventLevelExcel> TowerEventLevelData { get; private set; } = [];
+    public static Dictionary<uint, OtherItemExcel> OtherItemData { 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

@@ -2,16 +2,15 @@ using MikuSB.Data;
 using MikuSB.Data.Excel;
 using MikuSB.Database.Inventory;
 using MikuSB.GameServer.Game.Player;
-using MikuSB.GameServer.Server.CallGS;
 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.BossPvp;
+namespace MikuSB.GameServer.Game.BossPvp;
 
-internal static class BossPvpShared
+internal static class BossPvpService
 {
     private const uint GroupId = 51;
     private const uint ActivitySubId = 0;
@@ -27,9 +26,8 @@ internal static class BossPvpShared
         DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
     };
 
-    public static async ValueTask<(object Response, NtfSyncPlayer Sync)> HandleGetOpenIdAsync(Connection connection)
+    public static async ValueTask<(object Response, NtfSyncPlayer Sync)> HandleGetOpenIdAsync(PlayerInstance player)
     {
-        var player = connection.Player!;
         await EnsureBossLineupsAsync(player);
 
         var sync = new NtfSyncPlayer();

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

@@ -1,3 +1,5 @@
+using MikuSB.GameServer.Game.BossPvp;
+
 namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
 
 [CallGSApi("BossPvpLogic_EnterLevel")]
@@ -5,7 +7,7 @@ public class BossPvpLogic_EnterLevel : ICallGSHandler
 {
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
-        var response = BossPvpShared.HandleEnterLevel(param);
+        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

@@ -1,3 +1,5 @@
+using MikuSB.GameServer.Game.BossPvp;
+
 namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
 
 [CallGSApi("BossPvpLogic_GetOpenID")]
@@ -5,7 +7,7 @@ public class BossPvpLogic_GetOpenID : ICallGSHandler
 {
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
-        var (response, sync) = await BossPvpShared.HandleGetOpenIdAsync(connection);
+        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

@@ -1,3 +1,5 @@
+using MikuSB.GameServer.Game.BossPvp;
+
 namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
 
 [CallGSApi("BossPvpLogic_GetReward")]
@@ -5,7 +7,7 @@ public class BossPvpLogic_GetReward : ICallGSHandler
 {
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
-        var response = BossPvpShared.HandleGetReward(param);
+        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

@@ -1,3 +1,5 @@
+using MikuSB.GameServer.Game.BossPvp;
+
 namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
 
 [CallGSApi("BossPvpLogic_LevelFail")]
@@ -6,7 +8,7 @@ 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) = BossPvpShared.HandleFail(connection.Player!, node);
+        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

@@ -1,3 +1,5 @@
+using MikuSB.GameServer.Game.BossPvp;
+
 namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
 
 [CallGSApi("BossPvpLogic_LevelMopup")]
@@ -5,7 +7,7 @@ public class BossPvpLogic_LevelMopup : ICallGSHandler
 {
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
-        var (response, sync) = BossPvpShared.HandleMopup(connection.Player!, param);
+        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

@@ -1,3 +1,5 @@
+using MikuSB.GameServer.Game.BossPvp;
+
 namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
 
 [CallGSApi("BossPvpLogic_LevelSettlement")]
@@ -6,7 +8,7 @@ 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) = BossPvpShared.HandleSettlement(connection.Player!, node);
+        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

@@ -1,3 +1,5 @@
+using MikuSB.GameServer.Game.BossPvp;
+
 namespace MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
 
 [CallGSApi("BossPvpLogic_Record")]
@@ -5,7 +7,7 @@ public class BossPvpLogic_Record : ICallGSHandler
 {
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
-        var (response, sync) = BossPvpShared.HandleRecord(connection.Player!, param);
+        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,8 +1,9 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
-using MikuSB.GameServer.Server.CallGS.Handlers.BossPvp;
+using MikuSB.GameServer.Game.BossPvp;
 using MikuSB.Proto;
+using MikuSB.GameServer.Server.CallGS.Handlers.Tower;
 
 namespace MikuSB.GameServer.Server.CallGS.Handlers.Chapter;
 
@@ -44,20 +45,51 @@ public class Chapter_DealLevelSettlement : ICallGSHandler
 
         if (string.Equals(sCmd, "BossPvpLogic_LevelSettlement", StringComparison.Ordinal))
         {
-            var (response, sync) = BossPvpShared.HandleSettlement(connection.Player!, tbParam);
+            var normalized = NormalizeBossPvpSettlement(tbParam);
+            var (response, sync) = BossPvpService.HandleSettlement(connection.Player!, normalized);
             extraSync = sync;
             return response;
         }
 
         if (string.Equals(sCmd, "BossPvpLogic_LevelFail", StringComparison.Ordinal))
         {
-            var (response, sync) = BossPvpShared.HandleFail(connection.Player!, tbParam);
+            var (response, sync) = BossPvpService.HandleFail(connection.Player!, tbParam);
+            extraSync = sync;
+            return response;
+        }
+
+        if (string.Equals(sCmd, "TowerLevel_LevelSettlement", StringComparison.Ordinal))
+        {
+            var (response, sync) = TowerLevel_LevelSettlement.HandleSettlement(connection.Player!, tbParam);
+            extraSync = sync;
+            return response;
+        }
+
+        if (string.Equals(sCmd, "TowerEventChapter_LevelSettlement", StringComparison.Ordinal))
+        {
+            var (response, sync) = TowerEventChapter_LevelSettlement.HandleSettlement(connection.Player!, tbParam);
             extraSync = sync;
             return response;
         }
 
         return tbParam?.DeepClone() ?? new JsonObject();
     }
+
+    private static JsonNode? NormalizeBossPvpSettlement(JsonNode? tbParam)
+    {
+        if (tbParam is not JsonObject obj)
+            return tbParam;
+
+        var clone = obj.DeepClone() as JsonObject ?? obj;
+        if (clone.TryGetPropertyValue("ResidueTime", out var residueNode) &&
+            residueNode is JsonValue residueValue &&
+            residueValue.TryGetValue<double>(out var residueTime))
+        {
+            clone["ResidueTime"] = (int)Math.Max(0, Math.Round(residueTime, MidpointRounding.AwayFromZero));
+        }
+
+        return clone;
+    }
 }
 
 internal sealed class DealLevelSettlementParam

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/Lineup/Lineups_Update.cs

@@ -0,0 +1,43 @@
+using MikuSB.Database;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Lineup;
+
+[CallGSApi("Lineups_Update")]
+public class Lineups_Update : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<List<LineupUpdateBatchParam>>(param);
+        if (req == null)
+        {
+            await CallGSRouter.SendScript(connection, "UpdateLineup", "{}");
+            return;
+        }
+
+        foreach (var lineup in req)
+        {
+            if (lineup == null)
+                continue;
+
+            await connection.Player!.LineupManager.UpdateLineup(
+                lineup.Index,
+                lineup.Member1,
+                lineup.Member2,
+                lineup.Member3);
+        }
+
+        DatabaseHelper.SaveDatabaseType(connection.Player!.LineupManager.LineupData);
+        await CallGSRouter.SendScript(connection, "UpdateLineup", "{}");
+    }
+}
+
+internal sealed class LineupUpdateBatchParam
+{
+    [JsonPropertyName("name")] public string Name { get; set; } = "";
+    [JsonPropertyName("index")] public int Index { get; set; }
+    [JsonPropertyName("member1")] public uint Member1 { get; set; }
+    [JsonPropertyName("member2")] public uint Member2 { get; set; }
+    [JsonPropertyName("member3")] public uint Member3 { get; set; }
+}

GameServer/Server/CallGS/Handlers/Misc/ExtendFightDynamicLog.cs

@@ -0,0 +1,10 @@
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Misc;
+
+[CallGSApi("ExtendFightDynamicLog")]
+public class ExtendFightDynamicLog : ICallGSHandler
+{
+    public Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        return Task.CompletedTask;
+    }
+}

GameServer/Server/CallGS/Handlers/Misc/ExtendFightLog.cs

@@ -0,0 +1,10 @@
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Misc;
+
+[CallGSApi("ExtendFightLog")]
+public class ExtendFightLog : ICallGSHandler
+{
+    public Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        return Task.CompletedTask;
+    }
+}

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/CallGS/Handlers/Tower/ClimbTowerLogic_CheckCycleLevel.cs

@@ -0,0 +1,118 @@
+using MikuSB.Data;
+using MikuSB.Data.Excel;
+using MikuSB.Database;
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Tower;
+
+[CallGSApi("ClimbTowerLogic_CheckCycleLevel")]
+public class ClimbTowerLogic_CheckCycleLevel : ICallGSHandler
+{
+    private const uint TowerGroupId = 3;
+    private const uint TimeSubId = 1;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var player = connection.Player!;
+        var current = ResolveCurrentCycle(GameData.ClimbTowerTimeData.Values, DateTime.Now);
+        if (current == null)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_CheckCycleLevel", "{}");
+            return;
+        }
+
+        var currentTimeId = GetAttr(player.Data, TowerGroupId, TimeSubId);
+        var sync = new NtfSyncPlayer();
+        if (currentTimeId != current.ID)
+        {
+            ResetTowerAttrs(player, sync);
+            SetAttr(player.Data, TowerGroupId, TimeSubId, current.ID, sync, player);
+            DatabaseHelper.SaveDatabaseType(player.Data);
+        }
+
+        await CallGSRouter.SendScript(connection, "ClimbTowerLogic_CheckCycleLevel", $$"""{"timeID":{{current.ID}}}""", sync);
+    }
+
+    private static ClimbTowerTimeExcel? ResolveCurrentCycle(IEnumerable<ClimbTowerTimeExcel> configs, DateTime now)
+    {
+        var parsed = configs
+            .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;
+
+        var latestStarted = parsed.LastOrDefault(x => x.Start <= now);
+        if (latestStarted != null)
+            return latestStarted.Config;
+
+        return parsed.FirstOrDefault()?.Config;
+    }
+
+    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",
+            System.Globalization.CultureInfo.InvariantCulture,
+            System.Globalization.DateTimeStyles.None,
+            out var value)
+            ? value
+            : null;
+    }
+
+    private static uint GetAttr(PlayerGameData data, uint gid, uint sid)
+    {
+        return data.Attrs.FirstOrDefault(x => x.Gid == gid && x.Sid == sid)?.Val ?? 0;
+    }
+
+    private static void ResetTowerAttrs(PlayerInstance player, NtfSyncPlayer sync)
+    {
+        var towerAttrs = player.Data.Attrs
+            .Where(x => x.Gid == TowerGroupId)
+            .ToList();
+
+        foreach (var attr in towerAttrs)
+        {
+            sync.Custom[player.ToPackedAttrKey(attr.Gid, attr.Sid)] = 0;
+            sync.Custom[player.ToShiftedAttrKey(attr.Gid, attr.Sid)] = 0;
+        }
+
+        player.Data.Attrs.RemoveAll(x => x.Gid == TowerGroupId);
+    }
+
+    private static void SetAttr(PlayerGameData data, uint gid, uint sid, uint value, NtfSyncPlayer sync, PlayerInstance player)
+    {
+        var attr = data.Attrs.FirstOrDefault(x => x.Gid == gid && x.Sid == sid);
+        if (attr == null)
+        {
+            attr = new PlayerAttr
+            {
+                Gid = gid,
+                Sid = sid
+            };
+            data.Attrs.Add(attr);
+        }
+
+        attr.Val = value;
+        sync.Custom[player.ToPackedAttrKey(gid, sid)] = value;
+        sync.Custom[player.ToShiftedAttrKey(gid, sid)] = value;
+    }
+}

GameServer/Server/CallGS/Handlers/Tower/ClimbTowerLogic_GetReward.cs

@@ -0,0 +1,449 @@
+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.Tower;
+
+[CallGSApi("ClimbTowerLogic_GetReward")]
+public class ClimbTowerLogic_GetReward : ICallGSHandler
+{
+    private const uint TowerGroupId = 3;
+    private const uint RewardStateSidBase = 100;
+    private const uint TowerLevelStateSidBase = 10000;
+    private const uint LaunchPassGroupId = 22;
+    private const uint AdvancedDiffSid = 4;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var player = connection.Player!;
+        var req = JsonSerializer.Deserialize<ClimbTowerGetRewardParam>(param);
+        if (req == null || req.Layer <= 0)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_GetReward", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var cycle = ResolveCurrentCycle(GameData.ClimbTowerTimeData.Values, DateTime.Now);
+        if (cycle == null)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_GetReward", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        if (!TryResolveLayer(cycle, req.Layer, player.Data, out var towerIds, out var diff))
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_GetReward", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        if (!GameData.ClimbTowerAwardData.TryGetValue((uint)req.Layer, out var diffMap) ||
+            !diffMap.TryGetValue(diff, out var rewardCfg))
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_GetReward", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var groups = ResolveRequestedGroups(req.Group);
+        if (groups.Count == 0)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_GetReward", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var claimableGroups = groups
+            .Where(group => CanClaimGroup(player.Data, rewardCfg, towerIds, req.Layer, group))
+            .Distinct()
+            .ToList();
+
+        if (claimableGroups.Count == 0)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_GetReward", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var sync = new NtfSyncPlayer();
+        var rewardStateAttr = GetOrCreateAttr(player.Data, TowerGroupId, RewardStateSidBase + (uint)req.Layer);
+        var responseRewards = new JsonArray();
+
+        foreach (var group in claimableGroups)
+        {
+            rewardStateAttr.Val |= 1u << GetFlagBitOffset(group);
+
+            foreach (var reward in rewardCfg.GetRewards(group))
+            {
+                if (reward.Count < 5)
+                    continue;
+
+                await GrantRewardAsync(player, sync, reward);
+                responseRewards.Add(new JsonArray(
+                    (int)reward[0],
+                    (int)reward[1],
+                    (int)reward[2],
+                    (int)reward[3],
+                    (int)reward[4]));
+            }
+        }
+
+        SyncAttr(sync, player, rewardStateAttr);
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        DatabaseHelper.SaveDatabaseType(player.InventoryManager.InventoryData);
+        DatabaseHelper.SaveDatabaseType(player.CharacterManager.CharacterData);
+
+        var rsp = new JsonObject
+        {
+            ["tbRewards"] = responseRewards
+        };
+
+        await CallGSRouter.SendScript(connection, "ClimbTowerLogic_GetReward", rsp.ToJsonString(), sync);
+    }
+
+    private static async Task GrantRewardAsync(PlayerInstance player, NtfSyncPlayer sync, IReadOnlyList<uint> reward)
+    {
+        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))
+                {
+                    var item = await player.InventoryManager.AddSuppliesItem(supplies, count, sendPacket: false);
+                    if (item != null)
+                        sync.Items.Add(item.ToProto());
+                }
+                break;
+            }
+            case ItemTypeEnum.TYPE_USEABLE:
+            {
+                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 CanClaimGroup(
+        PlayerGameData data,
+        ClimbTowerAwardExcel rewardCfg,
+        IReadOnlyList<uint> towerIds,
+        int layer,
+        int group)
+    {
+        if (group is < 0 or > 3 || IsRewardClaimed(data, layer, group))
+            return false;
+
+        if (group == 0)
+            return IsLayerPass(data, towerIds);
+
+        var requiredStar = rewardCfg.GetStarCount(group);
+        return requiredStar > 0 && GetLayerStar(data, towerIds) >= requiredStar;
+    }
+
+    private static bool IsLayerPass(PlayerGameData data, IReadOnlyList<uint> towerIds)
+    {
+        foreach (var towerId in towerIds)
+        {
+            if (!GameData.ClimbTowerLevelOrderData.TryGetValue(towerId, out var orderCfg))
+                return false;
+
+            var passAttr = data.Attrs.FirstOrDefault(x => x.Gid == LaunchPassGroupId && x.Sid == orderCfg.LevelID);
+            if (passAttr == null || passAttr.Val == 0)
+                return false;
+        }
+
+        return true;
+    }
+
+    private static int GetLayerStar(PlayerGameData data, IReadOnlyList<uint> towerIds)
+    {
+        var total = 0;
+        foreach (var towerId in towerIds)
+        {
+            var attr = data.Attrs.FirstOrDefault(x => x.Gid == TowerGroupId && x.Sid == TowerLevelStateSidBase + towerId);
+            var value = attr?.Val ?? 0;
+            for (var i = 0; i < 9; i++)
+            {
+                if (((value >> i) & 1u) != 0)
+                    total++;
+            }
+        }
+
+        return total;
+    }
+
+    private static bool IsRewardClaimed(PlayerGameData data, int layer, int group)
+    {
+        var attr = data.Attrs.FirstOrDefault(x => x.Gid == TowerGroupId && x.Sid == RewardStateSidBase + (uint)layer);
+        if (attr == null)
+            return false;
+
+        var offset = GetFlagBitOffset(group);
+        return ((attr.Val >> offset) & 0xFu) > 0;
+    }
+
+    private static int GetFlagBitOffset(int group) => group switch
+    {
+        0 => 0,
+        1 => 4,
+        2 => 8,
+        3 => 12,
+        _ => 0
+    };
+
+    private static List<int> ResolveRequestedGroups(int? group)
+    {
+        if (!group.HasValue)
+            return [0, 1, 2, 3];
+
+        return group.Value is >= 0 and <= 3 ? [group.Value] : [];
+    }
+
+    private static bool TryResolveLayer(
+        ClimbTowerTimeExcel cycle,
+        int layer,
+        PlayerGameData data,
+        out IReadOnlyList<uint> towerIds,
+        out int diff)
+    {
+        var basicGroups = cycle.GetLevelGroups(1);
+        if (layer <= basicGroups.Count)
+        {
+            towerIds = basicGroups[layer - 1];
+            diff = 1;
+            return towerIds.Count > 0;
+        }
+
+        var advancedIndex = layer - basicGroups.Count;
+        var advancedGroups = cycle.GetLevelGroups(2);
+        if (advancedIndex <= 0 || advancedIndex > advancedGroups.Count)
+        {
+            towerIds = [];
+            diff = 0;
+            return false;
+        }
+
+        var diffAttr = data.Attrs.FirstOrDefault(x => x.Gid == TowerGroupId && x.Sid == AdvancedDiffSid);
+        diff = (int)(diffAttr?.Val ?? 0);
+        towerIds = advancedGroups[advancedIndex - 1];
+        return diff > 0 && towerIds.Count > 0;
+    }
+
+    private static ClimbTowerTimeExcel? ResolveCurrentCycle(IEnumerable<ClimbTowerTimeExcel> configs, DateTime now)
+    {
+        var parsed = configs
+            .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;
+
+        var latestStarted = parsed.LastOrDefault(x => x.Start <= now);
+        if (latestStarted != null)
+            return latestStarted.Config;
+
+        return parsed.FirstOrDefault()?.Config;
+    }
+
+    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(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
+        };
+        data.Attrs.Add(attr);
+        return attr;
+    }
+
+    private static void SyncAttr(NtfSyncPlayer sync, PlayerInstance player, 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 ClimbTowerGetRewardParam
+{
+    [JsonPropertyName("nType")]
+    public int? Type { get; set; }
+
+    [JsonPropertyName("nLayer")]
+    public int Layer { get; set; }
+
+    [JsonPropertyName("nGroup")]
+    public int? Group { get; set; }
+}

GameServer/Server/CallGS/Handlers/Tower/ClimbTowerLogic_RecordProgres.cs

@@ -0,0 +1,219 @@
+using MikuSB.Data;
+using MikuSB.Data.Excel;
+using MikuSB.Database;
+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.Tower;
+
+[CallGSApi("ClimbTowerLogic_RecordProgres")]
+public class ClimbTowerLogic_RecordProgres : ICallGSHandler
+{
+    private const uint TowerGroupId = 3;
+    private const uint BasicProgressSid = 2;
+    private const uint AdvancedProgressSid = 3;
+    private const uint LevelStateSidBase = 10000;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var player = connection.Player!;
+        var req = JsonSerializer.Deserialize<ClimbTowerRecordProgressParam>(param);
+        if (req == null || req.LevelId == 0 || req.Area <= 0)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_RecordProgres", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var cycle = ResolveCurrentCycle(GameData.ClimbTowerTimeData.Values, DateTime.Now);
+        if (cycle == null)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_RecordProgres", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var towerType = ResolveTowerType(cycle, (uint)req.LevelId);
+        if (towerType == 0)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_RecordProgres", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var sync = new NtfSyncPlayer();
+
+        var levelStateSid = LevelStateSidBase + (uint)req.LevelId;
+        var levelState = GetOrCreateAttr(player.Data, TowerGroupId, levelStateSid);
+        levelState.Val = MergeAreaStars(levelState.Val, req.Area, req.StarMask);
+        SyncAttr(sync, player, levelState);
+
+        var progressSid = towerType == 1 ? BasicProgressSid : AdvancedProgressSid;
+        var progressAttr = GetOrCreateAttr(player.Data, TowerGroupId, progressSid);
+        progressAttr.Val = req.Area >= 3 ? 0u : PackProgress((uint)req.LevelId, (uint)(req.Area + 1));
+        SyncAttr(sync, player, progressAttr);
+
+        if (req.RoleHP.Count > 0 || req.TeamEnergy.HasValue)
+        {
+            SaveRoleState(player, sync, towerType, req.RoleHP, req.TeamEnergy.GetValueOrDefault());
+        }
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        await CallGSRouter.SendScript(connection, "ClimbTowerLogic_RecordProgres", "{}", sync);
+    }
+
+    private static void SaveRoleState(
+        PlayerInstance player,
+        NtfSyncPlayer sync,
+        int towerType,
+        List<List<int>> roleHp,
+        int teamEnergy)
+    {
+        var slotStart = towerType == 2 ? 4u : 1u;
+
+        for (var slot = slotStart; slot < slotStart + 3; slot++)
+        {
+            var templateAttr = GetOrCreateAttr(player.Data, TowerGroupId, slot * 10);
+            var hpAttr = GetOrCreateAttr(player.Data, TowerGroupId, slot * 10 + 1);
+            templateAttr.Val = 0;
+            hpAttr.Val = 0;
+            SyncAttr(sync, player, templateAttr);
+            SyncAttr(sync, player, hpAttr);
+        }
+
+        for (var i = 0; i < Math.Min(roleHp.Count, 3); i++)
+        {
+            var row = roleHp[i];
+            if (row == null || row.Count < 2)
+                continue;
+
+            var slot = slotStart + (uint)i;
+            var templateAttr = GetOrCreateAttr(player.Data, TowerGroupId, slot * 10);
+            var hpAttr = GetOrCreateAttr(player.Data, TowerGroupId, slot * 10 + 1);
+            templateAttr.Val = (uint)Math.Max(0, row[0]);
+            hpAttr.Val = (uint)Math.Max(0, row[1]);
+            SyncAttr(sync, player, templateAttr);
+            SyncAttr(sync, player, hpAttr);
+        }
+
+        var energyAttr = GetOrCreateAttr(player.Data, TowerGroupId, slotStart * 10 + 2);
+        energyAttr.Val = (uint)Math.Max(0, teamEnergy);
+        SyncAttr(sync, player, energyAttr);
+    }
+
+    private static uint MergeAreaStars(uint currentValue, int area, int starMask)
+    {
+        var areaIndex = Math.Clamp(area, 1, 3) - 1;
+        var result = currentValue;
+        for (var i = 0; i < 3; i++)
+        {
+            if (((starMask >> i) & 1) == 0)
+                continue;
+
+            var bitIndex = areaIndex * 3 + i;
+            result |= 1u << bitIndex;
+        }
+
+        return result;
+    }
+
+    private static uint PackProgress(uint levelId, uint area) => (area << 24) | (levelId & 0x00FF_FFFF);
+
+    private static int ResolveTowerType(ClimbTowerTimeExcel cycle, uint levelId)
+    {
+        if (ContainsLevel(cycle.GetLevelGroups(1), levelId))
+            return 1;
+
+        if (ContainsLevel(cycle.GetLevelGroups(2), levelId))
+            return 2;
+
+        return 0;
+    }
+
+    private static bool ContainsLevel(IEnumerable<IReadOnlyList<uint>> groups, uint levelId)
+    {
+        return groups.Any(group => group.Any(id => id == levelId));
+    }
+
+    private static ClimbTowerTimeExcel? ResolveCurrentCycle(IEnumerable<ClimbTowerTimeExcel> configs, DateTime now)
+    {
+        var parsed = configs
+            .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;
+
+        var latestStarted = parsed.LastOrDefault(x => x.Start <= now);
+        if (latestStarted != null)
+            return latestStarted.Config;
+
+        return parsed.FirstOrDefault()?.Config;
+    }
+
+    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",
+            System.Globalization.CultureInfo.InvariantCulture,
+            System.Globalization.DateTimeStyles.None,
+            out var value)
+            ? value
+            : null;
+    }
+
+    private 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
+        };
+        data.Attrs.Add(attr);
+        return attr;
+    }
+
+    private static void SyncAttr(NtfSyncPlayer sync, PlayerInstance player, 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 ClimbTowerRecordProgressParam
+{
+    [JsonPropertyName("nID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nArea")]
+    public int Area { get; set; }
+
+    [JsonPropertyName("nStar")]
+    public int StarMask { get; set; }
+
+    [JsonPropertyName("tbRoleHP")]
+    public List<List<int>> RoleHP { get; set; } = [];
+
+    [JsonPropertyName("nTeamEnergy")]
+    public int? TeamEnergy { get; set; }
+}

GameServer/Server/CallGS/Handlers/Tower/ClimbTowerLogic_SetLevelDiff.cs

@@ -0,0 +1,76 @@
+using MikuSB.Data;
+using MikuSB.Database;
+using MikuSB.Database.Player;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Tower;
+
+[CallGSApi("ClimbTowerLogic_SetLevelDiff")]
+public class ClimbTowerLogic_SetLevelDiff : ICallGSHandler
+{
+    private const uint TowerGroupId = 3;
+    private const uint DiffSid = 4;
+    private const uint HisDiffSid = 5;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var player = connection.Player!;
+        var req = JsonSerializer.Deserialize<ClimbTowerSetLevelDiffParam>(param);
+        if (req == null || req.Diff <= 0)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_SetLevelDiff", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        if (!GameData.ClimbTowerDiffData.ContainsKey((uint)req.Diff))
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_SetLevelDiff", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var hisDiff = GetAttrValue(player.Data, TowerGroupId, HisDiffSid);
+        if (req.Diff > hisDiff + 1)
+        {
+            await CallGSRouter.SendScript(connection, "ClimbTowerLogic_SetLevelDiff", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var diffAttr = GetOrCreateAttr(player.Data, TowerGroupId, DiffSid);
+        diffAttr.Val = (uint)req.Diff;
+
+        var sync = new NtfSyncPlayer();
+        sync.Custom[player.ToPackedAttrKey(diffAttr.Gid, diffAttr.Sid)] = diffAttr.Val;
+        sync.Custom[player.ToShiftedAttrKey(diffAttr.Gid, diffAttr.Sid)] = diffAttr.Val;
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        await CallGSRouter.SendScript(connection, "ClimbTowerLogic_SetLevelDiff", "{}", sync);
+    }
+
+    private static uint GetAttrValue(PlayerGameData data, uint gid, uint sid)
+    {
+        return data.Attrs.FirstOrDefault(x => x.Gid == gid && x.Sid == sid)?.Val ?? 0;
+    }
+
+    private 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
+        };
+        data.Attrs.Add(attr);
+        return attr;
+    }
+}
+
+internal sealed class ClimbTowerSetLevelDiffParam
+{
+    [JsonPropertyName("nDiff")]
+    public int Diff { get; set; }
+}

GameServer/Server/CallGS/Handlers/Tower/TowerEventChapter_EnterLevel.cs

@@ -0,0 +1,39 @@
+using MikuSB.Data;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Tower;
+
+[CallGSApi("TowerEventChapter_EnterLevel")]
+public class TowerEventChapter_EnterLevel : ICallGSHandler
+{
+    private static readonly Random Random = new();
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<TowerEventEnterLevelParam>(param);
+        if (req == null || req.LevelId == 0 || req.TeamId <= 0)
+        {
+            await CallGSRouter.SendScript(connection, "TowerEventChapter_EnterLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        if (!GameData.TowerEventLevelData.ContainsKey((uint)req.LevelId))
+        {
+            await CallGSRouter.SendScript(connection, "TowerEventChapter_EnterLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var rsp = $"{{\"nSeed\":{Random.Next(1, 1_000_000_000)}}}";
+        await CallGSRouter.SendScript(connection, "TowerEventChapter_EnterLevel", rsp);
+    }
+}
+
+internal sealed class TowerEventEnterLevelParam
+{
+    [JsonPropertyName("nID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nTeamID")]
+    public int TeamId { get; set; }
+}

GameServer/Server/CallGS/Handlers/Tower/TowerEventChapter_LevelSettlement.cs

@@ -0,0 +1,82 @@
+using MikuSB.Database;
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+using MikuSB.Util;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Tower;
+
+[CallGSApi("TowerEventChapter_LevelSettlement")]
+public class TowerEventChapter_LevelSettlement : ICallGSHandler
+{
+    private const uint LevelStateGroupId = 21;
+    private const uint LaunchPassGroupId = 22;
+    private const uint PassedFlagMask = (1u << 8) | 0b111u;
+    private static readonly Logger Logger = new("TowerEvent");
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var (response, sync) = HandleSettlement(connection.Player!, JsonNode.Parse(param));
+        await CallGSRouter.SendScript(connection, "TowerEventChapter_LevelSettlement", response.ToJsonString(), sync);
+    }
+
+    public static (JsonNode Response, NtfSyncPlayer Sync) HandleSettlement(PlayerInstance player, JsonNode? tbParam)
+    {
+        var req = tbParam?.Deserialize<TowerEventSettlementParam>();
+        if (req == null || req.LevelId == 0 || req.ChapterId == 0)
+        {
+            Logger.Error($"Invalid tower event settlement payload: {tbParam?.ToJsonString() ?? "null"}");
+            return (new JsonObject { ["sErr"] = "error.BadParam" }, new NtfSyncPlayer());
+        }
+
+        var sync = new NtfSyncPlayer();
+
+        var levelStateAttr = GetOrCreateAttr(player.Data, LevelStateGroupId, (uint)req.LevelId);
+        levelStateAttr.Val |= PassedFlagMask;
+        SyncAttr(sync, player, levelStateAttr);
+
+        var passAttr = GetOrCreateAttr(player.Data, LaunchPassGroupId, (uint)req.LevelId);
+        passAttr.Val = Math.Max(1u, passAttr.Val + 1);
+        SyncAttr(sync, player, passAttr);
+
+        Logger.Info(
+            $"TowerEvent settlement saved. uid={player.Uid} chapterId={req.ChapterId} levelId={req.LevelId} " +
+            $"levelStateVal={levelStateAttr.Val} passVal={passAttr.Val}");
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        return (new JsonObject(), sync);
+    }
+
+    private 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
+        };
+        data.Attrs.Add(attr);
+        return attr;
+    }
+
+    private static void SyncAttr(NtfSyncPlayer sync, PlayerInstance player, 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 TowerEventSettlementParam
+{
+    [JsonPropertyName("nID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nChapterID")]
+    public int ChapterId { get; set; }
+}

GameServer/Server/CallGS/Handlers/Tower/TowerLevel_EnterLevel.cs

@@ -0,0 +1,39 @@
+using MikuSB.Data;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Tower;
+
+[CallGSApi("TowerLevel_EnterLevel")]
+public class TowerLevel_EnterLevel : ICallGSHandler
+{
+    private static readonly Random Random = new();
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<TowerLevelEnterLevelParam>(param);
+        if (req == null || req.LevelId == 0 || req.TeamId <= 0)
+        {
+            await CallGSRouter.SendScript(connection, "TowerLevel_EnterLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        if (!GameData.TowerLevelData.ContainsKey((uint)req.LevelId))
+        {
+            await CallGSRouter.SendScript(connection, "TowerLevel_EnterLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var rsp = $"{{\"nSeed\":{Random.Next(1, 1_000_000_000)}}}";
+        await CallGSRouter.SendScript(connection, "TowerLevel_EnterLevel", rsp);
+    }
+}
+
+internal sealed class TowerLevelEnterLevelParam
+{
+    [JsonPropertyName("nID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nTeamID")]
+    public int TeamId { get; set; }
+}

GameServer/Server/CallGS/Handlers/Tower/TowerLevel_LevelSettlement.cs

@@ -0,0 +1,178 @@
+using MikuSB.Data;
+using MikuSB.Data.Excel;
+using MikuSB.Database;
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+using MikuSB.Util;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Tower;
+
+[CallGSApi("TowerLevel_LevelSettlement")]
+public class TowerLevel_LevelSettlement : ICallGSHandler
+{
+    private static readonly Logger Logger = new("Tower");
+    private const uint TowerGroupId = 3;
+    private const uint LaunchPassGroupId = 22;
+    private const uint BasicProgressSid = 2;
+    private const uint AdvancedProgressSid = 3;
+    private const uint LevelStateSidBase = 10000;
+    private const int FinalArea = 3;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var (response, sync) = HandleSettlement(connection.Player!, JsonNode.Parse(param));
+        await CallGSRouter.SendScript(connection, "TowerLevel_LevelSettlement", response.ToJsonString(), sync);
+    }
+
+    public static (JsonNode Response, NtfSyncPlayer Sync) HandleSettlement(PlayerInstance player, JsonNode? tbParam)
+    {
+        var req = tbParam?.Deserialize<TowerLevelSettlementParam>();
+        if (req == null || req.TowerId == 0 || req.LevelId == 0)
+        {
+            Logger.Error($"Invalid tower settlement payload: {tbParam?.ToJsonString() ?? "null"}");
+            return (new JsonObject { ["sErr"] = "error.BadParam" }, new NtfSyncPlayer());
+        }
+
+        var cycle = ResolveCurrentCycle(GameData.ClimbTowerTimeData.Values, DateTime.Now);
+        if (cycle == null)
+            return (new JsonObject { ["sErr"] = "error.BadParam" }, new NtfSyncPlayer());
+
+        var towerType = ResolveTowerType(cycle, (uint)req.TowerId);
+        if (towerType == 0)
+            return (new JsonObject { ["sErr"] = "error.BadParam" }, new NtfSyncPlayer());
+
+        var sync = new NtfSyncPlayer();
+        var levelStateSid = LevelStateSidBase + (uint)req.TowerId;
+        var levelState = GetOrCreateAttr(player.Data, TowerGroupId, levelStateSid);
+        levelState.Val = MergeAreaStars(levelState.Val, FinalArea, req.StarMask);
+        SyncAttr(sync, player, levelState);
+
+        var progressSid = towerType == 1 ? BasicProgressSid : AdvancedProgressSid;
+        var progressAttr = GetOrCreateAttr(player.Data, TowerGroupId, progressSid);
+        progressAttr.Val = 0;
+        SyncAttr(sync, player, progressAttr);
+
+        var passAttr = GetOrCreateAttr(player.Data, LaunchPassGroupId, (uint)req.LevelId);
+        passAttr.Val = Math.Max(1u, passAttr.Val + 1);
+        SyncAttr(sync, player, passAttr);
+
+        Logger.Info(
+            $"Tower settlement saved. uid={player.Uid} towerId={req.TowerId} levelId={req.LevelId} starMask={req.StarMask} " +
+            $"towerStateSid={levelStateSid} towerStateVal={levelState.Val} progressSid={progressSid} passVal={passAttr.Val}");
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        return (new JsonObject(), sync);
+    }
+
+    private static uint MergeAreaStars(uint currentValue, int area, int starMask)
+    {
+        var areaIndex = Math.Clamp(area, 1, 3) - 1;
+        var result = currentValue;
+        for (var i = 0; i < 3; i++)
+        {
+            if (((starMask >> i) & 1) == 0)
+                continue;
+
+            var bitIndex = areaIndex * 3 + i;
+            result |= 1u << bitIndex;
+        }
+
+        return result;
+    }
+
+    private static int ResolveTowerType(ClimbTowerTimeExcel cycle, uint levelId)
+    {
+        if (ContainsLevel(cycle.GetLevelGroups(1), levelId))
+            return 1;
+
+        if (ContainsLevel(cycle.GetLevelGroups(2), levelId))
+            return 2;
+
+        return 0;
+    }
+
+    private static bool ContainsLevel(IEnumerable<IReadOnlyList<uint>> groups, uint levelId)
+    {
+        return groups.Any(group => group.Any(id => id == levelId));
+    }
+
+    private static ClimbTowerTimeExcel? ResolveCurrentCycle(IEnumerable<ClimbTowerTimeExcel> configs, DateTime now)
+    {
+        var parsed = configs
+            .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;
+
+        var latestStarted = parsed.LastOrDefault(x => x.Start <= now);
+        if (latestStarted != null)
+            return latestStarted.Config;
+
+        return parsed.FirstOrDefault()?.Config;
+    }
+
+    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",
+            System.Globalization.CultureInfo.InvariantCulture,
+            System.Globalization.DateTimeStyles.None,
+            out var value)
+            ? value
+            : null;
+    }
+
+    private 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
+        };
+        data.Attrs.Add(attr);
+        return attr;
+    }
+
+    private static void SyncAttr(MikuSB.Proto.NtfSyncPlayer sync, PlayerInstance player, 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 TowerLevelSettlementParam
+{
+    [JsonPropertyName("nID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nTowerID")]
+    public int TowerId { get; set; }
+
+    [JsonPropertyName("nStar")]
+    public int StarMask { get; set; }
+}

version.txt

@@ -1 +1 @@
-v=3.7
+v=4.1