init

game_server/handlers/ChangeLineupLeaderCsReq.py

@@ -0,0 +1,13 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    ChangeLineupLeaderCsReq,
+    ChangeLineupLeaderScRsp
+)
+
+async def handle(session: PlayerSession, msg: ChangeLineupLeaderCsReq) -> betterproto.Message:
+    session.player.lineup_manager.get(session.player.data.cur_lineup,None).leader_slot = msg.slot
+    return ChangeLineupLeaderScRsp(
+        retcode=0,
+        slot=msg.slot
+    )

game_server/handlers/DressAvatarCsReq.py

@@ -0,0 +1,38 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    DressAvatarCsReq, 
+    DressAvatarScRsp
+)
+
+async def handle(session: PlayerSession, msg: DressAvatarCsReq) -> betterproto.Message:
+    equipment = session.player.inventory_manager.get(msg.equipment_unique_id)
+    target_avatar = session.player.avatar_mananger.get(msg.avatar_id)
+    
+    if not equipment or not target_avatar:
+        return DressAvatarScRsp()
+
+    previous_avatar = session.player.avatar_mananger.get(equipment.equip_avatar)
+    if previous_avatar:
+        if previous_avatar.lightcone_id > 0 and target_avatar.lightcone_id > 0:
+            target_equipment = session.player.inventory_manager.get(target_avatar.lightcone_id)
+            target_avatar.lightcone_id, previous_avatar.lightcone_id = previous_avatar.lightcone_id, target_avatar.lightcone_id
+            target_equipment.equip_avatar, equipment.equip_avatar = previous_avatar.avatar_id, target_avatar.avatar_id
+            #target_equipment.save_item()
+        else:
+            previous_avatar.lightcone_id = 0
+            equipment.equip_avatar = target_avatar.avatar_id
+            target_avatar.lightcone_id = equipment.unique_id
+        #previous_avatar.save_avatar()
+    else:
+        if target_avatar.lightcone_id > 0:
+            previous_equipment = session.player.inventory_manager.get(target_avatar.lightcone_id)
+            previous_equipment.equip_avatar = 0
+            #previous_equipment.save_item()
+        equipment.equip_avatar = target_avatar.avatar_id
+        target_avatar.lightcone_id = equipment.unique_id
+
+    #equipment.save_item()
+    #target_avatar.save_avatar()
+    await session.notify(session.player.PlayerSyncProto())
+    return DressAvatarScRsp(retcode=0)

game_server/handlers/DressRelicAvatarCsReq.py

