Remove msg folder

EpinelPS/LobbyServer/LobbyUser/AquireUserTitle.cs

@@ -0,0 +1,20 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/lobby/usertitle/acquire")]
+    public class AquireUserTitle : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqAcquireUserTitle>();
+            var user = GetUser();
+
+            var response = new ResAcquireUserTitle();
+            
+            // TODO
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/BuyWallpaper.cs

@@ -0,0 +1,24 @@
+using EpinelPS.Database;
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/wallpaper/buy")]
+    public class BuyWallpaper : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqBuyLobbyDecoBackground>();
+            var response = new ResBuyLobbyDecoBackground();
+            var user = GetUser();
+            
+            user.LobbyDecoBackgroundList.Add(req.LobbyDecoBackgroundId);
+
+            response.OwnedLobbyDecoBackgroundIdList.Add(user.LobbyDecoBackgroundList);
+
+            JsonDb.Save();
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/EnterLobbyServer.cs

@@ -0,0 +1,93 @@
+using EpinelPS.Database;
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/enterlobbyserver")]
+    public class EnterLobbyServer : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqEnterLobbyServer>();
+            var user = GetUser();
+
+            var battleTime = DateTime.UtcNow - user.BattleTime;
+            var battleTimeMs = (long)(battleTime.TotalNanoseconds / 100);
+
+            // NOTE: Keep this in sync with GetUser code
+
+            var response = new ResEnterLobbyServer();
+            response.User = LobbyHandler.CreateNetUserDataFromUser(user);
+            response.ResetHour = 20;
+            response.Nickname = user.Nickname;
+            response.SynchroLv = 1;
+            response.OutpostBattleLevel = user.OutpostBattleLevel;
+            response.OutpostBattleTime = new NetOutpostBattleTime() { MaxBattleTime = 864000000000, MaxOverBattleTime = 12096000000000, BattleTime = battleTimeMs };
+
+            response.JukeboxV2 = new NetUserJukeboxDataV2() { CommandBgm = new NetJukeboxBgm() { JukeboxTableId = user.CommanderMusic.TableId, Type = NetJukeboxBgmType.NetJukeboxBgmTypeJukeboxTableId, Location = NetJukeboxLocation.NetJukeboxLocationCommanderRoom } };
+
+            // Add default slot data
+            if (user.RepresentationTeamData.Slots.Count == 0)
+            {
+                user.RepresentationTeamData = new NetWholeUserTeamData() { TeamNumber = 1, Type = 2 };
+                user.RepresentationTeamData.Slots.Add(new NetWholeTeamSlot() { Slot = 1 });
+                user.RepresentationTeamData.Slots.Add(new NetWholeTeamSlot() { Slot = 2 });
+                user.RepresentationTeamData.Slots.Add(new NetWholeTeamSlot() { Slot = 3 });
+                user.RepresentationTeamData.Slots.Add(new NetWholeTeamSlot() { Slot = 4 });
+                user.RepresentationTeamData.Slots.Add(new NetWholeTeamSlot() { Slot = 5 });
+                JsonDb.Save();
+            }
+            response.RepresentationTeam = user.RepresentationTeamData;
+
+            foreach (var item in user.Currency)
+            {
+                response.Currency.Add(new NetUserCurrencyData() { Type = (int)item.Key, Value = item.Value });
+            }
+
+            foreach (var item in user.Characters)
+            {
+                response.Character.Add(new NetUserCharacterData() { Default = new() { Csn = item.Csn, Skill1Lv = item.Skill1Lvl, Skill2Lv = item.Skill2Lvl, CostumeId = item.CostumeId, Level = user.GetCharacterLevel(item.Csn, item.Level), Grade = item.Grade, Tid = item.Tid, UltiSkillLv = item.UltimateLevel}, IsSynchro = user.GetSynchro(item.Csn) });
+            }
+          
+            foreach (var item in NetUtils.GetUserItems(user))
+            {
+                response.Items.Add(item);
+            }
+
+            // Add squad data if there are characters
+            if (user.Characters.Count > 0)
+            {
+                var highestLevelCharacters = user.Characters.OrderByDescending(x => x.Level).Take(5).ToList();
+                response.SynchroLv = user.GetSynchroLevel();
+
+                foreach (var item in highestLevelCharacters)
+                {
+                    response.SynchroStandardCharacters.Add(item.Csn);
+                }
+
+                foreach (var teamInfo in user.UserTeams)
+                    response.TypeTeams.Add(teamInfo.Value);
+            }
+
+            // TODO: Save outpost data
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 1, BuildingId = 22401, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 4, BuildingId = 22701, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 5, BuildingId = 22801, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 6, BuildingId = 22901, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 7, BuildingId = 23001, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 3, BuildingId = 23101, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 2, BuildingId = 23201, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 9, BuildingId = 23301, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 8, BuildingId = 23401, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 10, BuildingId = 23501, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+            response.Outposts.Add(new NetUserOutpostData() { SlotId = 38, BuildingId = 33601, IsDone = true, StartAt = 638549982076760660, CompleteAt = 638549982076760660 });
+
+            response.LastClearedNormalMainStageId = user.LastNormalStageCleared;
+            response.TimeRewardBuffs.AddRange(NetUtils.GetOutpostTimeReward(user));
+
+            response.OwnedLobbyDecoBackgroundIdList.AddRange(user.LobbyDecoBackgroundList);
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetAllFeatureFlags.cs

