Update version.txt

Common/Data/Excel/HouseFurniturePosData.cs

@@ -0,0 +1,18 @@
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("house/FurniturePos.json")]
+public class HouseFurniturePosExcel : ExcelResource
+{
+    public uint AreaId { get; set; }
+    public uint GroupId { get; set; }
+
+    public override uint GetId()
+    {
+        return (AreaId << 48) | (GroupId << 32);
+    }
+
+    public override void Loaded()
+    {
+        GameData.HouseFurniturePosData.TryAdd(GetId(), this);
+    }
+}

Common/Data/Excel/SupportAffixExcel.cs

@@ -0,0 +1,27 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("item/support/affix.json")]
+public class SupportAffixExcel : ExcelResource
+{
+    [JsonProperty("ID")] public int Id { get; set; }
+    [JsonExtensionData] public IDictionary<string, JToken> ExtraData { get; set; } = new Dictionary<string, JToken>();
+
+    public int TierCount =>
+        ExtraData
+            .Where(x => x.Key != "ID" && x.Key != "Sift" && x.Key != "Comment")
+            .Select(x => x.Value)
+            .OfType<JObject>()
+            .Select(x => x.Count)
+            .DefaultIfEmpty(0)
+            .Max();
+
+    public override uint GetId() => (uint)Id;
+
+    public override void Loaded()
+    {
+        GameData.SupportAffixData[Id] = this;
+    }
+}

Common/Data/Excel/SupportAffixPoolExcel.cs

@@ -0,0 +1,35 @@
+using Newtonsoft.Json;
+
+namespace MikuSB.Data.Excel;
+
+[ResourceEntity("item/support/affix_pool.json")]
+public class SupportAffixPoolExcel : ExcelResource
+{
+    [JsonProperty("ID")] public int Id { get; set; }
+    public List<int> AffixGroup1 { get; set; } = [];
+    public int Weight1 { get; set; }
+    public List<int> AffixGroup2 { get; set; } = [];
+    public int Weight2 { get; set; }
+    public List<int> AffixGroup3 { get; set; } = [];
+    public int Weight3 { get; set; }
+    public List<int> AffixGroup4 { get; set; } = [];
+    public int Weight4 { get; set; }
+
+    public IEnumerable<(IReadOnlyList<int> Affixs, int Weight)> Groups
+    {
+        get
+        {
+            if (AffixGroup1.Count > 0 && Weight1 > 0) yield return (AffixGroup1, Weight1);
+            if (AffixGroup2.Count > 0 && Weight2 > 0) yield return (AffixGroup2, Weight2);
+            if (AffixGroup3.Count > 0 && Weight3 > 0) yield return (AffixGroup3, Weight3);
+            if (AffixGroup4.Count > 0 && Weight4 > 0) yield return (AffixGroup4, Weight4);
+        }
+    }
+
+    public override uint GetId() => (uint)Id;
+
+    public override void Loaded()
+    {
+        GameData.SupportAffixPoolData[Id] = this;
+    }
+}

Common/Data/Excel/SupportCardExcel.cs

@@ -11,7 +11,9 @@ public class SupportCardExcel : ExcelResource
     public uint Level { get; set; }
     public uint Icon { get; set; }
     public uint ProvideExp { get; set; }
+    public uint Color { get; set; }
     [JsonProperty("LevelLimitID")] public int LevelLimitId { get; set; }
+    [JsonProperty("AffixPool")] public List<int> AffixPool { get; set; } = [];
 
     public uint MaxLevel => LevelLimitId switch
     {
@@ -21,6 +23,12 @@ public class SupportCardExcel : ExcelResource
         _ => 10
     };
 
+    // Number of affixes granted initially
+    public int InitialAffixCount => Color >= 5 ? 2 : 1;
+
+    // Total maximum affixes (including ones unlocked at max level)
+    public int TotalAffixCount => Color >= 5 ? 3 : 2;
+
     public ulong TemplateId => GameResourceTemplateId.FromGdpl(Genre, Detail, Particular, Level);
 
     public override uint GetId() => Icon;

Common/Data/GameData.cs

@@ -23,6 +23,8 @@ public static class GameData
     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; } = [];
