Update version.txt

Common/Data/Excel/MonsterCardExcel.cs

@@ -0,0 +1,25 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("item/templates/monster_card.json")]
+public class MonsterCardExcel : ExcelResource
+{
+    [JsonProperty("Genre")] public uint Genre { get; set; }
+    [JsonProperty("Detail")] public uint Detail { get; set; }
+    [JsonProperty("Particular")] public uint Particular { get; set; }
+    [JsonProperty("Level")] public uint Level { get; set; }
+    [JsonProperty("Color")] public uint Color { get; set; }
+    [JsonProperty("RikiId")] public uint RikiId { get; set; }
+    [JsonProperty("CostValue")] public uint CostValue { get; set; }
+
+    [JsonIgnore]
+    public ulong TemplateId => GameResourceTemplateId.FromGdpl(Genre, Detail, Particular, Level);
+
+    public override uint GetId() => Particular;
+
+    public override void Loaded()
+    {
+        GameData.MonsterCardData[TemplateId] = 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/VirCaptureCaptureRegionExcel.cs

@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("dlc/vircapture/captureregion.json")]
+public class VirCaptureCaptureRegionExcel : ExcelResource
+{
+    [JsonProperty("Id")] public uint Id { get; set; }
+    [JsonProperty("StartTime")] public string StartTime { get; set; } = "";
+    [JsonProperty("EndTime")] public string EndTime { get; set; } = "";
+    [JsonProperty("MapId")] public uint MapId { get; set; }
+    [JsonProperty("LevelRegionName")] public string LevelRegionName { get; set; } = "";
+
+    public override uint GetId() => Id;
+
+    public override void Loaded()
+    {
+        GameData.VirCaptureCaptureRegionData[Id] = this;
+    }
+}

Common/Data/Excel/VirCaptureLevelListExcel.cs

@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("dlc/vircapture/levellist.json")]
+public class VirCaptureLevelListExcel : ExcelResource
+{
+    [JsonProperty("Level")] public uint Level { get; set; }
+    [JsonProperty("Num")] public uint Num { get; set; }
+    [JsonProperty("MaxCost")] public uint MaxCost { get; set; }
+
+    public override uint GetId() => Level;
+
+    public override void Loaded()
+    {
+        GameData.VirCaptureLevelListData[Level] = this;
+    }
+}

Common/Data/Excel/VirCaptureSeasonExcel.cs

@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("dlc/vircapture/season.json")]
+public class VirCaptureSeasonExcel : ExcelResource
+{
+    [JsonProperty("Id")] public uint Id { get; set; }
+    [JsonProperty("StartTime")] public string StartTime { get; set; } = "";
+    [JsonProperty("EndTime")] public string EndTime { get; set; } = "";
+
+    public override uint GetId() => Id;
+
+    public override void Loaded()
+    {
+        GameData.VirCaptureSeasonData[Id] = this;
+    }
+}

Common/Data/Excel/VirCaptureTimeExcel.cs

@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("dlc/vircapture/timelist.json")]
+public class VirCaptureTimeExcel : ExcelResource
+{
+    [JsonProperty("Id")] public uint Id { get; set; }
+    [JsonProperty("StartTime")] public string StartTime { get; set; } = "";
+    [JsonProperty("EndTime")] public string EndTime { get; set; } = "";
+    [JsonProperty("CaptureRegionId")] public List<uint> CaptureRegionId { get; set; } = [];
+
+    public override uint GetId() => Id;
+
+    public override void Loaded()
+    {
+        GameData.VirCaptureTimeData[Id] = this;
+    }
+}

Common/Data/Excel/VirCaptureTrialTimeExcel.cs

@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("dlc/vircapture/trial_timelist.json")]
+public class VirCaptureTrialTimeExcel : ExcelResource
+{
+    [JsonProperty("Id")] public uint Id { get; set; }
+    [JsonProperty("StartTime")] public string StartTime { get; set; } = "";
+    [JsonProperty("EndTime")] public string EndTime { get; set; } = "";
+    [JsonProperty("AwardTime")] public string AwardTime { get; set; } = "";
+
+    public override uint GetId() => Id;
+
+    public override void Loaded()
+    {
+        GameData.VirCaptureTrialTimeData[Id] = this;
+    }
+}

Common/Data/GameData.cs

@@ -38,6 +38,7 @@ public static class GameData
     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; } = [];
@@ -49,6 +50,12 @@ public static class GameData
     public static Dictionary<uint, GachaExcel> GachaData { get; private set; } = [];
     public static Dictionary<uint, GachaProbabilityExcel> GachaProbabilityData { get; private set; } = [];
     public static Dictionary<string, List<GachaPoolItem>> GachaPoolData { get; private set; } = [];
