Update version.txt

Common/Data/Excel/Rogue3DDailyBuffExcel.cs

@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("dailybuff.json")]
+public class Rogue3DDailyBuffExcel : ExcelResource
+{
+    [JsonProperty("ID")] public uint Id { get; set; }
+    [JsonProperty("GroupID")] public uint GroupId { get; set; }
+    [JsonProperty("ScoreBuffID")] public uint ScoreBuffId { get; set; }
+
+    public override uint GetId() => Id;
+
+    public override void Loaded()
+    {
+        GameData.Rogue3DDailyBuffData[Id] = this;
+    }
+}

Common/Data/Excel/Rogue3DSeasonExcel.cs

@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("server_10_season.json")]
+public class Rogue3DSeasonExcel : ExcelResource
+{
+    [JsonProperty("SeasonID")] public uint SeasonId { get; set; }
+    [JsonProperty("Type")] public int Type { get; set; }
+    [JsonProperty("OpenTime")] public string OpenTime { get; set; } = "";
+    [JsonProperty("CloseTime")] public string CloseTime { get; set; } = "";
+
+    public override uint GetId() => SeasonId;
+
+    public override void Loaded()
+    {
+        GameData.Rogue3DSeasonData[SeasonId] = this;
+    }
+}

Common/Data/Excel/Rogue3DTalentExcel.cs

@@ -0,0 +1,31 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("server_03_talent.json")]
+public class Rogue3DTalentExcel : ExcelResource
+{
+    [JsonProperty("TalentID")] public uint TalentId { get; set; }
+    [JsonProperty("UnlockCondition")] private object? UnlockConditionRaw { get; set; }
+    [JsonIgnore] public uint UnlockCondition { get; private set; }
+
+    public override uint GetId() => TalentId;
+
+    public override void Loaded()
+    {
+        UnlockCondition = ParseUnlockCondition(UnlockConditionRaw);
+        GameData.Rogue3DTalentData[TalentId] = this;
+    }
+
+    private static uint ParseUnlockCondition(object? raw)
+    {
+        return raw switch
+        {
+            null => 0,
+            long value when value > 0 => (uint)value,
+            int value when value > 0 => (uint)value,
+            string text when uint.TryParse(text, out var value) => value,
+            _ => 0
+        };
+    }
+}

Common/Data/GameData.cs

@@ -16,6 +16,9 @@ public static class GameData
     public static Dictionary<uint, ArItemExcel> ArItemData { get; private set; } = [];
     public static Dictionary<uint, ManifestationExcel> ManifestationData { get; private set; } = [];
     public static Dictionary<uint, Rogue3DDifficultExcel> Rogue3DDifficultData { get; private set; } = [];
+    public static Dictionary<uint, Rogue3DSeasonExcel> Rogue3DSeasonData { get; private set; } = [];
+    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<uint, SpineExcel> SpineData { get; private set; } = [];
     public static Dictionary<uint, NodeConditionExcel> NodeConditionData { get; private set; } = [];

GameServer/Server/CallGS/Handlers/House/House_Func/HouseArcade.cs

@@ -0,0 +1,97 @@
+using MikuSB.Proto;
+using System.Text.Json.Nodes;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.House;
+
+// ArcadeGameEnterMainUI
+// Returns all girl IDs (1-25) as unlocked, and syncs TeachMode + EndlessMode attrs.
+[HouseFunc("ArcadeGameEnterMainUI")]
+public class ArcadeGameEnterMainUI : IHouseFuncHandler
+{
+    private const uint ArcadeGid = 101;
+    private const uint EndlessModeStateSid = 18000 + 5;
+    private const uint TeachModeConditionSid = 18000 + 36 + 8;
+
+    public async Task Handle(Connection connection, string param)
+    {
+        var girlList = new JsonArray();
+        for (int i = 1; i <= 25; i++) girlList.Add(i);
+
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "ArcadeGameEnterMainUI",
+            ["tbUnlockGirlList"] = girlList
+        };
+
+        var player = connection.Player!;
+        var sync = new NtfSyncPlayer();
+        sync.Custom[player.ToPackedAttrKey(ArcadeGid, TeachModeConditionSid)] = 1;
+        sync.Custom[player.ToShiftedAttrKey(ArcadeGid, TeachModeConditionSid)] = 1;
+        const uint endlessAllUnlocked = 0x3FFFFFE;
+        sync.Custom[player.ToPackedAttrKey(ArcadeGid, EndlessModeStateSid)] = endlessAllUnlocked;
+        sync.Custom[player.ToShiftedAttrKey(ArcadeGid, EndlessModeStateSid)] = endlessAllUnlocked;
+
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString(), sync);
+    }
+}
+
+// ArcadeGameEnter — returns a random seed for level generation.
+[HouseFunc("ArcadeGameEnter")]
+public class ArcadeGameEnter : IHouseFuncHandler
+{
+    private static readonly Random Random = new();
+
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "ArcadeGameEnter",
+            ["nSeed"] = Random.Next(1, 1_000_000_000)
+        };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+// ArcadeGameSettlement — acknowledges round end; nAddExp=0 on private server.
+[HouseFunc("ArcadeGameSettlement")]
+public class ArcadeGameSettlement : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ArcadeGameSettlement", ["nAddExp"] = 0 };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+// ArcadeGameLogSettlement — acknowledges log upload (no client data required).
+[HouseFunc("ArcadeGameLogSettlement")]
+public class ArcadeGameLogSettlement : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ArcadeGameLogSettlement" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+// ArcadeGameGetLevelReward — UI refresh only on client side.
+[HouseFunc("ArcadeGameGetLevelReward")]
+public class ArcadeGameGetLevelReward : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ArcadeGameGetLevelReward" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+// ArcadeGameGetAchReward — UI refresh only on client side.
+[HouseFunc("ArcadeGameGetAchReward")]
+public class ArcadeGameGetAchReward : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ArcadeGameGetAchReward" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}