@@ -0,0 +1,52 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/featureflags/all/get")]
+    public class GetAllFeatureFlags : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetAllFeatureFlags>();
+
+            var response = new ResGetAllFeatureFlags();
+            response.Flags.AddRange([
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.UnionRaid, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.CooperationEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.RookieArena, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.SimulationRoom, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.DailyEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.Intercept, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.Attendance, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.Dice, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.StoryDungeonEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.Tower, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.LostSector, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.Subscription, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.ArchiveEventSystem, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.ViewShortCut, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.PollEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.ComeBackUserEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.EventPass, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.FieldHubEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.ShopEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.MissionEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.ChargeGachaEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.MiniGameSortOut, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.CharacterSkillResetEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.EventQuest, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.RewardUpEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.SdbattleEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.TextAdventure, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.ChallengeModeEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.DailyFreeGachaEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.BoxGachaEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.DiceEvent, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.Bbqtycoon, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.Ce002MiniGame, IsOpen = true },
+                    new NetFeatureFlag() { FeatureKind = NetFeatureKind.SoloRaid, IsOpen = true },
+                ]);
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetContentsData.cs

@@ -0,0 +1,34 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/getcontentsdata")]
+    public class GetContentsData : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetContentsOpenData>();
+            var user = GetUser();
+
+            // this request returns a list of "special" stages that mark when something is unlocked, ex: the shop or interception
+
+            List<int> specialStages = [6003003, 6002008, 6002016, 6005003, 6003021, 6011018, 6007021, 6004018, 6005013, 6003009, 6003012, 6009017, 6016039, 6001004, 6000003, 6000001, 6002001, 6004023, 6005026, 6020050, 6006004, 6006023,6022049];
+
+            var response = new ResGetContentsOpenData();
+            foreach (var field in user.FieldInfoNew.Values)
+            {
+                foreach (var stage in field.CompletedStages)
+                {
+                    if (specialStages.Contains(stage))
+                        response.ClearStageList.Add(stage);
+                }
+            }
+            response.MaxGachaCount = 10;
+			response.MaxGachaPremiumCount = 10;
+            // todo tutorial playcount of gacha
+            response.TutorialGachaPlayCount = user.GachaTutorialPlayCount;
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetFieldTalkList.cs

@@ -0,0 +1,19 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/getfieldtalklist")]
+    public class GetFieldTalkList : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetFieldTalkList>();
+            var user = GetUser();
+
+            var response = new ResGetFieldTalkList();
+            // TODO
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetMail.cs