+    public static Dictionary<uint, VirCaptureTimeExcel> VirCaptureTimeData { get; private set; } = [];
+    public static Dictionary<uint, VirCaptureSeasonExcel> VirCaptureSeasonData { get; private set; } = [];
+    public static Dictionary<uint, VirCaptureTrialTimeExcel> VirCaptureTrialTimeData { get; private set; } = [];
+    public static Dictionary<uint, VirCaptureCaptureRegionExcel> VirCaptureCaptureRegionData { get; private set; } = [];
+    public static Dictionary<uint, VirCaptureLevelListExcel> VirCaptureLevelListData { get; private set; } = [];
+    public static Dictionary<ulong, MonsterCardExcel> MonsterCardData { get; private set; } = [];
 }
 
 public static class GameResourceTemplateId

GameServer/Game/Inventory/InventoryManager.cs

@@ -208,6 +208,27 @@ public class InventoryManager(PlayerInstance player) : BasePlayerManager(player)
         return InventoryData.Items.Values.FirstOrDefault(x => x.TemplateId == templateId);
     }
 
+    public async ValueTask<BaseGameItemInfo?> AddMonsterCardItem(uint detail, uint particular, uint level = 1, bool sendPacket = true)
+    {
+        const ItemTypeEnum genre = ItemTypeEnum.TYPE_MONSTER_CARD;
+        var templateId = GameResourceTemplateId.FromGdpl((uint)genre, detail, particular, level);
+        if (!GameData.MonsterCardData.ContainsKey(templateId))
+            return null;
+
+        var monsterInfo = new BaseGameItemInfo
+        {
+            TemplateId = templateId,
+            UniqueId = InventoryData.NextUniqueUid++,
+            ItemType = genre,
+            ItemCount = 1
+        };
+        InventoryData.Items[monsterInfo.UniqueId] = monsterInfo;
+
+        if (sendPacket) await Player.SendPacket(new PacketNtfCallScript([monsterInfo]));
+
+        return monsterInfo;
+    }
+
     private static uint GetSuppliesMaxCount(SuppliesExcel suppliesData) =>
         suppliesData.Genre == 5 && suppliesData.Detail == 4 ? 999999u : 99999u;
 

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

@@ -45,7 +45,8 @@ public class Chapter_DealLevelSettlement : ICallGSHandler
 
         if (string.Equals(sCmd, "BossPvpLogic_LevelSettlement", StringComparison.Ordinal))
         {
-            var (response, sync) = BossPvpService.HandleSettlement(connection.Player!, tbParam);
+            var normalized = NormalizeBossPvpSettlement(tbParam);
+            var (response, sync) = BossPvpService.HandleSettlement(connection.Player!, normalized);
             extraSync = sync;
             return response;
         }
@@ -64,8 +65,31 @@ public class Chapter_DealLevelSettlement : ICallGSHandler
             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/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/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/VirCapture/VirCaptureCaptureRewardResolver.cs

