Init enter game

GameServer/Game/Avatar/AvatarManager.cs

@@ -0,0 +1,63 @@
+using KianaBH.Data;
+using KianaBH.Data.Excel;
+using KianaBH.Database;
+using KianaBH.Database.Avatar;
+using KianaBH.Enums.Item;
+using KianaBH.GameServer.Game.Player;
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Util.Extensions;
+
+
+namespace KianaBH.GameServer.Game.Avatar;
+
+public class AvatarManager(PlayerInstance player) : BasePlayerManager(player)
+{
+    public AvatarData AvatarData { get; } = DatabaseHelper.GetInstanceOrCreateNew<AvatarData>(player.Uid);
+    public async ValueTask<AvatarDataExcel?> AddAvatar(int avatarId, bool sync = true)
+    {
+        GameData.AvatarData.TryGetValue(avatarId, out var avatarExcel);
+        if (avatarExcel == null) return null;
+
+        var avatar = new AvatarInfo
+        {
+            Level = 1,
+            Timestamp = Extensions.GetUnixSec(),
+            Star = avatarExcel.UnlockStar,
+            DressId = avatarExcel.DefaultDressId,
+            DressList = {avatarExcel.DefaultDressId},
+            AvatarId = avatarExcel.AvatarID,
+        };
+
+        foreach (var skill in avatarExcel.SkillList)
+        {
+            avatar.SkillList.Add(new AvatarSkill
+            {
+                SkillId = skill
+            });
+        };
+
+        var weapon = GameData.WeaponData.TryGetValue(avatarExcel.InitialWeapon, out var weaponConfig);
+        if (weaponConfig != null) 
+        {
+            var item = await Player.InventoryManager!.AddItem(avatarExcel.InitialWeapon, 1, ItemMainTypeEnum.Weapon, weaponConfig.MaxLv, avatarId);
+            if (item != null)
+            {
+                avatar.WeaponUniqueId = item!.UniqueId;
+            };
+        };
+
+        
+
+        AvatarData.Avatars.Add(avatar);
+
+        if (sync) await Player.SendPacket(new PacketGetAvatarDataRsp(new List<AvatarInfo> { avatar }, false));
+
+        return avatarExcel;
+    }
+
+    public AvatarInfo? GetAvatar(uint avatarId)
+    {
+
+        return AvatarData.Avatars.Find(avatar => avatar.AvatarId == avatarId);
+    }
+}

GameServer/Game/BasePlayerManager.cs

@@ -0,0 +1,8 @@
+using KianaBH.GameServer.Game.Player;
+
+namespace KianaBH.GameServer.Game;
+
+public class BasePlayerManager(PlayerInstance player)
+{
+    public PlayerInstance Player { get; private set; } = player;
+}

GameServer/Game/Inventory/InventoryManager.cs

@@ -0,0 +1,86 @@
+using KianaBH.Data;
+using KianaBH.Database;
+using KianaBH.Database.Inventory;
+using KianaBH.Enums.Item;
+using KianaBH.GameServer.Game.Player;
+using KianaBH.Proto;
+using KianaBH.Util;
+using static KianaBH.Proto.MasterPupilRetcode.Types;
+
+namespace KianaBH.GameServer.Game.Inventory;
+
+public class InventoryManager(PlayerInstance player) : BasePlayerManager(player)
+{
+    public InventoryData Data = DatabaseHelper.GetInstanceOrCreateNew<InventoryData>(player.Uid);
+
+    public async ValueTask<ItemData?> AddItem(int itemId, int count, ItemMainTypeEnum type, int level = 1, int equipAvatar = 0, bool notify = true,
+         bool sync = true)
+    {
+        ItemData? itemData = null;
+
+        switch (type)
+        {
+            case ItemMainTypeEnum.Material:
+                GameData.MaterialData.TryGetValue(itemId, out var materialConfig);
+                if (materialConfig == null) return null;
+                itemData = await PutItem(itemId, count, type);
+                break;
+            case ItemMainTypeEnum.Weapon:
+                GameData.WeaponData.TryGetValue(itemId, out var weaponConfig);
+                if (weaponConfig == null) return null;
+                itemData = await PutItem(itemId, 1, type, level, equipAvatar: equipAvatar, uniqueId: ++Data.NextUniqueId);
+                break;
+            default:
+                break;
+        }
+
+        return itemData;
+    }
+
+    public async ValueTask<ItemData> PutItem(int itemId, int count, ItemMainTypeEnum type, int level = 0,
+        int exp = 0, int equipAvatar = 0, int uniqueId = 0)
+    {
+        var item = new ItemData
+        {
+            ItemId = itemId,
+            Count = count,
+            Level = level,
+            Exp = exp,
+            EquipAvatar = equipAvatar,
+        };
+
+        if (uniqueId > 0) item.UniqueId = uniqueId;
+
+        switch (type)
+        {
+            case ItemMainTypeEnum.Material:
+                var oldItem = Data.MaterialItems.Find(x => x.ItemId == itemId);
+                if (oldItem != null)
+                {
+                    oldItem.Count += count;
+                    item = oldItem;
+                    break;
+                }
+
+                Data.MaterialItems.Add(item);
+                break;
+            case ItemMainTypeEnum.Weapon:
+                if (Data.WeaponItems.Count + 1 > GameConstants.INVENTORY_MAX_EQUIPMENT)
+                {
+                    return item;
+                }
+
+                Data.WeaponItems.Add(item);
+                break;
+            case ItemMainTypeEnum.Stigmata:
+                if (Data.StigmataItems.Count + 1 > GameConstants.INVENTORY_MAX_EQUIPMENT)
+                {
+                    return item;
+                }
+                Data.StigmataItems.Add(item);
+                break;
+        }
+
+        return item;
+    }
+}