@@ -0,0 +1,30 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/mail/get")]
+    public class GetMail : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetMailData>();
+
+            var r = new ResGetMailData();
+            r.Mail.Add(new NetUserMailData()
+            {
+
+                Msn = 3,
+                Nickname = "nick",
+                Title = new() { IsPlain = true, Str = "Our Server Fell" },
+                Text = new() { IsPlain = true, Str = "Our Game Was Down For 1 Second because the HP Laptop Which Hosted the Server Got Shut Down by the Lid Closing. As for the Reward for the Inconvience, free paid gems" },
+                HasReward = true,
+                Sender = 102
+
+            });
+
+            r.Mail[0].Items.Add(new NetMailRewardItem() { ExpiredAt = DateTimeOffset.UtcNow.AddYears(10).ToUnixTimeSeconds(), RewardId = 1, RewardType = (int)CurrencyType.ChargeCash, RewardValue = 100000 });
+
+            await WriteDataAsync(r);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetProfileCardPossession.cs

@@ -0,0 +1,17 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/ProfileCard/Possession/Get")]
+    public class GetProfileCardPossession : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqProfileCardObjectList>();
+
+            var response = new ResProfileCardObjectList();
+            // TODO
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetProfileDecoration.cs

@@ -0,0 +1,19 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/ProfileCard/DecorationLayout/Get")]
+    public class GetProfileDecoration : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqProfileCardDecorationLayout>();
+
+            var r = new ResProfileCardDecorationLayout();
+            r.Layout = new ProfileCardDecorationLayout();
+            r.Layout.BackgroundId = 101002;
+			r.Layout.ShowCharacterSpine = true;
+            await WriteDataAsync(r);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetProfileFrame.cs

@@ -0,0 +1,22 @@
+using EpinelPS.Utils;
+using EpinelPS.StaticInfo;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/User/GetProfileFrame")]
+    public class GetProfileFrame : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetProfileFrame>();
+            var response = new ResGetProfileFrame();
+
+            foreach (var frameRecord in GameData.Instance.userFrameTable.Values)
+            {
+                response.Frames.Add(frameRecord.id);
+            }
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetScenarioList.cs

@@ -0,0 +1,25 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/User/GetScenarioList")]
+    public class GetScenarioList : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetScenarioList>();
+            var user = GetUser();
+
+            // todo what are bookmark scenarios?
+
+            // this returns a list of scenarios that user has completed
+            var response = new ResGetScenarioList();
+            foreach (var item in user.CompletedScenarios)
+            {
+                response.ScenarioList.Add(item);
+            }
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetSpecialLobbySlotData.cs

@@ -0,0 +1,22 @@
+using EpinelPS.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/speciallobbyslot/get")]
+    public class GetSpecialLobbySlotData : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetSpecialLobbySlotData>();
+
+            var response = new ResGetSpecialLobbySlotData();
+            // TODO
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetUser.cs