@@ -0,0 +1,73 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    DressRelicAvatarCsReq,
+    DressRelicAvatarScRsp
+)
+
+async def handle(session: PlayerSession, msg: DressRelicAvatarCsReq) -> betterproto.Message:
+    target_avatar = session.player.avatar_mananger.get(msg.avatar_id)
+    if not target_avatar:
+        return DressRelicAvatarScRsp()
+
+    for relic_data in msg.switch_list:
+        relic = session.player.inventory_manager.get(relic_data.relic_unique_id)
+        if not relic:
+            continue
+
+        relic_sub_type = str(relic.sub_type)
+        current_relic_id = target_avatar.relic_ids.get(relic_sub_type, 0)
+        previous_avatar = session.player.avatar_mananger.get(relic.equip_avatar)
+
+        if previous_avatar:
+            previous_relic_id = previous_avatar.relic_ids.get(relic_sub_type, 0)
+
+            if previous_relic_id > 0 and current_relic_id > 0:
+                current_relic = session.player.inventory_manager.get(current_relic_id)
+                previous_relic = session.player.inventory_manager.get(previous_relic_id)
+
+                if current_relic and previous_relic:
+                    previous_avatar.relic_ids[relic_sub_type] = current_relic.unique_id
+                    current_relic.equip_avatar = previous_avatar.avatar_id
+
+                    target_avatar.relic_ids[relic_sub_type] = previous_relic.unique_id
+                    previous_relic.equip_avatar = target_avatar.avatar_id
+
+                    #current_relic.save_item()
+                    #previous_relic.save_item()
+
+            elif previous_relic_id > 0:
+                previous_relic = session.player.inventory_manager.get(previous_relic_id)
+                if previous_relic:
+                    previous_relic.equip_avatar = 0
+                    #previous_relic.save_item()
+                previous_avatar.relic_ids[relic_sub_type] = 0
+
+            elif current_relic_id > 0:
+                current_relic = session.player.inventory_manager.get(current_relic_id)
+                if current_relic:
+                    current_relic.equip_avatar = 0
+                    #current_relic.save_item()
+                target_avatar.relic_ids[relic_sub_type] = 0
+
+            target_avatar.relic_ids[relic_sub_type] = relic.unique_id
+            relic.equip_avatar = target_avatar.avatar_id
+            #relic.save_item()
+            #previous_avatar.save_avatar()
+
+        else:
+            if current_relic_id > 0:
+                current_relic = session.player.inventory_manager.get(current_relic_id)
+                if current_relic:
+                    current_relic.equip_avatar = 0
+                    #current_relic.save_item()
+
+            target_avatar.relic_ids[relic_sub_type] = relic.unique_id
+            relic.equip_avatar = target_avatar.avatar_id
+            #relic.save_item()
+
+        #target_avatar.save_avatar()
+
+    await session.notify(session.player.PlayerSyncProto())
+    
+    return DressRelicAvatarScRsp(retcode=0)

game_server/handlers/EnterSceneCsReq.py

@@ -0,0 +1,39 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.game.motion.motion_info import Motion
+from rail_proto.lib import (
+    EnterSceneCsReq,
+    EnterSceneScRsp,
+    EnterSceneByServerScNotify,
+    SceneEntityMoveScNotify
+)
+
+async def handle(session: PlayerSession, msg: EnterSceneCsReq) -> betterproto.Message:
+    scene = session.player.scene_manager
+    scene.entry_id = msg.entry_id
+    if msg.teleport_id > 0:
+        session.player.scene_manager.teleport_id = msg.teleport_id
+    scene_proto = scene.ToProto(session)
+    lineup = session.player.lineup_manager.get(session.player.data.cur_lineup).ToProto()
+    session.pending_notify(
+        EnterSceneByServerScNotify(
+            scene=scene_proto,
+            lineup=lineup
+        )
+    )
+    session.pending_notify(
+        SceneEntityMoveScNotify(
+            entry_id=session.player.scene_manager.entry_id,
+            motion=Motion(
+                x=session.player.data.pos.x,
+                y=session.player.data.pos.y,
+                z=session.player.data.pos.z,
+                rotY=session.player.data.rot.y,
+            ).ToProto()
+        )
+    )
+    scene.teleport_id = 0
+    #session.player.data.save_player_data()
+    return EnterSceneScRsp(
+        retcode=0
+    )

game_server/handlers/GetAllLineupDataCsReq.py

@@ -0,0 +1,16 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetAllLineupDataCsReq,
+    GetAllLineupDataScRsp,
+    LineupInfo
+)
+
+async def handle(session: PlayerSession, msg: GetAllLineupDataCsReq) -> betterproto.Message:
+    lineups: list[LineupInfo] = []
+    for index,lineup in session.player.lineup_manager.items():
+        lineups.append(lineup.ToProto())
+    return GetAllLineupDataScRsp(
+        retcode=0,
+        lineup_list=lineups
+    )

game_server/handlers/GetAvatarDataCsReq.py

@@ -0,0 +1,16 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetAvatarDataCsReq,
+    GetAvatarDataScRsp,
+    Avatar
+)
+
+async def handle(session: PlayerSession, msg: GetAvatarDataCsReq) -> betterproto.Message:
+    avatars: list[Avatar] = []
+    for avatar_id,avatar in session.player.avatar_mananger.items():
+        avatars.append(avatar.ToProto())
+    return GetAvatarDataScRsp(
+        retcode=0,
+        avatar_list=avatars
+    )