GameServer/Server/CallGS/Handlers/House/House_Func/HouseNpc.cs

@@ -0,0 +1,59 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.House;
+
+[HouseFunc("ChangeNpcSuit")]
+public class ChangeNpcSuit : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var req = JsonSerializer.Deserialize<NpcSuitParam>(param);
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "ChangeNpcSuitSuccess",
+            ["NpcId"] = req?.NpcId ?? 0,
+            ["SuitId"] = req?.SuitId ?? 0
+        };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("ChangeNpcSuitByAreaId")]
+public class ChangeNpcSuitByAreaId : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var req = JsonSerializer.Deserialize<NpcSuitParam>(param);
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "ChangeNpcSuitByAreaIdRsp",
+            ["NpcId"] = req?.NpcId ?? 0,
+            ["SuitId"] = req?.SuitId ?? 0
+        };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("ChangeGirlBeachSuitId")]
+public class ChangeGirlBeachSuitId : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var req = JsonSerializer.Deserialize<NpcSuitParam>(param);
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "ChangeGirlBeachSuitIdSuccess",
+            ["NpcId"] = req?.NpcId ?? 0,
+            ["SuitId"] = req?.SuitId ?? 0
+        };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+internal sealed class NpcSuitParam
+{
+    [JsonPropertyName("NpcId")] public int NpcId { get; set; }
+    [JsonPropertyName("SuitId")] public int SuitId { get; set; }
+}

GameServer/Server/CallGS/Handlers/House/House_Func/HousePub.cs

@@ -0,0 +1,74 @@
+using System.Text.Json.Nodes;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.House;
+
+// PubGameEnter — returns nSeed for client-side game initialization.
+[HouseFunc("PubGameEnter")]
+public class PubGameEnter : IHouseFuncHandler
+{
+    private static readonly Random Random = new();
+
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "PubGameEnter",
+            ["nSeed"] = Random.Next(1, 1_000_000_000),
+            ["nModeType"] = 1,
+            ["bIsGuide"] = false,
+            ["bHasTry"] = false
+        };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("PubGameMulExit")]
+public class PubGameMulExit : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "PubGameMulExit" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+// PubGameSettlement — nAddExp=0 on private server.
+[HouseFunc("PubGameSettlement")]
+public class PubGameSettlement : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "PubGameSettlement", ["nAddExp"] = 0 };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("PubGameGetReward")]
+public class PubGameGetReward : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "PubGameGetReward" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("PubGameGetAchReward")]
+public class PubGameGetAchReward : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "PubGameGetAchReward" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("PubGameAchievementFinish")]
+public class PubGameAchievementFinish : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "PubGameAchievementFinish" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}

GameServer/Server/CallGS/Handlers/House/House_Func/HouseThrow.cs