+    public static Dictionary<int, SupportAffixExcel> SupportAffixData { get; private set; } = [];
+    public static Dictionary<int, SupportAffixPoolExcel> SupportAffixPoolData { get; private set; } = [];
     public static Dictionary<uint, WeaponSkinExcel> WeaponSkinData { get; private set; } = [];
     public static Dictionary<uint, DailyLevelExcel> DailyLevelData { get; private set; } = [];
     public static Dictionary<uint, ProfileExcel> ProfileData { get; private set; } = [];
@@ -31,6 +33,7 @@ public static class GameData
     public static Dictionary<uint, WeaponPartsExcel> WeaponPartsData { get; private set; } = [];
     public static Dictionary<uint, GuideExcel> GuideData { get; private set; } = [];
     public static Dictionary<uint, DormGiftExcel> DormGiftData { get; private set; } = [];
+    public static Dictionary<uint, HouseFurniturePosExcel> HouseFurniturePosData { get; private set; } = [];
 }
 
 public static class GameResourceTemplateId

Common/Database/Inventory/InventoryData.cs

@@ -106,6 +106,8 @@ public class GameSkinInfo : BaseGameItemInfo
 public class GameSupportCardInfo : BaseGameItemInfo
 {
     public uint AffixId { get; set; }
+    [SugarColumn(IsJson = true)] public List<uint> Affixs { get; set; } = [];
+
     public override Item ToProto()
     {
         var proto = new Item
@@ -120,6 +122,7 @@ public class GameSupportCardInfo : BaseGameItemInfo
                 Exp = Exp
             }
         };
+        proto.Enhance.Affixs.AddRange(Affixs);
         proto.Slots[(uint)ItemSupportCardSlotTypeEnum.SLOT_AFFIXINDEX] = AffixId;
         return proto;
     }

Common/Internationalization/Message/LanguageCHS.cs

@@ -222,9 +222,16 @@ public class HelpTextCHS
 public class AccountTextCHS
 {
     public string Desc => "管理 SDK 登录使用的账号映射";
-    public string Usage => "用法: /account create <邮箱> <UID>";
+    public string Usage =>
+        "用法: /account create <邮箱> <UID>\n" +
+        "用法: /account delete <邮箱|UID>\n" +
+        "用法: /account list";
     public string Created => "已创建账号映射: {0} -> UID {1}";
     public string CreateFailed => "创建账号映射失败: {0}";
+    public string Deleted => "已删除账号映射: {0} -> UID {1}";
+    public string DeleteFailed => "删除账号映射失败: {0}";
+    public string DeleteOnline => "账号在线时无法删除: {0} -> UID {1}";
+    public string NotFound => "未找到账号: {0}";
 }
 
 /// <summary>

Common/Internationalization/Message/LanguageCHT.cs

@@ -222,9 +222,16 @@ public class HelpTextCHT
 public class AccountTextCHT
 {
     public string Desc => "管理 SDK 登入使用的帳號映射";
-    public string Usage => "用法: /account create <郵箱> <UID>";
+    public string Usage =>
+        "用法: /account create <郵箱> <UID>\n" +
+        "用法: /account delete <郵箱|UID>\n" +
+        "用法: /account list";
     public string Created => "已建立帳號映射: {0} -> UID {1}";
     public string CreateFailed => "建立帳號映射失敗: {0}";
+    public string Deleted => "已刪除帳號映射: {0} -> UID {1}";
+    public string DeleteFailed => "刪除帳號映射失敗: {0}";
+    public string DeleteOnline => "帳號在線時無法刪除: {0} -> UID {1}";
+    public string NotFound => "未找到帳號: {0}";
 }
 
 /// <summary>

Common/Internationalization/Message/LanguageEN.cs

@@ -188,9 +188,16 @@ public class HelpTextEN
 public class AccountTextEN
 {
     public string Desc => "Manage account mappings for SDK logins";
-    public string Usage => "Usage: /account create <email> <uid>";
+    public string Usage =>
+        "Usage: /account create <email> <uid>\n" +
+        "Usage: /account delete <email|uid>\n" +
+        "Usage: /account list";
     public string Created => "Created account mapping: {0} -> UID {1}";
     public string CreateFailed => "Failed to create account mapping: {0}";
+    public string Deleted => "Deleted account mapping: {0} -> UID {1}";
+    public string DeleteFailed => "Failed to delete account mapping: {0}";
+    public string DeleteOnline => "Cannot delete account while online: {0} -> UID {1}";
+    public string NotFound => "Account not found: {0}";
 }
 
 /// <summary>

Common/Util/ConfigManager.cs