game_server/handlers/GetBagCsReq.py

@@ -0,0 +1,15 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetBagCsReq,
+    GetBagScRsp
+)
+
+async def handle(session: PlayerSession, msg: GetBagCsReq) -> betterproto.Message:
+    equipment = [equipment.ToProto() for unique_id,equipment in session.player.inventory_manager.items() if equipment.main_type == 1]
+    relics = [relic.ToProto() for unique_id,relic in session.player.inventory_manager.items() if relic.main_type == 2]
+    return GetBagScRsp(
+        retcode=0,
+        equipment_list=equipment,
+        relic_list=relics
+    )

game_server/handlers/GetBasicInfoCsReq.py

@@ -0,0 +1,24 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetBasicInfoCsReq,
+    GetBasicInfoScRsp,
+    PlayerSettingInfo
+)
+
+async def handle(session: PlayerSession, msg: GetBasicInfoCsReq) -> betterproto.Message:
+    return GetBasicInfoScRsp(
+        retcode=0,
+        player_setting_info=PlayerSettingInfo(
+            mmmnjchemfn=True,
+            kapdimgjlnf=True,
+            ilfalcdlaol=True,
+            gmjanojmkce=True,
+            pbkbglhhkpe=True,
+            nkekibnjmpa=True,
+            kjncckhjfhe=True,
+            aicnfaobcpi=True,
+            aponeidmphl=True,
+            njfmiljofok=True
+        )
+    )

game_server/handlers/GetChallengeCsReq.py

@@ -0,0 +1,20 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.resource import ResourceManager
+from game_server.resource.configdb.challenge_maze_config import ChallengeMazeConfig
+from rail_proto.lib import (
+    GetChallengeCsReq,
+    GetChallengeScRsp,
+    Challenge
+)
+
+async def handle(session: PlayerSession, msg: GetChallengeCsReq) -> betterproto.Message:
+    return GetChallengeScRsp(
+        retcode=0,
+        challenge_list=[
+            Challenge(
+                challenge_id=challenge.ID
+            )
+            for challenge in ResourceManager.instance().values(ChallengeMazeConfig)
+        ]
+    )

game_server/handlers/GetCurLineupDataCsReq.py

@@ -0,0 +1,12 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetCurLineupDataCsReq,
+    GetCurLineupDataScRsp
+)
+
+async def handle(session: PlayerSession, msg: GetCurLineupDataCsReq) -> betterproto.Message:
+    return GetCurLineupDataScRsp(
+        retcode=0,
+        lineup=session.player.lineup_manager.get(session.player.data.cur_lineup,None).ToProto()
+    )

game_server/handlers/GetCurSceneInfoCsReq.py

@@ -0,0 +1,25 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.game.motion.motion_info import Motion
+from rail_proto.lib import (
+    GetCurSceneInfoCsReq,
+    GetCurSceneInfoScRsp,
+    SceneEntityMoveScNotify
+)
+
+async def handle(session: PlayerSession, msg: GetCurSceneInfoCsReq) -> betterproto.Message:
+    session.pending_notify(
+        SceneEntityMoveScNotify(
+            entry_id=session.player.scene_manager.entry_id,
+            motion=Motion(
+                x=session.player.data.pos.x,
+                y=session.player.data.pos.y,
+                z=session.player.data.pos.z,
+                rotY=session.player.data.rot.y,
+            ).ToProto()
+        )
+    )
+    return GetCurSceneInfoScRsp(
+        retcode=0,
+        scene=session.player.scene_manager.ToProto(session=session)
+    )

game_server/handlers/GetFriendListInfoCsReq.py