@@ -0,0 +1,134 @@
+using MikuSB.Data.Excel;
+using MikuSB.Util;
+using Newtonsoft.Json.Linq;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+internal static class VirCaptureCaptureRewardResolver
+{
+    private static readonly Lock CacheLock = new();
+    private static readonly Dictionary<string, Dictionary<uint, VirCaptureLevelRegionReward>> RegionCache = [];
+    private static readonly Dictionary<string, Dictionary<uint, List<uint>>> BossCache = [];
+
+    public static List<uint>? ResolveGdpl(VirCaptureCaptureRegionExcel captureRegion, uint regionId)
+    {
+        if (string.IsNullOrWhiteSpace(captureRegion.LevelRegionName))
+            return null;
+
+        var regionMap = GetOrLoadRegionMap(captureRegion.LevelRegionName);
+        if (!regionMap.TryGetValue(regionId, out var regionReward))
+            return null;
+
+        if (regionReward.PalType == 2)
+            return GetOrLoadBossMap(captureRegion.LevelRegionName).GetValueOrDefault(regionId);
+
+        return regionReward.Rewards1;
+    }
+
+    private static Dictionary<uint, VirCaptureLevelRegionReward> GetOrLoadRegionMap(string mapName)
+    {
+        lock (CacheLock)
+        {
+            if (RegionCache.TryGetValue(mapName, out var cached))
+                return cached;
+
+            var loaded = new Dictionary<uint, VirCaptureLevelRegionReward>();
+            var path = Path.Combine(
+                ConfigManager.Config.Path.ResourcePath,
+                "dlc",
+                "vircapture",
+                mapName,
+                "region_info.json");
+
+            if (File.Exists(path))
+            {
+                var array = JArray.Parse(File.ReadAllText(path));
+                foreach (var token in array)
+                {
+                    var id = ReadUInt(token["Id"]);
+                    if (id == 0)
+                        continue;
+
+                    loaded[id] = new VirCaptureLevelRegionReward
+                    {
+                        PalType = ReadInt(token["PalType"]),
+                        Rewards1 = token["Rewards1"]?.ToObject<List<uint>>() ?? []
+                    };
+                }
+            }
+
+            RegionCache[mapName] = loaded;
+            return loaded;
+        }
+    }
+
+    private static Dictionary<uint, List<uint>> GetOrLoadBossMap(string mapName)
+    {
+        lock (CacheLock)
+        {
+            if (BossCache.TryGetValue(mapName, out var cached))
+                return cached;
+
+            var loaded = new Dictionary<uint, List<uint>>();
+            var path = Path.Combine(
+                ConfigManager.Config.Path.ResourcePath,
+                "dlc",
+                "vircapture",
+                mapName,
+                "boss.json");
+
+            if (File.Exists(path))
+            {
+                var array = JArray.Parse(File.ReadAllText(path));
+                foreach (var token in array)
+                {
+                    var regionId = ReadUInt(token["RegionId"]);
+                    var boss = token["Boss"]?.ToObject<List<uint>>();
+                    if (regionId == 0 || boss == null || boss.Count < 4)
+                        continue;
+
+                    loaded.TryAdd(regionId, boss);
+                }
+            }
+
+            BossCache[mapName] = loaded;
+            return loaded;
+        }
+    }
+
+    private sealed class VirCaptureLevelRegionReward
+    {
+        public int PalType { get; init; }
+        public List<uint> Rewards1 { get; init; } = [];
+    }
+
+    private static uint ReadUInt(JToken? token)
+    {
+        if (token == null || token.Type == JTokenType.Null)
+            return 0;
+
+        return token.Type switch
+        {
+            JTokenType.Integer => token.Value<uint>(),
+            JTokenType.Float => Math.Max(0u, (uint)token.Value<double>()),
+            JTokenType.String when uint.TryParse(token.Value<string>(), out var value) => value,
+            JTokenType.String => 0,
+            _ => 0
+        };
+    }
+
+    private static int ReadInt(JToken? token)
+    {
+        if (token == null || token.Type == JTokenType.Null)
+            return 0;
+
+        return token.Type switch
+        {
+            JTokenType.Integer => token.Value<int>(),
+            JTokenType.Float => (int)token.Value<double>(),
+            JTokenType.String when int.TryParse(token.Value<string>(), out var value) => value,
+            JTokenType.String => 0,
+            _ => 0
+        };
+    }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCaptureLevel_ChangeFlag.cs

@@ -0,0 +1,40 @@
+using MikuSB.Database;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+[CallGSApi("VirCaptureLevel_ChangeFlag")]
+public class VirCaptureLevel_ChangeFlag : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<VirCaptureChangeFlagParam>(param);
+        if (req == null || req.LevelId == 0 || req.RegionId == 0)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_ChangeFlag", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+        VirCaptureStateHelper.SetPointState(player, (uint)req.LevelId, (uint)req.RegionId, req.Clean ? 0u : 1u, sync);
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        var rsp = $"{{\"nLevelID\":{req.LevelId},\"nRegionId\":{req.RegionId},\"bClean\":{req.Clean.ToString().ToLowerInvariant()}}}";
+        await CallGSRouter.SendScript(connection, "VirCaptureLevel_ChangeFlag", rsp, sync);
+    }
+}
+
+internal sealed class VirCaptureChangeFlagParam
+{
+    [JsonPropertyName("nLevelID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nRegionId")]
+    public int RegionId { get; set; }
+
+    [JsonPropertyName("bClean")]
+    public bool Clean { get; set; }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCaptureLevel_EnterLevel.cs

@@ -0,0 +1,171 @@
+using MikuSB.Data;
+using MikuSB.Data.Excel;
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+[CallGSApi("VirCaptureLevel_EnterLevel")]
+public class VirCaptureLevel_EnterLevel : ICallGSHandler
+{
+    private const uint GroupId = 128;
+    private const uint MapDataStart = 10000;
+    private const uint MaxMapCount = 3;
+    private const uint MaxMapDataLen = 3000;
+    private const uint OffMapId = 1;
+    private const uint OffDayNight = 7;
+    private const uint OffMapLevel = 8;
+    private static readonly Random Random = new();
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<VirCaptureEnterLevelParam>(param);
+        if (req == null || req.LevelId == 0 || req.TeamId <= 0)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_EnterLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var now = DateTime.Now;
+        var act = ResolveCurrent(GameData.VirCaptureTimeData.Values, now);
+        if (act == null || !act.CaptureRegionId.Contains((uint)req.LevelId))
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_EnterLevel", "{\"sErr\":\"ui.TxtNotOpen\"}");
+            return;
+        }
+
+        if (!GameData.VirCaptureCaptureRegionData.TryGetValue((uint)req.LevelId, out var region))
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_EnterLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var regionStart = ParseConfigTime(region.StartTime);
+        var regionEnd = ParseConfigTime(region.EndTime);
+        if (!regionStart.HasValue || !regionEnd.HasValue || now < regionStart.Value || now >= regionEnd.Value)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_EnterLevel", "{\"sErr\":\"ui.TxtNotOpen\"}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+        EnsureMapState(player, (uint)req.LevelId, sync);
+
+        var rsp = $"{{\"nSeed\":{Random.Next(1, 1_000_000_000)}}}";
+        await CallGSRouter.SendScript(connection, "VirCaptureLevel_EnterLevel", rsp, sync);
+    }
+
+    private static void EnsureMapState(PlayerInstance player, uint levelId, NtfSyncPlayer sync)
+    {
+        var slotStart = FindOrAllocateMapSlot(player, levelId);
+        if (slotStart == 0)
+            return;
+
+        EnsureMapAttr(player, slotStart + OffMapId, levelId, sync);
+        EnsureMapAttr(player, slotStart + OffDayNight, 1, sync);
+        EnsureMapAttr(player, slotStart + OffMapLevel, 1, sync);
+    }
+
+    private static uint FindOrAllocateMapSlot(PlayerInstance player, uint levelId)
+    {
+        uint? emptySlot = null;
+        for (uint i = 0; i < MaxMapCount; i++)
+        {
+            var slotStart = MapDataStart + (i * MaxMapDataLen);
+            var mapIdAttr = player.Data.Attrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == slotStart + OffMapId);
+            if (mapIdAttr?.Val == levelId)
+                return slotStart;
+
+            if (emptySlot == null && (mapIdAttr == null || mapIdAttr.Val == 0))
+                emptySlot = slotStart;
+        }
+
+        return emptySlot ?? 0;
+    }
+
+    private static void EnsureMapAttr(PlayerInstance player, uint sid, uint minValue, 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,
+                Val = minValue
+            };
+            player.Data.Attrs.Add(attr);
+            SyncAttr(player, sync, sid, minValue);
+            return;
+        }
+
+        if (attr.Val < minValue)
+        {
+            attr.Val = minValue;
+            SyncAttr(player, sync, sid, attr.Val);
+        }
+    }
+
+    private static void SyncAttr(PlayerInstance player, NtfSyncPlayer sync, uint sid, uint value)
+    {
+        sync.Custom[player.ToPackedAttrKey(GroupId, sid)] = value;
+        sync.Custom[player.ToShiftedAttrKey(GroupId, sid)] = value;
+    }
+
+    private static VirCaptureTimeExcel? ResolveCurrent(IEnumerable<VirCaptureTimeExcel> 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 && latestStarted.End > latestStarted.Start)
+            return latestStarted.Config;
+
+        return null;
+    }
+
+    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;
+    }
+}
+
+internal sealed class VirCaptureEnterLevelParam
+{
+    [JsonPropertyName("nLevelID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nTeamID")]
+    public int TeamId { get; set; }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCaptureLevel_SaveCapture.cs

@@ -0,0 +1,101 @@
+using MikuSB.Database;
+using MikuSB.Data;
+using MikuSB.Enums.Item;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+[CallGSApi("VirCaptureLevel_SaveCapture")]
+public class VirCaptureLevel_SaveCapture : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<VirCaptureSaveCaptureParam>(param);
+        if (req == null || req.LevelId == 0 || req.RegionId == 0)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_SaveCapture", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+        VirCaptureStateHelper.SetPointState(player, (uint)req.LevelId, (uint)req.RegionId, 2u, sync);
+
+        if (!GameData.VirCaptureCaptureRegionData.TryGetValue((uint)req.LevelId, out var captureRegion))
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_SaveCapture", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var rewardGdpl = VirCaptureCaptureRewardResolver.ResolveGdpl(captureRegion, (uint)req.RegionId);
+        if (rewardGdpl == null || rewardGdpl.Count < 4 || rewardGdpl[0] != (uint)ItemTypeEnum.TYPE_MONSTER_CARD)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_SaveCapture", "{\"sErr\":\"error.BadParam\"}", sync);
+            return;
+        }
+
+        var grantedItem = await player.InventoryManager.AddMonsterCardItem(
+            rewardGdpl[1],
+            rewardGdpl[2],
+            rewardGdpl[3],
+            sendPacket: false);
+        if (grantedItem == null)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_SaveCapture", "{\"sErr\":\"error.BadParam\"}", sync);
+            return;
+        }
+
+        sync.Items.Add(grantedItem.ToProto());
+        SyncVirCaptureCounters(player, grantedItem.TemplateId, sync);
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        DatabaseHelper.SaveDatabaseType(player.InventoryManager.InventoryData);
+
+        var response = new JsonObject
+        {
+            ["nLevelID"] = req.LevelId,
+            ["nRegionId"] = req.RegionId,
+            ["nAddItemId"] = grantedItem.UniqueId,
+            ["tbGDPL"] = new JsonArray(rewardGdpl.Select(x => JsonValue.Create((int)x)).ToArray())
+        };
+
+        await CallGSRouter.SendScript(connection, "VirCaptureLevel_SaveCapture", response.ToJsonString(), sync);
+    }
+
+    private static void SyncVirCaptureCounters(MikuSB.GameServer.Game.Player.PlayerInstance player, ulong templateId, NtfSyncPlayer sync)
+    {
+        var bagCount = (uint)player.InventoryManager.InventoryData.Items.Values.Count(x => x.ItemType == ItemTypeEnum.TYPE_MONSTER_CARD);
+        VirCaptureStateHelper.SetUnsignedAttr(player, 5, bagCount, sync);
+
+        if (!GameData.MonsterCardData.TryGetValue(templateId, out var monsterCard) || monsterCard.RikiId == 0)
+            return;
+
+        var rikiAttr = player.Data.Attrs.FirstOrDefault(x => x.Gid == 135 && x.Sid == monsterCard.RikiId);
+        if (rikiAttr == null)
+        {
+            rikiAttr = new Database.Player.PlayerAttr
+            {
+                Gid = 135,
+                Sid = monsterCard.RikiId,
+                Val = 0
+            };
+            player.Data.Attrs.Add(rikiAttr);
+        }
+
+        rikiAttr.Val += 1;
+        sync.Custom[player.ToPackedAttrKey(135, monsterCard.RikiId)] = rikiAttr.Val;
+        sync.Custom[player.ToShiftedAttrKey(135, monsterCard.RikiId)] = rikiAttr.Val;
+    }
+}
+
+internal sealed class VirCaptureSaveCaptureParam
+{
+    [JsonPropertyName("nLevelID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nRegionId")]
+    public int RegionId { get; set; }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCaptureLevel_SaveFightData.cs

@@ -0,0 +1,45 @@
+using MikuSB.Database;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+[CallGSApi("VirCaptureLevel_SaveFightData")]
+public class VirCaptureLevel_SaveFightData : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<VirCaptureSaveFightDataParam>(param);
+        if (req == null || req.LevelId == 0 || req.RegionId == 0)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_SaveFightData", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+        VirCaptureStateHelper.SetPointState(player, (uint)req.LevelId, (uint)req.RegionId, 2u, sync);
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+
+        var response = new JsonObject
+        {
+            ["nLevelID"] = req.LevelId,
+            ["nRegionId"] = req.RegionId,
+            ["tbRewards"] = new JsonArray()
+        };
+
+        await CallGSRouter.SendScript(connection, "VirCaptureLevel_SaveFightData", response.ToJsonString(), sync);
+    }
+}
+
+internal sealed class VirCaptureSaveFightDataParam
+{
+    [JsonPropertyName("nLevelID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nRegionId")]
+    public int RegionId { get; set; }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCaptureLevel_SavePos.cs

@@ -0,0 +1,48 @@
+using MikuSB.Database;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+[CallGSApi("VirCaptureLevel_SavePos")]
+public class VirCaptureLevel_SavePos : ICallGSHandler
+{
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<VirCaptureSavePosParam>(param);
+        if (req == null || req.LevelId == 0)
+        {
+            await CallGSRouter.SendScript(connection, "VirCaptureLevel_SavePos", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+        VirCaptureStateHelper.SetSignedMapOffset(player, (uint)req.LevelId, VirCaptureStateHelper.OffPosX, req.PosX, sync);
+        VirCaptureStateHelper.SetSignedMapOffset(player, (uint)req.LevelId, VirCaptureStateHelper.OffPosY, req.PosY, sync);
+        VirCaptureStateHelper.SetSignedMapOffset(player, (uint)req.LevelId, VirCaptureStateHelper.OffPosZ, req.PosZ, sync);
+        VirCaptureStateHelper.SetSignedMapOffset(player, (uint)req.LevelId, VirCaptureStateHelper.OffToward, req.Toward, sync);
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+        await CallGSRouter.SendScript(connection, "VirCaptureLevel_SavePos", "{}", sync);
+    }
+}
+
+internal sealed class VirCaptureSavePosParam
+{
+    [JsonPropertyName("nLevelID")]
+    public int LevelId { get; set; }
+
+    [JsonPropertyName("nPosX")]
+    public int PosX { get; set; }
+
+    [JsonPropertyName("nPosY")]
+    public int PosY { get; set; }
+
+    [JsonPropertyName("nPosZ")]
+    public int PosZ { get; set; }
+
+    [JsonPropertyName("nToward")]
+    public int Toward { get; set; }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCaptureStateHelper.cs

@@ -0,0 +1,157 @@
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+internal static class VirCaptureStateHelper
+{
+    public const uint GroupId = 128;
+    public const uint MapDataStart = 10000;
+    public const uint MapDataEnd = 19000;
+    public const uint MaxMapCount = 3;
+    public const uint MaxMapDataLen = 3000;
+    public const uint MaxPatrolPoint = 500;
+    public const uint MaxOtherPoint = 2500;
+    public const uint MinMaterialId = 50000;
+    public const uint MaxMaterialId = 51500;
+
+    public const uint OffMapId = 1;
+    public const uint OffTurnNum = 2;
+    public const uint OffPosX = 3;
+    public const uint OffPosY = 4;
+    public const uint OffPosZ = 5;
+    public const uint OffToward = 6;
+    public const uint OffDayNight = 7;
+    public const uint OffMapLevel = 8;
+    public const uint OffPatrolStart = 51;
+    public const uint OffPatrolEnd = 1000;
+    public const uint OffOtherStart = 1001;
+    public const uint OffOtherEnd = 1500;
+    public const uint OffMaterialStart = 1501;
+    public const uint OffMaterialEnd = 3000;
+
+    public static uint FindOrAllocateMapSlot(PlayerInstance player, uint levelId)
+    {
+        uint? emptySlot = null;
+        for (uint i = 0; i < MaxMapCount; i++)
+        {
+            var slotStart = MapDataStart + (i * MaxMapDataLen);
+            var mapIdAttr = player.Data.Attrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == slotStart + OffMapId);
+            if (mapIdAttr?.Val == levelId)
+                return slotStart;
+
+            if (emptySlot == null && (mapIdAttr == null || mapIdAttr.Val == 0))
+                emptySlot = slotStart;
+        }
+
+        return emptySlot ?? 0;
+    }
+
+    public static void EnsureBaseMapState(PlayerInstance player, uint levelId, NtfSyncPlayer sync)
+    {
+        var slotStart = FindOrAllocateMapSlot(player, levelId);
+        if (slotStart == 0)
+            return;
+
+        EnsureUnsignedAttr(player, slotStart + OffMapId, levelId, sync);
+        EnsureUnsignedAttr(player, slotStart + OffDayNight, 1, sync);
+        EnsureUnsignedAttr(player, slotStart + OffMapLevel, 1, sync);
+    }
+
+    public static void SetSignedMapOffset(PlayerInstance player, uint levelId, uint offset, int value, NtfSyncPlayer sync)
+    {
+        var slotStart = FindOrAllocateMapSlot(player, levelId);
+        if (slotStart == 0)
+            return;
+
+        EnsureBaseMapState(player, levelId, sync);
+        SetUnsignedAttr(player, slotStart + offset, unchecked((uint)value), sync);
+    }
+
+    public static void SetPointState(PlayerInstance player, uint levelId, uint pointId, uint value, NtfSyncPlayer sync)
+    {
+        var slotStart = FindOrAllocateMapSlot(player, levelId);
+        if (slotStart == 0 || pointId == 0)
+            return;
+
+        EnsureBaseMapState(player, levelId, sync);
+
+        if (pointId <= MaxPatrolPoint)
+        {
+            var sid = slotStart + (OffPatrolStart - 1) + pointId;
+            SetUnsignedAttr(player, sid, value, sync);
+            return;
+        }
+
+        if (pointId <= MaxOtherPoint)
+        {
+            var relative = pointId - MaxPatrolPoint;
+            var sid = slotStart + (uint)Math.Floor(relative / 30d) + OffOtherStart;
+            if (sid > slotStart + OffOtherEnd)
+                return;
+
+            var bit = (int)(relative % 30);
+            var attr = GetOrCreateAttr(player, sid);
+            var next = value > 0
+                ? attr.Val | (1u << bit)
+                : attr.Val & ~(1u << bit);
+            if (next != attr.Val)
+            {
+                attr.Val = next;
+                SyncAttr(player, sync, sid, next);
+            }
+            return;
+        }
+
+        if (pointId > MinMaterialId && pointId <= MaxMaterialId)
+        {
+            var sid = slotStart + (OffMaterialStart - 1) + (pointId - MinMaterialId);
+            if (sid >= slotStart + OffMaterialEnd)
+                return;
+
+            SetUnsignedAttr(player, sid, value, sync);
+        }
+    }
+
+    public static void EnsureUnsignedAttr(PlayerInstance player, uint sid, uint minValue, NtfSyncPlayer sync)
+    {
+        var attr = GetOrCreateAttr(player, sid);
+        if (attr.Val < minValue)
+        {
+            attr.Val = minValue;
+            SyncAttr(player, sync, sid, attr.Val);
+        }
+    }
+
+    public static void SetUnsignedAttr(PlayerInstance player, uint sid, uint value, NtfSyncPlayer sync)
+    {
+        var attr = GetOrCreateAttr(player, sid);
+        if (attr.Val != value)
+        {
+            attr.Val = value;
+            SyncAttr(player, sync, sid, value);
+        }
+    }
+
+    private static PlayerAttr GetOrCreateAttr(PlayerInstance player, uint sid)
+    {
+        var attr = player.Data.Attrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == sid);
+        if (attr != null)
+            return attr;
+
+        attr = new PlayerAttr
+        {
+            Gid = GroupId,
+            Sid = sid
+        };
+        player.Data.Attrs.Add(attr);
+        return attr;
+    }
+
+    private static void SyncAttr(PlayerInstance player, NtfSyncPlayer sync, uint sid, uint value)
+    {
+        sync.Custom[player.ToPackedAttrKey(GroupId, sid)] = value;
+        sync.Custom[player.ToShiftedAttrKey(GroupId, sid)] = value;
+    }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCapture_ChangeFormation.cs

@@ -0,0 +1,140 @@
+using MikuSB.Data;
+using MikuSB.Database;
+using MikuSB.Enums.Item;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+[CallGSApi("VirCapture_ChangeFormation")]
+public class VirCapture_ChangeFormation : ICallGSHandler
+{
+    private const uint StrGroupId = 57;
+    private const uint FormationSid = 1;
+    private const uint VirCaptureGroupId = 128;
+    private const uint CurLevelSid = 3;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<VirCaptureChangeFormationParam>(param);
+        if (req == null)
+        {
+            await CallGSRouter.SendScript(connection, "VirCapture_ChangeFormation", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var formation = ReadFormation(player);
+        var addId = (uint)Math.Max(0, req.Id);
+        var unloadId = (uint)Math.Max(0, req.UnloadId);
+
+        var unloadIndex = unloadId == 0 ? -1 : formation.FindIndex(x => x == unloadId);
+        if (unloadId > 0 && unloadIndex < 0)
+        {
+            await CallGSRouter.SendScript(connection, "VirCapture_ChangeFormation", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        if (addId > 0)
+        {
+            if (formation.Contains(addId))
+            {
+                await CallGSRouter.SendScript(connection, "VirCapture_ChangeFormation", "{\"sErr\":\"error.BadParam\"}");
+                return;
+            }
+
+            var addItem = player.InventoryManager.GetNormalItem(addId);
+            if (addItem == null || addItem.ItemType != ItemTypeEnum.TYPE_MONSTER_CARD)
+            {
+                await CallGSRouter.SendScript(connection, "VirCapture_ChangeFormation", "{\"sErr\":\"error.BadParam\"}");
+                return;
+            }
+        }
+
+        if (unloadIndex >= 0)
+            formation.RemoveAt(unloadIndex);
+
+        if (addId > 0)
+        {
+            if (unloadIndex >= 0 && unloadIndex <= formation.Count)
+                formation.Insert(unloadIndex, addId);
+            else
+                formation.Add(addId);
+        }
+
+        if (!ValidateFormation(player, formation))
+        {
+            await CallGSRouter.SendScript(connection, "VirCapture_ChangeFormation", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var json = JsonSerializer.Serialize(formation);
+        player.SetStrAttr(StrGroupId, FormationSid, json);
+
+        DatabaseHelper.SaveDatabaseType(player.Data);
+
+        var sync = new NtfSyncPlayer();
+        sync.CustomStr[player.ToShiftedAttrKey(StrGroupId, FormationSid)] = json;
+
+        var response = new JsonObject
+        {
+            ["nId"] = req.Id,
+            ["nUnloadId"] = req.UnloadId,
+            ["bAdd"] = addId > 0
+        };
+
+        await CallGSRouter.SendScript(connection, "VirCapture_ChangeFormation", response.ToJsonString(), sync);
+    }
+
+    private static List<uint> ReadFormation(MikuSB.GameServer.Game.Player.PlayerInstance player)
+    {
+        var raw = player.Data.StrAttrs.FirstOrDefault(x => x.Gid == StrGroupId && x.Sid == FormationSid)?.Val;
+        if (string.IsNullOrWhiteSpace(raw))
+            return [];
+
+        try
+        {
+            return JsonSerializer.Deserialize<List<uint>>(raw) ?? [];
+        }
+        catch
+        {
+            return [];
+        }
+    }
+
+    private static bool ValidateFormation(MikuSB.GameServer.Game.Player.PlayerInstance player, List<uint> formation)
+    {
+        var curLevel = player.Data.Attrs.FirstOrDefault(x => x.Gid == VirCaptureGroupId && x.Sid == CurLevelSid)?.Val ?? 1;
+        if (!GameData.VirCaptureLevelListData.TryGetValue(curLevel, out var levelCfg))
+            return formation.Count == 0;
+
+        if (formation.Count > levelCfg.Num)
+            return false;
+
+        uint totalCost = 0;
+        foreach (var itemId in formation)
+        {
+            var item = player.InventoryManager.GetNormalItem(itemId);
+            if (item == null || item.ItemType != ItemTypeEnum.TYPE_MONSTER_CARD)
+                return false;
+
+            if (!GameData.MonsterCardData.TryGetValue(item.TemplateId, out var monsterCfg))
+                return false;
+
+            totalCost += monsterCfg.CostValue;
+        }
+
+        return totalCost <= levelCfg.MaxCost;
+    }
+}
+
+internal sealed class VirCaptureChangeFormationParam
+{
+    [JsonPropertyName("nId")]
+    public int Id { get; set; }
+
+    [JsonPropertyName("nUnloadId")]
+    public int UnloadId { get; set; }
+}

GameServer/Server/CallGS/Handlers/VirCapture/VirCapture_CheckOpenAct.cs

@@ -0,0 +1,164 @@
+using MikuSB.Data;
+using MikuSB.Data.Excel;
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+using System.Globalization;
+using System.Text.Json.Nodes;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.VirCapture;
+
+[CallGSApi("VirCapture_CheckOpenAct")]
+public class VirCapture_CheckOpenAct : ICallGSHandler
+{
+    private const uint GroupId = 128;
+    private const uint ActIdSid = 1;
+    private const uint CurLevelSid = 3;
+    private const uint TrialActIdSid = 6;
+    private const uint SeasonActIdSid = 9;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var now = DateTime.Now;
+        var act = ResolveCurrent(GameData.VirCaptureTimeData.Values, now);
+        if (act == null)
+        {
+            await CallGSRouter.SendScript(connection, "VirCapture_CheckOpenAct", "{\"bOpen\":false}");
+            return;
+        }
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+
+        SetAttr(player, ActIdSid, act.Id, sync);
+        EnsureMinAttr(player, CurLevelSid, 1, sync);
+
+        var response = new JsonObject
+        {
+            ["bOpen"] = true,
+            ["nId"] = act.Id,
+            ["nStartTime"] = ToUnixSeconds(ParseConfigTime(act.StartTime)),
+            ["nEndTime"] = ToUnixSeconds(ParseConfigTime(act.EndTime))
+        };
+
+        var season = ResolveCurrent(GameData.VirCaptureSeasonData.Values, now);
+        if (season != null)
+        {
+            SetAttr(player, SeasonActIdSid, season.Id, sync);
+            response["tbSeason"] = new JsonObject
+            {
+                ["nId"] = season.Id,
+                ["nStartTime"] = ToUnixSeconds(ParseConfigTime(season.StartTime)),
+                ["nEndTime"] = ToUnixSeconds(ParseConfigTime(season.EndTime))
+            };
+        }
+        else
+        {
+            SetAttr(player, SeasonActIdSid, 0, sync);
+        }
+
+        var trial = ResolveCurrent(GameData.VirCaptureTrialTimeData.Values, now);
+        SetAttr(player, TrialActIdSid, trial?.Id ?? 0, sync);
+
+        await CallGSRouter.SendScript(connection, "VirCapture_CheckOpenAct", response.ToJsonString(), sync);
+    }
+
+    private static T? ResolveCurrent<T>(IEnumerable<T> configs, DateTime now) where T : class
+    {
+        var parsed = configs
+            .Select(x => new
+            {
+                Config = x,
+                Start = ParseConfigTime(GetTimeValue(x, true)),
+                End = ParseConfigTime(GetTimeValue(x, false))
+            })
+            .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 && latestStarted.End > latestStarted.Start)
+            return latestStarted.Config;
+
+        return null;
+    }
+
+    private static string? GetTimeValue<T>(T value, bool start) where T : class
+    {
+        return value switch
+        {
+            VirCaptureTimeExcel time => start ? time.StartTime : time.EndTime,
+            VirCaptureSeasonExcel season => start ? season.StartTime : season.EndTime,
+            _ => null
+        };
+    }
+
+    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 long ToUnixSeconds(DateTime? value)
+    {
+        return value.HasValue ? new DateTimeOffset(value.Value).ToUnixTimeSeconds() : 0L;
+    }
+
+    private static void EnsureMinAttr(PlayerInstance player, uint sid, uint minValue, NtfSyncPlayer sync)
+    {
+        var attr = GetOrCreateAttr(player, sid);
+        if (attr.Val < minValue)
+        {
+            attr.Val = minValue;
+            SyncAttr(player, sync, sid, attr.Val);
+        }
+    }
+
+    private static void SetAttr(PlayerInstance player, uint sid, uint value, NtfSyncPlayer sync)
+    {
+        var attr = GetOrCreateAttr(player, sid);
+        if (attr.Val != value)
+        {
+            attr.Val = value;
+            SyncAttr(player, sync, sid, value);
+        }
+    }
+
+    private static PlayerAttr GetOrCreateAttr(PlayerInstance player, uint sid)
+    {
+        var attr = player.Data.Attrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == sid);
+        if (attr != null)
+            return attr;
+
+        attr = new PlayerAttr
+        {
+            Gid = GroupId,
+            Sid = sid
+        };
+        player.Data.Attrs.Add(attr);
+        return attr;
+    }
+
+    private static void SyncAttr(PlayerInstance player, NtfSyncPlayer sync, uint sid, uint value)
+    {
+        sync.Custom[player.ToPackedAttrKey(GroupId, sid)] = value;
+        sync.Custom[player.ToShiftedAttrKey(GroupId, sid)] = value;
+    }
+}

version.txt

@@ -1 +1 @@
-v=4.0
+v=4.2