@@ -19,6 +19,11 @@ public static class ConfigManager
         //LoadHotfixData();
     }
 
+    public static void SaveConfig()
+    {
+        SaveData(Config, ConfigFilePath);
+    }
+
     private static void LoadConfigData()
     {
         var file = new FileInfo(ConfigFilePath);
@@ -43,9 +48,26 @@ public static class ConfigManager
             Config = JsonConvert.DeserializeObject<ConfigContainer>(json)!;
         }
 
+        Config.Loader.Arguments = NormalizeLoaderArguments(Config.Loader.Arguments);
         SaveData(Config, ConfigFilePath);
     }
 
+    private static string[] NormalizeLoaderArguments(string[]? arguments)
+    {
+        var result = new List<string>(arguments ?? []);
+        var userDataDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "Client_User_Data"));
+        Directory.CreateDirectory(userDataDirectory);
+
+        var userDirArgument = $"-userdir={userDataDirectory}";
+        var existingIndex = result.FindIndex(x => x.StartsWith("-userdir=", StringComparison.OrdinalIgnoreCase));
+        if (existingIndex >= 0)
+            result[existingIndex] = userDirArgument;
+        else
+            result.Add(userDirArgument);
+
+        return result.ToArray();
+    }
+
     private static void LoadHotfixData()
     {
         var file = new FileInfo(HotfixFilePath);

GameServer/Command/Commands/CommandAccount.cs

@@ -2,6 +2,7 @@ using MikuSB.Database;
 using MikuSB.Database.Account;
 using MikuSB.Enums.Player;
 using MikuSB.Internationalization;
+using MikuSB.GameServer.Server;
 using System.Text;
 
 namespace MikuSB.GameServer.Command.Commands;
@@ -37,6 +38,42 @@ public class CommandAccount : ICommands
         }
     }
 
+    [CommandMethod("delete")]
+    public async ValueTask Delete(CommandArg arg)
+    {
+        if (!await arg.CheckArgCnt(1))
+            return;
+
+        var identifier = arg.Args[0].Trim();
+        var account = int.TryParse(identifier, out var uid) && uid > 0
+            ? AccountData.GetAccountByUid(uid)
+            : AccountData.GetAccountByUserName(identifier);
+
+        if (account == null)
+        {
+            await arg.SendMsg(I18NManager.Translate("Game.Command.Account.NotFound", identifier));
+            return;
+        }
+
+        try
+        {
+            if (Listener.GetActiveConnection(account.Uid) != null)
+            {
+                await arg.SendMsg(I18NManager.Translate("Game.Command.Account.DeleteOnline", account.Username,
+                    account.Uid.ToString()));
+                return;
+            }
+
+            AccountData.DeleteAccount(account.Uid);
+            await arg.SendMsg(I18NManager.Translate("Game.Command.Account.Deleted", account.Username,
+                account.Uid.ToString()));
+        }
+        catch (Exception ex)
+        {
+            await arg.SendMsg(I18NManager.Translate("Game.Command.Account.DeleteFailed", ex.Message));
+        }
+    }
+
     [CommandMethod("list")]
     public async ValueTask List(CommandArg arg)
     {

GameServer/Game/Inventory/InventoryManager.cs

@@ -4,6 +4,7 @@ using MikuSB.Database;
 using MikuSB.Database.Inventory;
 using MikuSB.Enums.Item;
 using MikuSB.GameServer.Game.Player;
+using MikuSB.GameServer.Game.Support;
 using MikuSB.GameServer.Server.Packet.Send.Misc;
 
 namespace MikuSB.GameServer.Game.Inventory;
@@ -135,7 +136,18 @@ public class InventoryManager(PlayerInstance player) : BasePlayerManager(player)
             ItemType = genre,
             ItemCount = 1,
             Level = cardLevel,
+            AffixId = 1,
         };
+
+        var affixCount = cardLevel >= spCard.MaxLevel ? spCard.TotalAffixCount : spCard.InitialAffixCount;
+        for (int i = 0; i < affixCount && i < spCard.AffixPool.Count; i++)
+        {
+            var (affixId, tier) = SupportAffixService.GenerateRandomAffix(spCard.AffixPool[i]);
+            if (affixId == 0) continue;
+            info.Affixs.Add(affixId);
+            info.Affixs.Add(tier);
+        }
+
         InventoryData.SupportCards[info.UniqueId] = info;
 
         if (sendPacket) await Player.SendPacket(new PacketNtfCallScript([info]));