@@ -0,0 +1,29 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetFriendListInfoCsReq,
+    GetFriendListInfoScRsp,
+    FriendSimpleInfo,
+    PlayerSimpleInfo,
+    PlatformType,
+    FriendOnlineStatus
+)
+
+async def handle(session: PlayerSession, msg: GetFriendListInfoCsReq) -> betterproto.Message:
+    return GetFriendListInfoScRsp(
+        retcode=0,
+        friend_list=[
+            FriendSimpleInfo(
+                player_info=PlayerSimpleInfo(
+                    uid=69,
+                    level=1,
+                    chat_bubble_id=220004,
+                    head_icon=201310,
+                    platform=PlatformType.PC.value,
+                    online_status=FriendOnlineStatus.FRIEND_ONLINE_STATUS_ONLINE.value,
+                    is_banned=False,
+                    nickname="FireFly"
+                )
+            )
+        ]
+    )

game_server/handlers/GetMissionStatusCsReq.py

@@ -0,0 +1,26 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.resource import ResourceManager
+from game_server.resource.configdb.main_mission import MainMissionData
+from rail_proto.lib import (
+    GetMissionStatusCsReq,
+    GetMissionStatusScRsp,
+    Mission,
+    MissionStatus
+)
+
+async def handle(session: PlayerSession, msg: GetMissionStatusCsReq) -> betterproto.Message:
+    return GetMissionStatusScRsp(
+        retcode=0,
+        finished_main_mission_id_list=[mission.MainMissionID for mission in ResourceManager.instance().values(MainMissionData)],
+        sub_mission_status_list=[
+            Mission(
+                id=mission_id,
+                progress=1,
+                status=MissionStatus.MISSION_FINISH.value
+            )
+            for mission_id in msg.sub_mission_id_list
+        ],
+        unfinished_main_mission_id_list=[],
+        disabled_main_mission_id_list=[]
+    )

game_server/handlers/GetNpcTakenRewardCsReq.py

@@ -0,0 +1,13 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetNpcTakenRewardCsReq,
+    GetNpcTakenRewardScRsp,
+    PlayerSettingInfo
+)
+
+async def handle(session: PlayerSession, msg: GetNpcTakenRewardCsReq) -> betterproto.Message:
+    return GetNpcTakenRewardScRsp(
+        retcode=0,
+        npc_id=msg.npc_id
+    )

game_server/handlers/GetPhoneDataCsReq.py

@@ -0,0 +1,17 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.resource import ResourceManager
+from game_server.resource.configdb.item_config import ItemConfig
+from rail_proto.lib import (
+    GetPhoneDataCsReq,
+    GetPhoneDataScRsp
+)
+
+async def handle(session: PlayerSession, msg: GetPhoneDataCsReq) -> betterproto.Message:
+    return GetPhoneDataScRsp(
+        retcode=0,
+        cur_chat_bubble=session.player.data.chat_bubble,
+        cur_phone_theme=session.player.data.phone_theme,
+        owned_chat_bubbles=[item.ID for item in ResourceManager.instance().values(ItemConfig) if item.ItemSubType == "ChatBubble"],
+        owned_phone_themes=[item.ID for item in ResourceManager.instance().values(ItemConfig) if item.ItemSubType == "PhoneTheme"]
+    )

game_server/handlers/GetPlayerBoardDataCsReq.py

@@ -0,0 +1,21 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.resource import ResourceManager
+from game_server.resource.configdb.player_icon_config import PlayerIconConfig
+from rail_proto.lib import (
+    GetPlayerBoardDataCsReq,
+    GetPlayerBoardDataScRsp,
+    HeadIconData
+)
+
+async def handle(session: PlayerSession, msg: GetPlayerBoardDataCsReq) -> betterproto.Message:
+    return GetPlayerBoardDataScRsp(
+        retcode=0,
+        current_head_icon_id=session.player.data.head_icon,
+        unlocked_head_icon_list=[
+            HeadIconData(
+                id=icon.ID
+            )
+            for icon in ResourceManager.instance().values(PlayerIconConfig)
+        ]
+    )

game_server/handlers/GetPrivateChatHistoryCsReq.py