GameServer/Game/Player/PlayerInstance.cs

@@ -0,0 +1,110 @@
+using KianaBH.Data;
+using KianaBH.Database;
+using KianaBH.Database.Account;
+using KianaBH.Database.Client;
+using KianaBH.Database.Player;
+using KianaBH.GameServer.Game.Avatar;
+using KianaBH.GameServer.Game.Inventory;
+using KianaBH.GameServer.Server;
+using KianaBH.KcpSharp;
+using KianaBH.Util.Extensions;
+
+namespace KianaBH.GameServer.Game.Player;
+
+public class PlayerInstance(PlayerData data)
+{
+    public AvatarManager? AvatarManager { get; private set; }
+    public InventoryManager? InventoryManager { get; private set; }
+
+    public static readonly List<PlayerInstance> _playerInstances = [];
+    public PlayerData Data { get; set; } = data;
+    public ClientData? ClientData { get; private set; }
+    public GuideData? GuideData { get; private set; }
+    public int Uid { get; set; }
+    public Connection? Connection { get; set; }
+    public bool Initialized { get; set; }
+    public bool IsNewPlayer { get; set; }
+    public int GetMissionDataRequestCount = 0;
+
+    #region Initializers
+    public PlayerInstance(int uid) : this(new PlayerData { Uid = uid })
+    {
+        // new player
+        IsNewPlayer = true;
+        Data.Name = AccountData.GetAccountByUid(uid)?.Username;
+
+        DatabaseHelper.CreateInstance(Data);
+
+        var t = Task.Run(async () =>
+        {
+            await InitialPlayerManager();
+            await AvatarManager!.AddAvatar(101);
+            GuideData?.GuideFinishList.AddRange(GameData.TutorialData.Values.Select(x => x.Id));
+        });
+        t.Wait();
+
+        Initialized = true;
+
+    }
+    private async ValueTask InitialPlayerManager()
+    {
+        Uid = Data.Uid;
+        AvatarManager = new AvatarManager(this);
+        InventoryManager = new InventoryManager(this);
+        ClientData = InitializeDatabase<ClientData>();
+        GuideData = InitializeDatabase<GuideData>();
+        Data.LastActiveTime = Extensions.GetUnixSec();
+
+        await Task.CompletedTask;
+    }
+    public T InitializeDatabase<T>() where T : BaseDatabaseDataHelper, new()
+    {
+        var instance = DatabaseHelper.GetInstanceOrCreateNew<T>(Uid);
+        return instance!;
+    }
+
+    #endregion
+
+    #region Network
+    public async ValueTask OnGetToken()
+    {
+        if (!Initialized) await InitialPlayerManager();
+    }
+
+    public async ValueTask OnLogin()
+    {
+        _playerInstances.Add(this);
+        await Task.CompletedTask;
+    }
+
+    public static PlayerInstance? GetPlayerInstanceByUid(long uid)
+        => _playerInstances.FirstOrDefault(player => player.Uid == uid);
+    public void OnLogoutAsync()
+    {
+        _playerInstances.Remove(this);
+    }
+    public async ValueTask SendPacket(BasePacket packet)
+    {
+        if (Connection?.IsOnline == true) await Connection.SendPacket(packet);
+    }
+
+    #endregion
+
+    #region Actions
+    public async ValueTask OnHeartBeat()
+    {
+        DatabaseHelper.ToSaveUidList.SafeAdd(Uid);
+        await Task.CompletedTask;
+    }
+
+    #endregion
+
+    #region Serialization
+
+    public Proto.GetMainDataRsp ToProto()
+    {
+        return Data.ToProto();
+    }
+
+    #endregion
+}