GameServer/Game/Player/PlayerInstance.cs

@@ -327,20 +327,49 @@ public class PlayerInstance(PlayerGameData data)
 
     private static IEnumerable<(uint Gid, uint Sid, uint Value)> BuildGirlFurnitureAttrs()
     {
-        // Unlock some furniture slots for every girl
-        // Each furniture attr int stores 10 slots using 3 bits per slot
-        // Value below means slot 0..9 = 1
         const uint furnitureUnlockedValue = 153391689;
+        var groupFurnitureByArea = new Dictionary<uint, uint>();
+        foreach (var pos in GameData.HouseFurniturePosData.Values)
+        {
+            var areaId = pos.AreaId;
+            var groupId = pos.GroupId;
+            uint selectedIndex = 1;
+            var shift = (groupId - 1) * 3;
+            if (!groupFurnitureByArea.TryGetValue(areaId, out var packed)) packed = 0;
+            packed |= (selectedIndex << (int)shift);
+            groupFurnitureByArea[areaId] = packed;
+        }
 
         for (uint girlId = 0; girlId <= 50; girlId++)
         {
-            // FurnitureStart..FurnitureEnd = 10..19
+            var baseSid = girlId * 50;
             for (uint offset = 10; offset <= 19; offset++)
-            {
+                yield return (101, baseSid + offset, furnitureUnlockedValue);
-                uint sid = (girlId * 50) + offset;
+
+            if (groupFurnitureByArea.TryGetValue(girlId, out var groupValue))
+                yield return (101, baseSid + 20, groupValue);
+        }
+
+        // Massage room furniture
+        // 10010..10019
+        for (uint sid = 10010; sid <= 10019; sid++)
+            yield return (101, sid, furnitureUnlockedValue);
+
+        // Massage room group state
+        yield return (101, 10020, 1);
+
+        // Hot spring furniture
+        // 15001..15010
+        for (uint sid = 15001; sid <= 15010; sid++)
+            yield return (101, sid, furnitureUnlockedValue);
+
+        // Beach furniture
+        // 17101..17110
+        for (uint sid = 17101; sid <= 17110; sid++)
+            yield return (101, sid, furnitureUnlockedValue);
+
+        for (uint sid = 30000; sid < 31000; sid++)
             yield return (101, sid, furnitureUnlockedValue);
-            }
-        }
     }
 
     private static IEnumerable<(uint Gid, uint Sid, uint Value)> BuildLobbyBootstrapAttrs()

GameServer/Game/Support/SupportAffixService.cs

@@ -0,0 +1,40 @@
+using MikuSB.Data;
+
+namespace MikuSB.GameServer.Game.Support;
+
+public static class SupportAffixService
+{
+    // Returns (affixId, tier) - both 1-based. Returns (0,0) if pool not found.
+    public static (uint AffixId, uint Tier) GenerateRandomAffix(int poolId)
+    {
+        if (!GameData.SupportAffixPoolData.TryGetValue(poolId, out var pool))
+            return (0, 0);
+
+        var groups = pool.Groups.ToList();
+        if (groups.Count == 0)
+            return (0, 0);
+
+        var totalWeight = groups.Sum(x => x.Weight);
+        var roll = Random.Shared.Next(totalWeight);
+        var cumulative = 0;
+        var selectedAffixs = groups[0].Affixs;
+
+        foreach (var (affixIds, weight) in groups)
+        {
+            cumulative += weight;
+            if (roll < cumulative)
+            {
+                selectedAffixs = affixIds;
+                break;
+            }
+        }
+
+        if (selectedAffixs.Count == 0)
+            return (0, 0);
+
+        var affixId = selectedAffixs[Random.Shared.Next(selectedAffixs.Count)];
+        var tierCount = GameData.SupportAffixData.GetValueOrDefault(affixId)?.TierCount ?? 5;
+        var tier = (uint)(Random.Shared.Next(tierCount) + 1);
+        return ((uint)affixId, tier);
+    }
+}

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