@@ -0,0 +1,26 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    GetPrivateChatHistoryCsReq,
+    GetPrivateChatHistoryScRsp,
+    ChatMessageData,
+    MsgType
+)
+
+async def handle(session: PlayerSession, msg: GetPrivateChatHistoryCsReq) -> betterproto.Message:
+    return GetPrivateChatHistoryScRsp(
+        retcode=0,
+        contact_side=msg.contact_side,
+        chat_message_list=[
+            ChatMessageData(
+                message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value,
+                content="No commands available. FUCK OFF!",
+                sender_id=69
+            ),
+            ChatMessageData(
+                message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value,
+                content="Hi....",
+                sender_id=session.player.data.uid
+            )
+        ]
+    )

game_server/handlers/GetSceneMapInfoCsReq.py

@@ -0,0 +1,58 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.resource import ResourceManager
+from game_server.resource.configdb.map_entrance import MapEntranceData
+from game_server.resource.configdb.map_default_entrance import MapDefaultEntranceData
+from rail_proto.lib import (
+    GetSceneMapInfoCsReq,
+    GetSceneMapInfoScRsp,
+    SceneMapInfo,
+    ChestInfo,
+    ChestType,
+    MazeGroup,
+    MazePropState
+)
+
+async def handle(session: PlayerSession, msg: GetSceneMapInfoCsReq) -> betterproto.Message:
+    rsp = GetSceneMapInfoScRsp(retcode=0)
+    for floor_id in msg.floor_id_list:
+        map_default = ResourceManager.instance().find_by_index(MapDefaultEntranceData, floor_id)
+        if not map_default:
+            continue
+
+        data = ResourceManager.instance().find_by_index(MapEntranceData, map_default.EntranceID)
+
+        if not data:
+            continue
+
+        map_info = SceneMapInfo(
+            retcode=0,
+            chest_list=[
+                ChestInfo(chest_type=ChestType.MAP_INFO_CHEST_TYPE_NORMAL.value),
+                ChestInfo(chest_type=ChestType.MAP_INFO_CHEST_TYPE_PUZZLE.value),
+                ChestInfo(chest_type=ChestType.MAP_INFO_CHEST_TYPE_CHALLENGE.value)
+            ],
+            floor_id=floor_id
+        )
+        for i in range(101):
+            map_info.lighten_section_list.append(i)
+
+        level_group = data.floor_infos.get(map_default.EntranceID)
+        if level_group:
+            for group_id,group in level_group.groups.items():
+                maze_group_list = MazeGroup(
+                    group_id=group_id
+                )
+                map_info.maze_group_list.append(maze_group_list)
+                for prop in group.PropList:
+                    maze_prop = MazePropState(
+                        group_id=group_id,
+                        state=8 if prop.MappingInfoID > 0 else (1 if prop.State == 0 else prop.State),
+                        config_id=prop.ID
+                        )
+                    if prop.MappingInfoID > 0:
+                        map_info.unlock_teleport_list.append(prop.MappingInfoID)
+                    map_info.maze_prop_list.append(maze_prop)
+
+        rsp.scene_map_info.append(map_info)
+    return rsp

game_server/handlers/PVEBattleResultCsReq.py

@@ -0,0 +1,37 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    PVEBattleResultCsReq,
+    PVEBattleResultScRsp,
+    BattleEndStatus,
+    SceneGroupRefreshScNotify,
+    GroupRefreshInfo,
+    SceneGroupRefreshType,
+    SceneEntityRefreshInfo
+)
+
+async def handle(session: PlayerSession, msg: PVEBattleResultCsReq) -> betterproto.Message:
+    if msg.end_status == BattleEndStatus.BATTLE_END_WIN.value:
+        await session.notify(
+            SceneGroupRefreshScNotify(
+                group_refresh_list=[
+                    GroupRefreshInfo(
+                        refresh_type=SceneGroupRefreshType.SCENE_GROUP_REFRESH_TYPE_LOADED.value,
+                        refresh_entity=[
+                            SceneEntityRefreshInfo(
+                                delete_entity=monster.entity_id
+                            )
+                        ],
+                        group_id=monster.group_id
+                    ) for monster in session.player.scene_manager.battle_monster
+                ],
+                floor_id=session.player.data.floor_id
+            )
+        )
+        for monster in session.player.scene_manager.battle_monster:
+            session.player.scene_manager.entities.pop(monster.entity_id, None)
+    return PVEBattleResultScRsp(
+        retcode=0,
+        end_status=msg.end_status,
+        battle_id=msg.battle_id
+    )