@@ -0,0 +1,48 @@
+using EpinelPS.Utils;
+using EpinelPS.Database;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/User/Get")]
+    public class GetUser : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetUserData>();
+            var response = new ResGetUserData();
+            var user = GetUser();
+
+            var battleTime = DateTime.UtcNow - user.BattleTime;
+            var battleTimeMs = (long)(battleTime.TotalNanoseconds / 100);
+
+
+            response.User = LobbyHandler.CreateNetUserDataFromUser(user);
+            response.ResetHour = 20;
+            response.OutpostBattleTime = new NetOutpostBattleTime() { MaxBattleTime = 864000000000, MaxOverBattleTime = 12096000000000, BattleTime = battleTimeMs };
+            response.OutpostBattleLevel = user.OutpostBattleLevel;
+            response.IsSimple = req.IsSimple;
+
+            foreach (var item in user.Currency)
+            {
+                response.Currency.Add(new NetUserCurrencyData() { Type = (int)item.Key, Value = item.Value });
+            }
+            response.RepresentationTeam = user.RepresentationTeamData;
+
+            response.LastClearedNormalMainStageId = user.LastNormalStageCleared;
+
+            // Restore completed tutorials. GroupID is the first 4 digits of the Table ID.
+            foreach (var item in user.ClearedTutorialData)
+            {
+                int groupId = item.Value.GroupId;
+                int version = item.Value.VersionGroup;
+
+                response.User.Tutorials.Add(new NetTutorialData() { GroupId = groupId, LastClearedTid = item.Key, LastClearedVersion = version });
+            }
+
+            response.CommanderRoomJukeboxBgm = new NetJukeboxBgm() { JukeboxTableId = user.CommanderMusic.TableId, Type = NetJukeboxBgmType.NetJukeboxBgmTypeJukeboxTableId, Location = NetJukeboxLocation.NetJukeboxLocationCommanderRoom };
+            response.LobbyJukeboxBgm = new NetJukeboxBgm() { JukeboxTableId = user.LobbyMusic.TableId, Type = NetJukeboxBgmType.NetJukeboxBgmTypeJukeboxTableId, Location = NetJukeboxLocation.NetJukeboxLocationLobby };
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetUserProfile.cs

@@ -0,0 +1,40 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/User/GetProfile")]
+    public class GetUserProfile : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetProfileData>();
+            var callingUser = GetUser();
+            var user = GetUser((ulong)req.TargetUsn);
+            var response = new ResGetProfileData();
+          
+            if (user != null)
+            {
+                response.Data = new NetProfileData();
+                response.Data.User = LobbyHandler.CreateWholeUserDataFromDbUser(user);
+                response.Data.LastActionAt = DateTimeOffset.UtcNow.Ticks;
+                response.Data.CharacterCount.Add(new NetCharacterCount() { Count = user.Characters.Count });
+                response.Data.InfraCoreLv = user.InfraCoreLvl;
+                response.Data.LastCampaignNormalStageId = user.LastNormalStageCleared;
+                response.Data.LastCampaignHardStageId = user.LastHardStageCleared;
+                response.Data.OutpostOpenState = user.MainQuestData.ContainsKey(25);
+
+                foreach (var item in user.RepresentationTeamData.Slots)
+                {
+                    var c = user.GetCharacterBySerialNumber(item.Csn);
+
+                    if (c != null)
+                    {
+                        response.Data.ProfileTeam.Add(new NetProfileTeamSlot() { Slot = item.Slot, Default = new() { CostumeId = c.CostumeId, Csn = c.Csn, Grade = c.Grade, Level = c.Level, Skill1Lv = c.Skill1Lvl, Skill2Lv = c.Skill2Lvl, Tid = c.Tid, UltiSkillLv = c.UltimateLevel } });
+                    }
+                }
+            }
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetUserScenarioExist.cs

@@ -0,0 +1,35 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/scenario/exist")]
+    public class GetUserScenarioExist : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqExistScenario>();
+
+            // TODO: Check response from real server
+
+            var response = new ResExistScenario();
+
+            var user = GetUser();
+
+            foreach (var item in req.ScenarioGroupIds)
+            {
+                Console.WriteLine("check scenario " + item);
+                foreach (var completed in user.CompletedScenarios)
+                {
+                    // story thingy was completed
+                    if (completed == item)
+                    {
+                        Console.WriteLine(item + " is completed");
+                        response.ExistGroupIds.Add(item);
+                    }
+                }
+            }
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetUserTitle.cs

@@ -0,0 +1,25 @@
+using EpinelPS.Utils;
+using EpinelPS.StaticInfo; // For GameData access
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/lobby/usertitle/get")]
+    public class GetUserTitle : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetUserTitleList>();
+            var r = new ResGetUserTitleList();
+
+            // Access GameData and get all UserTitle IDs
+            var userTitleRecords = GameData.Instance.userTitleRecords;
+
+            foreach (var titleId in userTitleRecords.Keys)
+            {
+                r.UserTitleList.Add(new NetUserTitle() { UserTitleId = titleId });
+            }
+
+            await WriteDataAsync(r);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetUserTitleCounter.cs