@@ -0,0 +1,76 @@
+using System.Text.Json.Nodes;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.House;
+
+// GameEnterMainUI (Throw) — tblockGirlList empty = no blocked girls.
+[HouseFunc("GameEnterMainUI")]
+public class ThrowGameEnterMainUI : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "GameEnterMainUI",
+            ["tblockGirlList"] = new JsonArray()
+        };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("ThrowGameTutorialFinish")]
+public class ThrowGameTutorialFinish : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ThrowGameTutorialFinish" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+// ThrowGameEnter — returns nSeed for level generation.
+[HouseFunc("ThrowGameEnter")]
+public class ThrowGameEnter : IHouseFuncHandler
+{
+    private static readonly Random Random = new();
+
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject
+        {
+            ["FuncName"] = "ThrowGameEnter",
+            ["nSeed"] = Random.Next(1, 1_000_000_000)
+        };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+// ThrowGameSettlement — nAddExp=0 on private server.
+[HouseFunc("ThrowGameSettlement")]
+public class ThrowGameSettlement : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ThrowGameSettlement", ["nAddExp"] = 0 };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("ThrowGameGetLevelReward")]
+public class ThrowGameGetLevelReward : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ThrowGameGetLevelReward" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}
+
+[HouseFunc("ThrowGameGetAchReward")]
+public class ThrowGameGetAchReward : IHouseFuncHandler
+{
+    public async Task Handle(Connection connection, string param)
+    {
+        var rsp = new JsonObject { ["FuncName"] = "ThrowGameGetAchReward" };
+        await CallGSRouter.SendScript(connection, "House_Request", rsp.ToJsonString());
+    }
+}

GameServer/Server/CallGS/Handlers/House/House_Func/IHouseFuncHandler.cs

@@ -0,0 +1,12 @@
+namespace MikuSB.GameServer.Server.CallGS.Handlers.House;
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+public class HouseFuncAttribute(string funcName) : Attribute
+{
+    public string FuncName { get; } = funcName;
+}
+
+public interface IHouseFuncHandler
+{
+    Task Handle(Connection connection, string param);
+}

GameServer/Server/CallGS/Handlers/House/House_Request.cs

@@ -0,0 +1,42 @@
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.House;
+
+[CallGSApi("House_Request")]
+public class House_Request : ICallGSHandler
+{
+    private static readonly Dictionary<string, IHouseFuncHandler> Handlers = [];
+
+    static House_Request()
+    {
+        foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
+        {
+            foreach (var attr in type.GetCustomAttributes<HouseFuncAttribute>())
+                Handlers[attr.FuncName] = (IHouseFuncHandler)Activator.CreateInstance(type)!;
+        }
+    }
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var req = JsonSerializer.Deserialize<HouseRequestParam>(param);
+        if (req?.FuncName == null) return;
+
+        if (Handlers.TryGetValue(req.FuncName, out var handler))
+        {
+            await handler.Handle(connection, param);
+            return;
+        }
+
+        var err = new JsonObject { ["FuncName"] = req.FuncName, ["sErr"] = "error.NotImplemented" };
+        await CallGSRouter.SendScript(connection, "House_Request", err.ToJsonString());
+    }
+}
+
+internal sealed class HouseRequestParam
+{
+    [JsonPropertyName("FuncName")]
+    public string? FuncName { get; set; }
+}

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

