拆分房间功能和管理到单独文件，并删除control_packets相关代码

steam/steam_room_manager.cpp

@@ -0,0 +1,256 @@
+#include "steam_room_manager.h"
+#include "steam_networking_manager.h"
+#include <iostream>
+#include <algorithm>
+
+SteamFriendsCallbacks::SteamFriendsCallbacks(SteamNetworkingManager *manager) : manager_(manager)
+{
+    std::cout << "SteamFriendsCallbacks constructor called" << std::endl;
+}
+
+void SteamFriendsCallbacks::OnGameRichPresenceJoinRequested(GameRichPresenceJoinRequested_t *pCallback)
+{
+    std::cout << "GameRichPresenceJoinRequested received" << std::endl;
+    if (manager_)
+    {
+        const char *connectStr = pCallback->m_rgchConnect;
+        std::cout << "Connect string: '" << (connectStr ? connectStr : "null") << "'" << std::endl;
+        if (connectStr && connectStr[0] != '\0')
+        {
+            try
+            {
+                uint64 id = std::stoull(connectStr);
+                std::string str = connectStr;
+                std::cout << "Parsed ID: " << id << std::endl;
+                if (str.find("7656119") == 0)
+                {
+                    // It's a Steam ID, join host directly
+                    std::cout << "Parsed Steam ID: " << id << ", joining host" << std::endl;
+                    if (!manager_->isHost() && !manager_->isConnected())
+                    {
+                        manager_->joinHost(id);
+                        // Start TCP Server if dependencies are set
+                        if (manager_->server_ && !(*manager_->server_))
+                        {
+                            *manager_->server_ = std::make_unique<TCPServer>(8888, manager_);
+                            if (!(*manager_->server_)->start())
+                            {
+                                std::cerr << "Failed to start TCP server" << std::endl;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        std::cout << "Already host or connected, ignoring join request" << std::endl;
+                    }
+                }
+                else
+                {
+                    // Assume it's a lobby ID
+                    CSteamID lobbySteamID(id);
+                    std::cout << "Parsed lobby ID: " << id << std::endl;
+                    if (!manager_->isHost() && !manager_->isConnected())
+                    {
+                        std::cout << "Joining lobby from invite: " << id << std::endl;
+                        manager_->joinLobby(lobbySteamID);
+                    }
+                    else
+                    {
+                        std::cout << "Already host or connected, ignoring invite" << std::endl;
+                    }
+                }
+            }
+            catch (const std::exception &e)
+            {
+                std::cerr << "Failed to parse connect string: " << connectStr << " error: " << e.what() << std::endl;
+            }
+        }
+        else
+        {
+            std::cerr << "Empty connect string in join request" << std::endl;
+        }
+    }
+    else
+    {
+        std::cout << "Manager is null" << std::endl;
+    }
+}
+
+void SteamFriendsCallbacks::OnGameLobbyJoinRequested(GameLobbyJoinRequested_t *pCallback)
+{
+    std::cout << "GameLobbyJoinRequested received" << std::endl;
+    if (manager_)
+    {
+        CSteamID lobbyID = pCallback->m_steamIDLobby;
+        std::cout << "Lobby ID: " << lobbyID.ConvertToUint64() << std::endl;
+        if (!manager_->isHost() && !manager_->isConnected())
+        {
+            std::cout << "Joining lobby from request: " << lobbyID.ConvertToUint64() << std::endl;
+            manager_->joinLobby(lobbyID);
+        }
+        else
+        {
+            std::cout << "Already host or connected, ignoring lobby join request" << std::endl;
+        }
+    }
+    else
+    {
+        std::cout << "Manager is null" << std::endl;
+    }
+}
+
+SteamMatchmakingCallbacks::SteamMatchmakingCallbacks(SteamNetworkingManager *manager) : manager_(manager) {}
+
+void SteamMatchmakingCallbacks::OnLobbyCreated(LobbyCreated_t *pCallback)
+{
+    if (pCallback->m_eResult == k_EResultOK)
+    {
+        manager_->roomManager_->setCurrentLobby(pCallback->m_ulSteamIDLobby);
+        std::cout << "Lobby created: " << manager_->roomManager_->getCurrentLobby().ConvertToUint64() << std::endl;
+        // Set Rich Presence with lobby ID
+        std::string lobbyStr = std::to_string(manager_->roomManager_->getCurrentLobby().ConvertToUint64());
+        SteamFriends()->SetRichPresence("connect", lobbyStr.c_str());
+        SteamFriends()->SetRichPresence("status", "主持游戏房间");
+        SteamFriends()->SetRichPresence("steam_display", "#StatusWithConnectFormat");
+        std::cout << "Set Rich Presence connect to: " << lobbyStr << std::endl;
+    }
+    else
+    {
+        std::cerr << "Failed to create lobby" << std::endl;
+    }
+}
+
+void SteamMatchmakingCallbacks::OnLobbyListReceived(LobbyMatchList_t *pCallback)
+{
+    manager_->roomManager_->clearLobbies();
+    for (uint32 i = 0; i < pCallback->m_nLobbiesMatching; ++i)
+    {
+        CSteamID lobbyID = SteamMatchmaking()->GetLobbyByIndex(i);
+        manager_->roomManager_->addLobby(lobbyID);
+    }
+    std::cout << "Received " << pCallback->m_nLobbiesMatching << " lobbies" << std::endl;
+}
+
+void SteamMatchmakingCallbacks::OnLobbyEntered(LobbyEnter_t *pCallback)
+{
+    if (pCallback->m_EChatRoomEnterResponse == k_EChatRoomEnterResponseSuccess)
+    {
+        manager_->roomManager_->setCurrentLobby(pCallback->m_ulSteamIDLobby);
+        std::cout << "Entered lobby: " << pCallback->m_ulSteamIDLobby << std::endl;
+        // Only join host if not the host
+        if (!manager_->isHost())
+        {
+            CSteamID hostID = SteamMatchmaking()->GetLobbyOwner(pCallback->m_ulSteamIDLobby);
+            if (manager_->joinHost(hostID.ConvertToUint64()))
+            {
+                // Start TCP Server if dependencies are set
+                if (manager_->server_ && !(*manager_->server_))
+                {
+                    *manager_->server_ = std::make_unique<TCPServer>(8888, manager_);
+                    if (!(*manager_->server_)->start())
+                    {
+                        std::cerr << "Failed to start TCP server" << std::endl;
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        std::cerr << "Failed to enter lobby" << std::endl;
+    }
+}
+
+SteamRoomManager::SteamRoomManager(SteamNetworkingManager *networkingManager)
+    : networkingManager_(networkingManager), currentLobby(k_steamIDNil),
+      steamFriendsCallbacks(nullptr), steamMatchmakingCallbacks(nullptr)
+{
+    steamFriendsCallbacks = new SteamFriendsCallbacks(networkingManager_);
+    steamMatchmakingCallbacks = new SteamMatchmakingCallbacks(networkingManager_);
+}
+
+SteamRoomManager::~SteamRoomManager()
+{
+    delete steamFriendsCallbacks;
+    delete steamMatchmakingCallbacks;
+}
+
+bool SteamRoomManager::createLobby()
+{
+    SteamAPICall_t hSteamAPICall = SteamMatchmaking()->CreateLobby(k_ELobbyTypePublic, 4);
+    if (hSteamAPICall == k_uAPICallInvalid)
+    {
+        std::cerr << "Failed to create lobby" << std::endl;
+        return false;
+    }
+    // Call result will be handled by callback
+    return true;
+}
+
+void SteamRoomManager::leaveLobby()
+{
+    if (currentLobby != k_steamIDNil)
+    {
+        SteamMatchmaking()->LeaveLobby(currentLobby);
+        currentLobby = k_steamIDNil;
+    }
+}
+
+bool SteamRoomManager::searchLobbies()
+{
+    lobbies.clear();
+    SteamAPICall_t hSteamAPICall = SteamMatchmaking()->RequestLobbyList();
+    if (hSteamAPICall == k_uAPICallInvalid)
+    {
+        std::cerr << "Failed to request lobby list" << std::endl;
+        return false;
+    }
+    // Results will be handled by callback
+    return true;
+}
+
+bool SteamRoomManager::joinLobby(CSteamID lobbyID)
+{
+    if (SteamMatchmaking()->JoinLobby(lobbyID) != k_EResultOK)
+    {
+        std::cerr << "Failed to join lobby" << std::endl;
+        return false;
+    }
+    // Connection will be handled by callback
+    return true;
+}
+
+bool SteamRoomManager::startHosting()
+{
+    if (!createLobby())
+    {
+        return false;
+    }
+
+    networkingManager_->hListenSock = networkingManager_->m_pInterface->CreateListenSocketP2P(0, 0, nullptr);
+
+    if (networkingManager_->hListenSock != k_HSteamListenSocket_Invalid)
+    {
+        networkingManager_->g_isHost = true;
+        std::cout << "Created listen socket for hosting game room" << std::endl;
+        // Rich Presence is set in OnLobbyCreated callback
+        return true;
+    }
+    else
+    {
+        std::cerr << "Failed to create listen socket for hosting" << std::endl;
+        leaveLobby();
+        return false;
+    }
+}
+
+void SteamRoomManager::stopHosting()
+{
+    if (networkingManager_->hListenSock != k_HSteamListenSocket_Invalid)
+    {
+        networkingManager_->m_pInterface->CloseListenSocket(networkingManager_->hListenSock);
+        networkingManager_->hListenSock = k_HSteamListenSocket_Invalid;
+    }
+    leaveLobby();
+    networkingManager_->g_isHost = false;
+}