@@ -0,0 +1,17 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/lobby/usertitlecounter/get")]
+    public class GetUserTitleCounter : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetUserTitleCounterList>();
+
+            var r = new ResGetUserTitleCounterList();
+
+            await WriteDataAsync(r);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetWallpaper.cs

@@ -0,0 +1,27 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/User/GetWallpaper")]
+    public class GetWallpaper : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetWallpaper>();
+            var response = new ResGetWallpaper();
+            var user = GetUser();
+
+
+            response.WallpaperList.AddRange(user.WallpaperList);
+            response.WallpaperPlaylistList.AddRange(user.WallpaperPlaylistList);
+            response.WallpaperJukeboxList.AddRange(user.WallpaperJukeboxList);
+            response.WallpaperBackgroundList.AddRange(user.WallpaperBackground);
+            response.WallpaperFavoriteList.AddRange(user.WallpaperFavoriteList);
+            response.OwnedLobbyDecoBackgroundIdList.AddRange(user.LobbyDecoBackgroundList);
+
+            // TODO: JukeboxIdList
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/GetWallpaperInventory.cs

@@ -0,0 +1,26 @@
+using EpinelPS.Utils;
+using EpinelPS.StaticInfo;
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/getwallpaperinventory")]
+    public class GetWallpaperInventory : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqGetWallpaperInventory>();
+
+            // Prepare the response
+            var r = new ResGetWallpaperInventory();
+
+            // Fetch all the wallpaper IDs from the LiveWallpaperTable,
+            // excluding records where livewallpaper_type is "SkillCutScene"
+            var wallpaperIds = GameData.Instance.lwptablemgrs.Where(w => w.Value.livewallpaper_type != "SkillCutScene").Select(w => w.Key).ToList();
+
+            // Add the filtered wallpaper IDs to the LivewallpaperIds field
+            r.LivewallpaperIds.AddRange(wallpaperIds);
+
+            // Send the response back
+            await WriteDataAsync(r);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/ReadMail.cs

@@ -0,0 +1,17 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/mail/read")]
+    public class ReadMail : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqReadMail>();
+
+            var r = new ResReadMail();
+            //TODO
+            await WriteDataAsync(r);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/SetNickname.cs

@@ -0,0 +1,21 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/setnickname")]
+    public class SetNickname : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetNickname>();
+            var user = GetUser();
+            user.Nickname = req.Nickname;
+
+            var response = new ResSetNickname();
+            response.Result = SetNicknameResult.SetNicknameResultOkay;
+            response.Nickname = req.Nickname;
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/SetProfileData.cs

@@ -0,0 +1,28 @@
+using EpinelPS.Database;
+using EpinelPS.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/setprofiledata")]
+    public class SetProfileData : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetProfileData>();
+            var user = GetUser();
+            user.ProfileIconId = req.Icon;
+            user.ProfileIconIsPrism = req.IsPrism;
+            user.ProfileFrame = req.Frame;
+
+            JsonDb.Save();
+            var response = new ResSetProfileData();
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/SetProfileIcon.cs

@@ -0,0 +1,21 @@
+using EpinelPS.Database;
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/setprofileicon")]
+    public class SetProfileIcon : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetProfileIcon>();
+            var user = GetUser();
+            user.ProfileIconId = req.Icon;
+            user.ProfileIconIsPrism = req.IsPrism;
+            JsonDb.Save();
+            var response = new ResSetProfileIcon();
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/SetProfileTeam.cs