@@ -0,0 +1,178 @@
+using MikuSB.Data;
+using MikuSB.Database.Player;
+using MikuSB.GameServer.Game.Player;
+using MikuSB.Proto;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Rogue3D;
+
+internal static class Rogue3DStateHelper
+{
+    private const uint GroupId = 124;
+    private const uint LevelPassStart = 20;
+    private const uint DailyBuffStart = 51;
+    private const uint DailyBuffEnd = 65;
+    private const int DailyBuffBitCount = 10;
+    private const int DailyBuffBitsPerValue = DailyBuffBitCount + 1;
+    private const uint DailyBuffMask = (1u << DailyBuffBitCount) - 1;
+    private const uint UnlockDiff1Sid = LevelPassStart + 1;
+    private const uint UnlockDiff2Sid = LevelPassStart + 2;
+    private const uint UnlockDiff3Sid = LevelPassStart + 3;
+    private const uint UnlockDiff4Sid = LevelPassStart + 4;
+    private static uint[]? ShuffledDailyBuffIds;
+
+    public static NtfSyncPlayer EnsureUnlockState(PlayerInstance player)
+    {
+        var sync = new NtfSyncPlayer();
+
+        EnsureMinAttr(player, UnlockDiff1Sid, 1, sync);
+        EnsureMinAttr(player, UnlockDiff2Sid, 1, sync);
+        EnsureMinAttr(player, UnlockDiff3Sid, 1, sync);
+        EnsureMinAttr(player, UnlockDiff4Sid, 1, sync);
+
+        foreach (var scienceSid in GetUnlockTalentScienceSids())
+        {
+            EnsureMinAttr(player, scienceSid, 1, sync);
+        }
+
+        EnsureDailyBuffAttrs(player, sync);
+
+        return sync;
+    }
+
+    private static IEnumerable<uint> GetUnlockTalentScienceSids()
+    {
+        return GameData.Rogue3DTalentData.Values
+            .Select(x => x.UnlockCondition)
+            .Where(x => x > 0)
+            .Distinct()
+            .OrderBy(x => x);
+    }
+
+    private static void EnsureDailyBuffAttrs(PlayerInstance player, NtfSyncPlayer sync)
+    {
+        var buffIds = GetOrCreateDailyBuffIds()
+            .Take((int)(DailyBuffEnd - DailyBuffStart + 1) * 3)
+            .ToArray();
+
+        var index = 0;
+        for (var sid = DailyBuffStart; sid <= DailyBuffEnd; sid++)
+        {
+            uint packed = 0;
+            for (var slot = 0; slot < 3 && index < buffIds.Length; slot++, index++)
+            {
+                packed |= (buffIds[index] & DailyBuffMask) << (slot * DailyBuffBitsPerValue);
+            }
+
+            SetAttr(player, sid, packed, sync);
+        }
+    }
+
+    private static uint[] GetOrCreateDailyBuffIds()
+    {
+        if (ShuffledDailyBuffIds != null)
+        {
+            return ShuffledDailyBuffIds;
+        }
+
+        var groupedBuffIds = GameData.Rogue3DDailyBuffData.Values
+            .Where(x => x.ScoreBuffId > 0 && x.ScoreBuffId <= DailyBuffMask)
+            .GroupBy(x => x.GroupId)
+            .OrderBy(x => x.Key)
+            .Select(x => x
+                .OrderBy(y => y.Id)
+                .Select(y => y.ScoreBuffId)
+                .Distinct()
+                .ToList())
+            .ToList();
+
+        var random = new Random();
+        foreach (var group in groupedBuffIds)
+        {
+            Shuffle(group, random);
+        }
+        Shuffle(groupedBuffIds, random);
+
+        var buffIds = new List<uint>();
+        var indexByGroup = new int[groupedBuffIds.Count];
+        var hasRemaining = true;
+
+        while (hasRemaining)
+        {
+            hasRemaining = false;
+            for (var i = 0; i < groupedBuffIds.Count; i++)
+            {
+                var group = groupedBuffIds[i];
+                var index = indexByGroup[i];
+                if (index >= group.Count)
+                {
+                    continue;
+                }
+
+                buffIds.Add(group[index]);
+                indexByGroup[i] = index + 1;
+                hasRemaining = true;
+            }
+        }
+
+        ShuffledDailyBuffIds = buffIds.ToArray();
+        return ShuffledDailyBuffIds;
+    }
+
+    private static IEnumerable<uint> GetDailyBuffIds()
+    {
+        return GetOrCreateDailyBuffIds();
+    }
+
+    private static void Shuffle<T>(IList<T> list, Random random)
+    {
+        for (var i = list.Count - 1; i > 0; i--)
+        {
+            var swapIndex = random.Next(i + 1);
+            (list[i], list[swapIndex]) = (list[swapIndex], list[i]);
+        }
+    }
+
+    private static void EnsureMinAttr(PlayerInstance player, uint sid, uint value, NtfSyncPlayer sync, bool overwrite = false)
+    {
+        var attr = player.Data.Attrs.FirstOrDefault(x => x.Gid == GroupId && x.Sid == sid);
+        if (attr == null)
+        {
+            attr = new PlayerAttr { Gid = GroupId, Sid = sid, Val = value };
+            player.Data.Attrs.Add(attr);
+            AddSync(player, sync, sid, value);
+            return;
+        }
+
+        if ((!overwrite && attr.Val >= value) || (overwrite && attr.Val == value))
+        {
+            return;
+        }
+
+        attr.Val = value;
+        AddSync(player, sync, sid, value);
+    }
+
+    private static void SetAttr(PlayerInstance player, uint sid, uint value, 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 == value)
+        {
+            return;
+        }
+
+        attr.Val = value;
+        AddSync(player, sync, sid, value);
+    }
+
+    private static void AddSync(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/Rogue3D/Rogue3D_CheckOpenAct.cs

@@ -8,6 +8,7 @@ public class Rogue3D_CheckOpenAct : ICallGSHandler
 {
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
-        await CallGSRouter.SendScript(connection, "Rogue3D_CheckOpenAct", "{\"bOpen\":true}");
+        var sync = Rogue3DStateHelper.EnsureUnlockState(connection.Player!);
+        await CallGSRouter.SendScript(connection, "Rogue3D_CheckOpenAct", "{\"bOpen\":true}", sync);
     }
 }

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

@@ -8,6 +8,7 @@ public class Rogue3D_SelectMode : ICallGSHandler
 {
     public async Task Handle(Connection connection, string param, ushort seqNo)
     {
-        await CallGSRouter.SendScript(connection, "Rogue3D_SelectMode", "{}");
+        var sync = Rogue3DStateHelper.EnsureUnlockState(connection.Player!);
+        await CallGSRouter.SendScript(connection, "Rogue3D_SelectMode", "{}", sync);
     }
 }

version.txt

@@ -1 +1 @@
-v=1.6
+v=1.9