game_server/handlers/PlayerGetTokenCsReq.py

@@ -0,0 +1,36 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from database.account.account_data import find_account_by_uid
+from database.player.player_data import PlayerData,find_player_by_uid
+from database.lineup.lineup_data import LineupData
+from rail_proto.lib import (
+    PlayerGetTokenCsReq,
+    PlayerGetTokenScRsp
+)
+from game_server.game.player.player_manager import PlayerManager
+
+async def handle(session: PlayerSession, msg: PlayerGetTokenCsReq) -> betterproto.Message:
+    account_uid = int(msg.account_uid)
+    account_data=find_account_by_uid(account_uid)
+    if not account_data:
+        return PlayerGetTokenScRsp(
+            retcode=1003
+        )   
+
+    player_data=find_player_by_uid(account_uid)
+    if not player_data:
+        player_data=PlayerData(uid=account_uid).create_player_data(account_data.username)
+        session.player=PlayerManager(data=player_data)
+        session.player.add_avatar(8001)
+        session.player.add_avatar(1001)
+        session.player.add_lineup([8001])
+        
+    else:
+        session.player=PlayerManager(data=player_data)
+    
+
+    return PlayerGetTokenScRsp(
+        retcode=0,
+        uid=account_uid,
+        msg="OK"
+    )

game_server/handlers/PlayerHeartBeatCsReq.py

@@ -0,0 +1,17 @@
+import betterproto
+import base64
+from game_server.net.session import PlayerSession
+from utils.time import cur_timestamp_ms
+from rail_proto.lib import (
+    PlayerHeartBeatCsReq,
+    PlayerHeartBeatScRsp,
+    ClientDownloadData
+)
+
+async def handle(session: PlayerSession, msg: PlayerHeartBeatCsReq) -> betterproto.Message:
+    return PlayerHeartBeatScRsp(
+        retcode=0,
+        client_time_ms=msg.client_time_ms,
+        server_time_ms=cur_timestamp_ms(),
+        download_data=ClientDownloadData()
+    )

game_server/handlers/PlayerLoginCsReq.py

@@ -0,0 +1,30 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from utils.time import cur_timestamp_ms
+from rail_proto.lib import (
+    PlayerLoginCsReq,
+    PlayerLoginScRsp,
+    PlayerBasicInfo
+)
+import traceback
+
+async def handle(session: PlayerSession, msg: PlayerLoginCsReq) -> betterproto.Message:
+    try:
+        session.player.init_default()
+        return PlayerLoginScRsp(
+            login_random=msg.login_random,
+            server_timestamp_ms=cur_timestamp_ms(),
+            stamina=240,
+            basic_info=PlayerBasicInfo(
+                nickname=session.player.data.name,
+                level=session.player.data.level,
+                exp=session.player.data.exp,
+                stamina=240,
+                mcoin=session.player.data.mcoin,
+                hcoin=session.player.data.hcoin,
+                scoin=session.player.data.scoin,
+                world_level=session.player.data.world_level,
+            )
+        )
+    except:
+        traceback.print_exc()

game_server/handlers/PlayerLoginFinishCsReq.py