@@ -0,0 +1,296 @@
+using MikuSB.Data;
+using MikuSB.Database;
+using MikuSB.Database.Inventory;
+using MikuSB.Database.Player;
+using MikuSB.Enums.Item;
+using MikuSB.Proto;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MikuSB.GameServer.Server.CallGS.Handlers.Girl;
+
+[CallGSApi("GirlCard_UpdateLevel")]
+public class GirlCard_UpdateLevel : ICallGSHandler
+{
+    private const uint CashGroupId = 1;
+    private const uint SilverMoneyType = 3;
+    private const uint SilverSid = SilverMoneyType * 2 + 1;
+    private const uint RoleMaxLevel = 80;
+
+    public async Task Handle(Connection connection, string param, ushort seqNo)
+    {
+        var player = connection.Player!;
+        var req = JsonSerializer.Deserialize<GirlCardUpdateLevelParam>(param);
+        if (req == null || req.Id == 0 || req.Materials == null || req.Materials.Count == 0)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var card = player.CharacterManager.GetCharacterByGUID((uint)req.Id);
+        if (card == null)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "{\"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_UpdateLevel", "{\"sErr\":\"error.BadParam\"}");
+            return;
+        }
+
+        var levelCap = GetCardLevelCap(player.Data.Level, cardTemplate.LevelLimitID);
+        if (levelCap == 0)
+        {
+            levelCap = card.Level;
+        }
+
+        if (card.Level >= RoleMaxLevel)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "{\"sErr\":\"tip.card_max_level\"}");
+            return;
+        }
+
+        var requestedMaterials = new Dictionary<uint, uint>();
+        foreach (var row in req.Materials)
+        {
+            if (row == null || row.Id == 0 || row.Num == 0)
+                continue;
+
+            requestedMaterials[(uint)row.Id] = requestedMaterials.GetValueOrDefault((uint)row.Id) + row.Num;
+        }
+
+        if (requestedMaterials.Count == 0)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "{\"sErr\":\"tip.material_not_enough\"}");
+            return;
+        }
+
+        ulong totalExp = 0;
+        ulong totalSilverCost = 0;
+        foreach (var (itemId, count) in requestedMaterials)
+        {
+            var item = player.InventoryManager.GetNormalItem(itemId);
+            if (item == null || item.ItemCount < count)
+            {
+                await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "{\"sErr\":\"tip.material_not_enough\"}");
+                return;
+            }
+
+            if (!GameData.SuppliesData.TryGetValue((uint)item.TemplateId, out var supplies) || supplies.ProvideExp == 0)
+            {
+                await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "{\"sErr\":\"error.BadParam\"}");
+                return;
+            }
+
+            totalExp += (ulong)supplies.ProvideExp * count;
+            totalSilverCost += (ulong)supplies.ConsumeGold * count;
+        }
+
+        var silverAttr = GetOrCreateAttr(player.Data, CashGroupId, SilverSid);
+        if ((ulong)silverAttr.Val < totalSilverCost)
+        {
+            await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "{\"sErr\":\"tip.material_not_enough\"}");
+            return;
+        }
+
+        var syncItems = new List<Item>();
+        foreach (var (itemId, count) in requestedMaterials)
+        {
+            var item = player.InventoryManager.GetNormalItem(itemId)!;
+            item.ItemCount -= count;
+
+            if (item.ItemCount == 0)
+            {
+                player.InventoryManager.InventoryData.Items.Remove(item.UniqueId);
+                syncItems.Add(BuildRemovedProto(item));
+            }
+            else
+            {
+                syncItems.Add(item.ToProto());
+            }
+        }
+
+        silverAttr.Val -= checked((uint)totalSilverCost);
+
+        var (newLevel, newExp) = ApplyCardExp(card.Level, card.Exp, totalExp, levelCap);
+        card.Level = newLevel;
+        card.Exp = checked((int)newExp);
+        syncItems.Add(card.ToProto());
+
+        DatabaseHelper.SaveDatabaseType(player.InventoryManager.InventoryData);
+        DatabaseHelper.SaveDatabaseType(player.CharacterManager.CharacterData);
+        DatabaseHelper.SaveDatabaseType(player.Data);
+
+        var sync = new NtfSyncPlayer();
+        sync.Items.AddRange(syncItems);
+        sync.Custom[player.ToPackedAttrKey(CashGroupId, SilverSid)] = silverAttr.Val;
+        sync.Custom[player.ToShiftedAttrKey(CashGroupId, SilverSid)] = silverAttr.Val;
+
+        await CallGSRouter.SendScript(connection, "GirlCard_UpdateLevel", "null", 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,
+            Val = 0
+        };
+        data.Attrs.Add(attr);
+        return attr;
+    }
+
+    private static Item BuildRemovedProto(BaseGameItemInfo item)
+    {
+        var proto = item.ToProto();
+        proto.Count = 0;
+        return proto;
+    }
+
+    private static uint GetCardLevelCap(uint playerLevel, int levelLimitId)
+    {
+        var limits = LoadCardLevelLimit(levelLimitId);
+        if (limits.Count == 0)
+            return 0;
+
+        uint nearestAccountLevel = 0;
+        uint nearestCardLevel = 0;
+
+        foreach (var (accountLevel, cardLevel) in limits)
+        {
+            if (accountLevel < playerLevel)
+            {
+                nearestAccountLevel = accountLevel;
+                nearestCardLevel = cardLevel;
+                continue;
+            }
+
+            if (accountLevel == playerLevel)
+                return Math.Min(cardLevel, RoleMaxLevel);
+
+            var distance = accountLevel - nearestAccountLevel;
+            if (distance == 0)
+                return Math.Min(cardLevel, RoleMaxLevel);
+
+            var percent = (playerLevel - nearestAccountLevel) / (double)distance;
+            var interpolated = (uint)Math.Floor(nearestCardLevel + ((cardLevel - nearestCardLevel) * percent));
+            return Math.Min(interpolated, RoleMaxLevel);
+        }
+
+        return Math.Min(nearestCardLevel, RoleMaxLevel);
+    }
+
+    private static List<(uint AccountLevel, uint CardLevel)> LoadCardLevelLimit(int levelLimitId)
+    {
+        var path = Path.Combine(
+            AppContext.BaseDirectory,
+            "Resources",
+            "item",
+            "level_limit.json");
+
+        if (!File.Exists(path))
+            return [];
+
+        using var doc = JsonDocument.Parse(File.ReadAllText(path));
+        var result = new List<(uint AccountLevel, uint CardLevel)>();
+
+        foreach (var row in doc.RootElement.EnumerateArray())
+        {
+            if (!row.TryGetProperty("ID", out var idProp) || idProp.GetInt32() != levelLimitId)
+                continue;
+
+            if (!row.TryGetProperty("Type", out var typeProp) || typeProp.GetInt32() != 1)
+                continue;
+
+            if (!row.TryGetProperty("Limit", out var limitProp) || limitProp.ValueKind != JsonValueKind.Object)
+                continue;
+
+            foreach (var property in limitProp.EnumerateObject())
+            {
+                if (!uint.TryParse(property.Name, out var accountLevel))
+                    continue;
+
+                uint cardLevel;
+                if (property.Value.ValueKind == JsonValueKind.Number)
+                {
+                    cardLevel = property.Value.GetUInt32();
+                }
+                else if (property.Value.ValueKind == JsonValueKind.String &&
+                         uint.TryParse(property.Value.GetString(), out var parsed))
+                {
+                    cardLevel = parsed;
+                }
+                else
+                {
+                    continue;
+                }
+
+                result.Add((accountLevel, cardLevel));
+            }
+
+            break;
+        }
+
+        result.Sort((a, b) => a.AccountLevel.CompareTo(b.AccountLevel));
+        return result;
+    }
+
+    private static (uint Level, ulong Exp) ApplyCardExp(uint level, int currentExp, ulong addedExp, uint levelCap)
+    {
+        var destLevel = level == 0 ? 1u : level;
+        var destExp = (ulong)Math.Max(0, currentExp) + addedExp;
+
+        if (levelCap > 0 && destLevel >= levelCap)
+            return (destLevel, destExp);
+
+        while (destLevel < RoleMaxLevel)
+        {
+            var needExp = GetCardNeedExp(destLevel);
+            if (needExp == 0 || destExp < needExp)
+                break;
+
+            destExp -= needExp;
+            destLevel++;
+
+            if (levelCap > 0 && destLevel >= levelCap)
+                return (levelCap, destExp);
+        }
+
+        return (destLevel, destExp);
+    }
+
+    private static uint GetCardNeedExp(uint currentLevel)
+    {
+        if (GameData.UpgradeExpData.TryGetValue((int)currentLevel, out var row))
+            return row.CardNeedExp;
+
+        return 0;
+    }
+}
+
+internal sealed class GirlCardUpdateLevelParam
+{
+    [JsonPropertyName("Id")]
+    public int Id { get; set; }
+
+    [JsonPropertyName("tbMaterials")]
+    public List<GirlCardLevelMaterial> Materials { get; set; } = [];
+}
+
+internal sealed class GirlCardLevelMaterial
+{
+    [JsonPropertyName("Id")]
+    public int Id { get; set; }
+
+    [JsonPropertyName("Num")]
+    public uint Num { get; set; }
+}