@@ -0,0 +1,35 @@
+using EpinelPS.Database;
+using EpinelPS.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/user/setprofileteam")]
+    public class SetProfileTeam : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetProfileTeam>();
+            var user = GetUser();
+            user.RepresentationTeamData = new NetWholeUserTeamData();
+            user.RepresentationTeamData.TeamNumber = req.Team.TeamNumber;
+            foreach (var item in req.Team.Slots)
+            {
+                var character = user.GetCharacterBySerialNumber(item.Value);
+                if (character != null)
+                {
+                    user.RepresentationTeamData.Slots.Add(new NetWholeTeamSlot() { Csn = item.Value, Slot = item.Slot, CostumeId = character.CostumeId, Level = character.Level, Tid = character.Tid });
+                }
+            }
+
+            JsonDb.Save();
+            var response = new ResSetProfileTeam();
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/SetScenarioCompleted.cs

@@ -0,0 +1,31 @@
+using EpinelPS.Database;
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/User/SetScenarioComplete")]
+    public class SetScenarioCompleted : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetScenarioComplete>();
+
+            var response = new ResSetScenarioComplete();
+
+            // Mark the story "scenario" as completed.
+            // TODO: Get rewards by making a database of them from actual server.
+            response.Reward = new NetRewardData();
+
+
+            var user = JsonDb.GetUser(UserId);
+            if (user == null)
+            {
+                throw new Exception("null user in SetScenarioComplete command");
+            }
+            user.CompletedScenarios.Add(req.ScenarioId);
+            JsonDb.Save();
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/SetUserTitle.cs

@@ -0,0 +1,19 @@
+using EpinelPS.Utils;
+using EpinelPS.Database;
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/lobby/usertitle/set")]
+    public class SetUserTitleData : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetUserTitle>();
+			var user = GetUser();
+			user.TitleId = req.UserTitleId;
+			JsonDb.Save();
+            var response = new ResSetUserTitle();
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/SetWallpaper.cs

@@ -0,0 +1,25 @@
+using EpinelPS.Database;
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/User/SetWallpaper")]
+    public class SetWallpaper : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetWallpaper>();
+            var response = new ResSetWallpaper();
+            var user = GetUser();
+            user.WallpaperList = req.WallpaperList.ToArray();
+            user.WallpaperBackground = req.WallpaperBackgroundList.ToArray();
+            user.WallpaperFavoriteList = req.WallpaperFavoriteList.ToArray();
+            user.WallpaperPlaylistList = req.WallpaperPlaylistList.ToArray();
+            user.WallpaperJukeboxList = req.WallpaperJukeboxList.ToArray();
+
+            JsonDb.Save();
+
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/Tutorial/SetTutorial.cs

@@ -0,0 +1,27 @@
+using EpinelPS.Database;
+using EpinelPS.StaticInfo;
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser.Tutorial
+{
+    [PacketPath("/tutorial/set")]
+    public class SetTutorial : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqSetTutorial>();
+            var user = GetUser();
+
+            if (!user.ClearedTutorialData.ContainsKey(req.LastClearedTid))
+            {
+                var cleared = GameData.Instance.GetTutorialDataById(req.LastClearedTid);
+                cleared.id = req.LastClearedTid;
+                user.ClearedTutorialData.Add(req.LastClearedTid, cleared);
+            }
+            JsonDb.Save();
+
+            var response = new ResSetTutorial();
+            await WriteDataAsync(response);
+        }
+    }
+}

EpinelPS/LobbyServer/LobbyUser/UnmarkUsertitleBadge.cs

@@ -0,0 +1,20 @@
+using EpinelPS.Utils;
+
+namespace EpinelPS.LobbyServer.LobbyUser
+{
+    [PacketPath("/lobby/usertitle/unmark-badge")]
+    public class UnmarkUserTitleBase : LobbyMsgHandler
+    {
+        protected override async Task HandleAsync()
+        {
+            var req = await ReadData<ReqUnMarkUserTitleBadge>();
+            var user = GetUser();
+
+            var response = new ResUnMarkUserTitleBadge();
+
+            // TODO
+
+            await WriteDataAsync(response);
+        }
+    }
+}