@@ -0,0 +1,28 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    PlayerLoginFinishCsReq,
+    PlayerLoginFinishScRsp,
+    ContentPackageSyncDataScNotify,
+    ContentPackageData,
+    ContentPackageInfo,
+    ContentPackageStatus
+)
+
+async def handle(session: PlayerSession, msg: PlayerLoginFinishCsReq) -> betterproto.Message:
+    content = [200001,200002,200003,150017,150015]
+    await session.notify(
+        ContentPackageSyncDataScNotify(
+            data=ContentPackageData(
+                cur_content_id=0,
+                content_package_list=[
+                    ContentPackageInfo(
+                        content_id=id,
+                        status=ContentPackageStatus.ContentPackageStatus_Finished.value
+                    ) for id in content
+                ]
+            )
+        )
+    )
+    session.active = True
+    return PlayerLoginFinishScRsp(retcode=0)

game_server/handlers/RelicRecommendCsReq.py

@@ -0,0 +1,12 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    RelicRecommendCsReq,
+    RelicRecommendScRsp
+)
+
+async def handle(session: PlayerSession, msg: RelicRecommendCsReq) -> betterproto.Message:
+    return RelicRecommendScRsp(
+        retcode=0,
+        avatar_id=msg.avatar_id
+    )

game_server/handlers/ReplaceLineupCsReq.py

@@ -0,0 +1,18 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    ReplaceLineupCsReq,
+    ReplaceLineupScRsp,
+    SyncLineupNotify
+)
+
+async def handle(session: PlayerSession, msg: ReplaceLineupCsReq) -> betterproto.Message:
+    lineup = session.player.lineup_manager.get(msg.index)
+    lineup.avatar_list = [avatar.id for avatar in msg.lineup_slot_list]
+    await session.notify(
+        SyncLineupNotify(
+            lineup=lineup.ToProto()
+        )
+    )
+    #lineup.save_lineup()
+    return ReplaceLineupScRsp(retcode=0)

game_server/handlers/SceneCastSkillCsReq.py

@@ -0,0 +1,63 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.resource import ResourceManager
+from game_server.resource.configdb.stage_config import StageConfig
+from rail_proto.lib import (
+    SceneCastSkillCsReq,
+    SceneCastSkillScRsp,
+    SceneBattleInfo,
+    SceneMonsterWave,
+    SceneMonster
+)
+import numpy as np
+
+async def handle(session: PlayerSession, msg: SceneCastSkillCsReq) -> betterproto.Message:
+    targets = [id for id in msg.assist_monster_entity_id_list if id > 20000 or id < 10]
+    for monster in msg.assist_monster_entity_info:
+        targets.extend(
+            id for id in monster.entity_id_list
+            if id not in targets and (id > 20000 or id < 10)
+        )
+    if msg.skill_index == 0 and targets:
+        monster_data: list[StageConfig] = []
+        for entity_id in targets:
+            entity_data = session.player.scene_manager.entities.get(entity_id)
+            if entity_data:
+                stage = ResourceManager.instance().find_by_index(StageConfig,entity_data.npc_monster.event_id*10)
+                if not stage:
+                    stage = ResourceManager.instance().find_by_index(StageConfig,entity_data.npc_monster.event_id)
+                if stage:
+                    monster_data.append(stage)
+                    session.player.scene_manager.battle_monster.append(entity_data)
+        if monster_data:
+            return SceneCastSkillScRsp(
+                retcode=0,
+                cast_entity_id=msg.cast_entity_id,
+                battle_info=SceneBattleInfo(
+                    rounds_limit=0,
+                    world_level=session.player.data.world_level,
+                    logic_random_seed=np.random.randint(1, np.iinfo(np.int32).max, dtype=np.int32),
+                    stage_id=monster_data[0].StageID,
+                    battle_id=1,
+                    battle_avatar_list=[
+                        session.player.avatar_mananger.get(avatar_id).ToBattleProto(index,session)
+                        for index, avatar_id in enumerate(session.player.lineup_manager.get(session.player.data.cur_lineup, None).avatar_list)
+                    ],
+                    monster_wave_list=[
+                        SceneMonsterWave(
+                            battle_stage_id=monster_list.StageID,
+                            battle_wave_id=index,
+                            monster_list=[
+                                SceneMonster(
+                                    monster_id=id
+                                )
+                                for monster_dict in monster_list.MonsterList
+                                for monster, id in monster_dict.items()
+                                if id > 0
+                            ]
+                        )
+                        for index,monster_list in enumerate(monster_data)
+                    ]
+                )
+            )
+    return SceneCastSkillScRsp(retcode=0)