GameServer/Server/CallGS/Handlers/SupporterCard/SupporterCard_Upgrade.cs

@@ -1,5 +1,6 @@
 using MikuSB.Data;
 using MikuSB.Database;
+using MikuSB.GameServer.Game.Support;
 using MikuSB.Proto;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -19,7 +20,7 @@ public class SupporterCard_Upgrade : ICallGSHandler
             return;
         }
 
-        var supportCard = player.InventoryManager.InventoryData.Items.GetValueOrDefault((uint)req.SupportCardUid);
+        var supportCard = player.InventoryManager.GetSupportCardItem((uint)req.SupportCardUid);
         if (supportCard == null)
         {
             await CallGSRouter.SendScript(connection, "Logistics_Upgrade", "{}");
@@ -68,10 +69,11 @@ public class SupporterCard_Upgrade : ICallGSHandler
         }
 
         // Apply exp and level up
+        if (supportCard.Level == 0) supportCard.Level = 1;
         supportCard.Exp += gainedExp;
         while (supportCard.Level < maxLevel)
         {
-            var expNeeded = GetExpNeeded(supportCard.Level + 1);
+            var expNeeded = GetExpNeeded(supportCard.Level);
             if (expNeeded == 0 || supportCard.Exp < expNeeded) break;
             supportCard.Exp -= expNeeded;
             supportCard.Level++;
@@ -80,6 +82,23 @@ public class SupporterCard_Upgrade : ICallGSHandler
         {
             supportCard.Exp = 0;
             supportCard.Level = maxLevel;
+
+            // Unlock next affix slot when reaching max level for the first time
+            if (supportCardExcel != null)
+            {
+                var currentSlots = supportCard.Affixs.Count / 2;
+                var totalSlots = supportCardExcel.TotalAffixCount;
+                if (currentSlots < totalSlots && currentSlots < supportCardExcel.AffixPool.Count)
+                {
+                    var poolId = supportCardExcel.AffixPool[currentSlots];
+                    var (affixId, tier) = SupportAffixService.GenerateRandomAffix(poolId);
+                    if (affixId > 0)
+                    {
+                        supportCard.Affixs.Add(affixId);
+                        supportCard.Affixs.Add(tier);
+                    }
+                }
+            }
         }
 
         syncItems.Add(supportCard.ToProto());

MikuSB.Loader/GameLaunchService.cs

@@ -293,11 +293,14 @@ public sealed class LaunchOptions
     public static LaunchOptions FromConfig(IEnumerable<string>? extraGameArguments = null)
     {
         var config = ConfigManager.Config;
+        var serverBaseDirectory = AppContext.BaseDirectory;
         var gamePath = ResolvePath(config.Loader.GamePath, AppContext.BaseDirectory);
-        var patchPaths = ResolvePatchPaths(config.Loader.PatchPaths, AppContext.BaseDirectory);
+        var patchPaths = ResolvePatchPaths(config.Loader.PatchPaths, serverBaseDirectory);
         var gameArgs = new List<string>(config.Loader.Arguments ?? []);
         if (extraGameArguments is not null)
             gameArgs.AddRange(extraGameArguments.Where(x => !string.IsNullOrWhiteSpace(x)));
+        gameArgs = EnsureUserDirArgument(gameArgs, serverBaseDirectory);
+        PersistResolvedArgumentsIfChanged(config, gameArgs);
 
         var env = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         if (config.Loader.SetAllProxy && config.Proxy.Enabled)
@@ -330,6 +333,31 @@ public sealed class LaunchOptions
         };
     }
 