game_server/handlers/SelectChatBubbleCsReq.py

@@ -0,0 +1,14 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    SelectChatBubbleCsReq,
+    SelectChatBubbleScRsp
+)
+
+async def handle(session: PlayerSession, msg: SelectChatBubbleCsReq) -> betterproto.Message:
+    session.player.data.chat_bubble = msg.bubble_id
+    #session.player.data.save_player_data()
+    return SelectChatBubbleScRsp(
+        retcode=0,
+        cur_chat_bubble=msg.bubble_id
+    )

game_server/handlers/SelectPhoneThemeCsReq.py

@@ -0,0 +1,14 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    SelectPhoneThemeCsReq,
+    SelectPhoneThemeScRsp
+)
+
+async def handle(session: PlayerSession, msg: SelectPhoneThemeCsReq) -> betterproto.Message:
+    session.player.data.chat_bubble = msg.theme_id
+    #session.player.data.save_player_data()
+    return SelectPhoneThemeScRsp(
+        retcode=0,
+        cur_phone_theme=msg.theme_id
+    )

game_server/handlers/SendMsgCsReq.py

@@ -0,0 +1,36 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from game_server.game.chat.command_handler import handler
+from rail_proto.lib import (
+    SendMsgCsReq,
+    SendMsgScRsp,
+    RevcMsgScNotify,
+    MsgType,
+    ChatType
+)
+
+async def handle(session: PlayerSession, msg: SendMsgCsReq) -> betterproto.Message:
+    if msg.message_type == MsgType.MSG_TYPE_CUSTOM_TEXT:
+        session.pending_notify(
+            RevcMsgScNotify(
+                message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value,
+                chat_type=ChatType.CHAT_TYPE_PRIVATE.value,
+                message_text=msg.message_text,
+                target_uid=69,
+                source_uid=session.player.data.uid
+            )
+        )
+        text = await handler.handle_command(session, msg.message_text)
+        if text:
+            session.pending_notify(
+                RevcMsgScNotify(
+                    message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value,
+                    chat_type=ChatType.CHAT_TYPE_PRIVATE.value,
+                    message_text=text,
+                    target_uid=session.player.data.uid,
+                    source_uid=69
+                )
+            )
+    return SendMsgScRsp(
+        retcode=0
+    )

game_server/handlers/SetClientPausedCsReq.py

@@ -0,0 +1,12 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    SetClientPausedCsReq,
+    SetClientPausedScRsp
+)
+
+async def handle(session: PlayerSession, msg: SetClientPausedCsReq) -> betterproto.Message:
+    return SetClientPausedScRsp(
+        retcode=0,
+        paused=msg.paused
+    )

game_server/handlers/SetHeadIconCsReq.py

@@ -0,0 +1,14 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    SetHeadIconCsReq,
+    SetHeadIconScRsp
+)
+
+async def handle(session: PlayerSession, msg: SetHeadIconCsReq) -> betterproto.Message:
+    session.player.data.head_icon = msg.id
+    #session.player.data.save_player_data()
+    return SetHeadIconScRsp(
+        retcode=0,
+        current_head_icon_id=msg.id
+    )

game_server/handlers/SetNicknameCsReq.py

@@ -0,0 +1,15 @@
+import betterproto
+from game_server.net.session import PlayerSession
+from rail_proto.lib import (
+    SetNicknameCsReq,
+    SetNicknameScRsp
+)
+
+async def handle(session: PlayerSession, msg: SetNicknameCsReq) -> betterproto.Message:
+    if msg.is_modify:
+        session.player.data.name = msg.nickname
+        await session.notify(session.player.PlayerSyncProto())
+    return SetNicknameScRsp(
+        retcode=0,
+        is_modify=msg.is_modify
+    )