+    private static List<string> EnsureUserDirArgument(List<string> gameArgs, string baseDirectory)
+    {
+        var userDataDirectory = Path.GetFullPath(Path.Combine(baseDirectory, "Client_User_Data"));
+        Directory.CreateDirectory(userDataDirectory);
+
+        var userDirArgument = $"-userdir={userDataDirectory}";
+        var existingIndex = gameArgs.FindIndex(x => x.StartsWith("-userdir=", StringComparison.OrdinalIgnoreCase));
+        if (existingIndex >= 0)
+            gameArgs[existingIndex] = userDirArgument;
+        else
+            gameArgs.Add(userDirArgument);
+
+        return gameArgs;
+    }
+
+    private static void PersistResolvedArgumentsIfChanged(Configuration.ConfigContainer config, List<string> gameArgs)
+    {
+        var currentArgs = config.Loader.Arguments ?? [];
+        if (currentArgs.SequenceEqual(gameArgs, StringComparer.Ordinal))
+            return;
+
+        config.Loader.Arguments = gameArgs.ToArray();
+        ConfigManager.SaveConfig();
+    }
+
     private static string? ResolvePath(string? value, string baseDirectory)
     {
         if (string.IsNullOrWhiteSpace(value))

MikuSB/Program/LoaderManager.cs

@@ -22,16 +22,35 @@ public class LoaderManager : MikuSB
     public static void InitConfig()
     {
         // Initialize log
-        var counter = 0;
+        var logDir = ConfigManager.Config.Path.LogPath;
-        FileInfo file;
+        var logFile = new FileInfo(Path.Combine(logDir, "Server.log"));
-        while (true)
+        logFile.Directory?.Create();
+
+        if (logFile.Exists)
         {
-            file = new FileInfo(ConfigManager.Config.Path.LogPath + $"/{DateTime.Now:yyyy-MM-dd}-{++counter}.log");
+            // Read start time from first log line, fall back to file creation time
-            if (file is not { Exists: false, Directory: not null }) continue;
+            DateTime logStartTime;
-            file.Directory.Create();
+            try
-            break;
+            {
+                var firstLine = File.ReadLines(logFile.FullName).FirstOrDefault() ?? "";
+                // Format: [HH:mm:ss] ...
+                var timeStr = firstLine.Length >= 10 ? firstLine[1..9] : "";
+                var dateStr = logFile.CreationTime.ToString("yyyy-MM-dd");
+                logStartTime = DateTime.TryParse($"{dateStr} {timeStr}", out var parsed)
+                    ? parsed
+                    : logFile.CreationTime;
             }
-        Logger.SetLogFile(file);
+            catch
+            {
+                logStartTime = logFile.CreationTime;
+            }
+
+            var backupName = $"Server-backup-{logStartTime:yyyy.MM.dd-HH.mm.ss}.log";
+            var backupFile = new FileInfo(Path.Combine(logDir, backupName));
+            logFile.MoveTo(backupFile.FullName, overwrite: true);
+        }
+
+        Logger.SetLogFile(new FileInfo(Path.Combine(logDir, "Server.log")));
 
         // Init all directories
         try

SdkServer/Handlers/RouteController.cs

@@ -270,12 +270,17 @@ public class RouteController : ControllerBase
         var finalEmail = email ?? form_email ?? await GetJsonBodyValue("email");
         if (!string.IsNullOrWhiteSpace(finalEmail))
         {
-            var accountByEmail = AccountData.GetAccountByEmail(finalEmail);
+            var normalizedEmail = finalEmail.Trim();
-            if (accountByEmail == null)
+            var accountData = AccountData.GetAccountByEmail(normalizedEmail);
-                return BuildLoginFailedResponse("Account not found.");
+            if (accountData == null)
+            {
+                if (!ConfigManager.Config.ServerOption.AutoCreateUser) return BuildLoginFailedResponse("Account not found.");
+                AccountData.CreateAccount(normalizedEmail, 0, "123456");
+                accountData = AccountData.GetAccountByEmail(normalizedEmail)!;
+            }
 
-            var finalUidValue = accountByEmail.Uid.ToString();
+            var finalUidValue = accountData.Uid.ToString();
-            var finalTokenValue = accountByEmail.GenerateComboToken();
+            var finalTokenValue = accountData.GenerateComboToken();
 
             object emailLoginRsp = new
             {
@@ -286,14 +291,14 @@ public class RouteController : ControllerBase
                     isFirstLogin = false,
                     isNeedKoreaSciAuth = false,
                     ksOpenId = $"ks_{finalUidValue}",
-                    nickname = accountByEmail.Username,
+                    nickname = accountData.Username,
                     passportId = finalUidValue,
                     playerFillAgeUrl = "",
                     status = 0,
                     thirdPartyUid = "",
                     token = finalTokenValue,
                     type = "guest",
-                    uid = accountByEmail.Uid
+                    uid = accountData.Uid
                 },
                 msg = "操作成功"
             };

version.txt

@@ -1 +1 @@
-v=2.8
+v=3.1