492 lines
14 KiB
C++
492 lines
14 KiB
C++
#include "steam/steam_networking_manager.h"
|
|
#include "steam/steam_room_manager.h"
|
|
#include "steam/steam_utils.h"
|
|
#include "tcp_server.h"
|
|
#include <GLFW/glfw3.h>
|
|
#include <algorithm>
|
|
#include <boost/asio.hpp>
|
|
#include <cstring>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <imgui.h>
|
|
#include <imgui_impl_glfw.h>
|
|
#include <imgui_impl_opengl3.h>
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#define GLFW_EXPOSE_NATIVE_WIN32
|
|
#include <GLFW/glfw3native.h>
|
|
#else
|
|
#include <signal.h>
|
|
#include <sys/file.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
using boost::asio::ip::tcp;
|
|
|
|
// New variables for multiple connections and TCP clients
|
|
std::vector<HSteamNetConnection> connections;
|
|
std::mutex connectionsMutex; // Add mutex for connections
|
|
int localPort = 0;
|
|
std::unique_ptr<TCPServer> server;
|
|
|
|
#ifdef _WIN32
|
|
// Windows implementation using mutex and shared memory
|
|
HANDLE g_hMutex = nullptr;
|
|
HANDLE g_hMapFile = nullptr;
|
|
HWND *g_pSharedHwnd = nullptr;
|
|
|
|
bool checkSingleInstance() {
|
|
g_hMutex = CreateMutexW(nullptr, FALSE,
|
|
L"Global\\OnlineGameTool_SingleInstance_Mutex");
|
|
if (GetLastError() == ERROR_ALREADY_EXISTS) {
|
|
// Another instance exists, try to find and activate it
|
|
g_hMapFile = OpenFileMappingW(FILE_MAP_READ, FALSE,
|
|
L"Global\\OnlineGameTool_HWND_Share");
|
|
if (g_hMapFile != nullptr) {
|
|
HWND *pHwnd =
|
|
(HWND *)MapViewOfFile(g_hMapFile, FILE_MAP_READ, 0, 0, sizeof(HWND));
|
|
if (pHwnd != nullptr && *pHwnd != nullptr && IsWindow(*pHwnd)) {
|
|
// Restore and bring to front
|
|
if (IsIconic(*pHwnd)) {
|
|
ShowWindow(*pHwnd, SW_RESTORE);
|
|
}
|
|
SetForegroundWindow(*pHwnd);
|
|
UnmapViewOfFile(pHwnd);
|
|
}
|
|
CloseHandle(g_hMapFile);
|
|
}
|
|
if (g_hMutex) {
|
|
CloseHandle(g_hMutex);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Create shared memory for HWND
|
|
g_hMapFile =
|
|
CreateFileMappingW(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0,
|
|
sizeof(HWND), L"Global\\OnlineGameTool_HWND_Share");
|
|
if (g_hMapFile != nullptr) {
|
|
g_pSharedHwnd = (HWND *)MapViewOfFile(g_hMapFile, FILE_MAP_ALL_ACCESS, 0, 0,
|
|
sizeof(HWND));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void storeWindowHandle(GLFWwindow *window) {
|
|
if (g_pSharedHwnd != nullptr) {
|
|
*g_pSharedHwnd = glfwGetWin32Window(window);
|
|
}
|
|
}
|
|
|
|
void cleanupSingleInstance() {
|
|
if (g_pSharedHwnd != nullptr) {
|
|
UnmapViewOfFile(g_pSharedHwnd);
|
|
g_pSharedHwnd = nullptr;
|
|
}
|
|
if (g_hMapFile != nullptr) {
|
|
CloseHandle(g_hMapFile);
|
|
g_hMapFile = nullptr;
|
|
}
|
|
if (g_hMutex != nullptr) {
|
|
CloseHandle(g_hMutex);
|
|
g_hMutex = nullptr;
|
|
}
|
|
}
|
|
|
|
#else
|
|
// Unix/Linux/macOS implementation using file lock and signal
|
|
int g_lockfd = -1;
|
|
std::string g_lockFilePath;
|
|
|
|
void signalHandler(int signum) {
|
|
// Signal received to bring window to front
|
|
std::cout << "Received signal to activate window" << std::endl;
|
|
}
|
|
|
|
bool checkSingleInstance() {
|
|
std::string tempDir;
|
|
#ifdef __APPLE__
|
|
const char *tmpdir = getenv("TMPDIR");
|
|
tempDir = tmpdir ? tmpdir : "/tmp";
|
|
#else
|
|
tempDir = "/tmp";
|
|
#endif
|
|
|
|
g_lockFilePath = tempDir + "/OnlineGameTool.lock";
|
|
|
|
g_lockfd = open(g_lockFilePath.c_str(), O_CREAT | O_RDWR, 0666);
|
|
if (g_lockfd < 0) {
|
|
std::cerr << "Failed to open lock file" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// Try to acquire exclusive lock
|
|
if (flock(g_lockfd, LOCK_EX | LOCK_NB) != 0) {
|
|
// Lock failed, another instance is running
|
|
// Read PID and send signal
|
|
char pidBuf[32];
|
|
ssize_t bytesRead = read(g_lockfd, pidBuf, sizeof(pidBuf) - 1);
|
|
if (bytesRead > 0) {
|
|
pidBuf[bytesRead] = '\0';
|
|
pid_t existingPid = atoi(pidBuf);
|
|
if (existingPid > 0) {
|
|
// Send SIGUSR1 to existing instance
|
|
kill(existingPid, SIGUSR1);
|
|
}
|
|
}
|
|
close(g_lockfd);
|
|
g_lockfd = -1;
|
|
return false;
|
|
}
|
|
|
|
// Write our PID to the lock file
|
|
ftruncate(g_lockfd, 0);
|
|
pid_t myPid = getpid();
|
|
std::string pidStr = std::to_string(myPid);
|
|
write(g_lockfd, pidStr.c_str(), pidStr.length());
|
|
|
|
// Set up signal handler
|
|
signal(SIGUSR1, signalHandler);
|
|
|
|
return true;
|
|
}
|
|
|
|
void storeWindowHandle(GLFWwindow *window) {
|
|
// GLFW doesn't provide a standard way to bring window to front on Unix
|
|
// but we can request attention
|
|
glfwRequestWindowAttention(window);
|
|
}
|
|
|
|
void cleanupSingleInstance() {
|
|
if (g_lockfd >= 0) {
|
|
flock(g_lockfd, LOCK_UN);
|
|
close(g_lockfd);
|
|
g_lockfd = -1;
|
|
unlink(g_lockFilePath.c_str());
|
|
}
|
|
}
|
|
#endif
|
|
|
|
int main() {
|
|
// Check for single instance
|
|
if (!checkSingleInstance()) {
|
|
std::cout << "另一个实例已在运行，正在激活该窗口..." << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
// Initialize Steam API first
|
|
if (!SteamAPI_Init()) {
|
|
std::cerr << "Failed to initialize Steam API" << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
boost::asio::io_context io_context;
|
|
auto work_guard = boost::asio::make_work_guard(io_context);
|
|
std::thread io_thread([&io_context]() { io_context.run(); });
|
|
|
|
// Initialize Steam Networking Manager
|
|
SteamNetworkingManager steamManager;
|
|
if (!steamManager.initialize()) {
|
|
std::cerr << "Failed to initialize Steam Networking Manager" << std::endl;
|
|
SteamAPI_Shutdown();
|
|
return 1;
|
|
}
|
|
|
|
// Initialize Steam Room Manager
|
|
SteamRoomManager roomManager(&steamManager);
|
|
|
|
// Initialize GLFW
|
|
if (!glfwInit()) {
|
|
std::cerr << "Failed to initialize GLFW" << std::endl;
|
|
steamManager.shutdown();
|
|
return -1;
|
|
}
|
|
|
|
#ifdef __APPLE__
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac
|
|
#endif
|
|
|
|
// Create window
|
|
GLFWwindow *window =
|
|
glfwCreateWindow(1280, 720, "在线游戏工具 - 1.0.0", nullptr, nullptr);
|
|
if (!window) {
|
|
std::cerr << "Failed to create GLFW window" << std::endl;
|
|
glfwTerminate();
|
|
cleanupSingleInstance();
|
|
SteamAPI_Shutdown();
|
|
return -1;
|
|
}
|
|
glfwMakeContextCurrent(window);
|
|
glfwSwapInterval(1); // Enable vsync
|
|
|
|
// Store window handle for single instance activation
|
|
storeWindowHandle(window);
|
|
|
|
// Initialize ImGui
|
|
IMGUI_CHECKVERSION();
|
|
ImGui::CreateContext();
|
|
ImGuiIO &io = ImGui::GetIO();
|
|
(void)io;
|
|
// Load Chinese font
|
|
io.Fonts->AddFontFromFileTTF(
|
|
"font.ttf", 18.0f, nullptr,
|
|
io.Fonts->GetGlyphRangesChineseSimplifiedCommon());
|
|
ImGui::StyleColorsDark();
|
|
|
|
// Initialize ImGui backends
|
|
ImGui_ImplGlfw_InitForOpenGL(window, true);
|
|
const char *glsl_version = "#version 130";
|
|
#ifdef __APPLE__
|
|
glsl_version = "#version 150";
|
|
#endif
|
|
ImGui_ImplOpenGL3_Init(glsl_version);
|
|
|
|
// Set message handler dependencies
|
|
steamManager.setMessageHandlerDependencies(io_context, server, localPort);
|
|
steamManager.startMessageHandler();
|
|
|
|
// Steam Networking variables
|
|
bool isHost = false;
|
|
bool isClient = false;
|
|
char joinBuffer[256] = "";
|
|
char filterBuffer[256] = "";
|
|
|
|
// Lambda to get connection info for a member
|
|
auto getMemberConnectionInfo =
|
|
[&](const CSteamID &memberID,
|
|
const CSteamID &hostSteamID) -> std::pair<int, std::string> {
|
|
int ping = 0;
|
|
std::string relayInfo = "-";
|
|
|
|
if (steamManager.isHost()) {
|
|
// Find connection for this member
|
|
std::lock_guard<std::mutex> lockConn(connectionsMutex);
|
|
for (const auto &conn : steamManager.getConnections()) {
|
|
SteamNetConnectionInfo_t info;
|
|
if (steamManager.getInterface()->GetConnectionInfo(conn, &info)) {
|
|
if (info.m_identityRemote.GetSteamID() == memberID) {
|
|
ping = steamManager.getConnectionPing(conn);
|
|
relayInfo = steamManager.getConnectionRelayInfo(conn);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Client only shows ping to host, not to other clients
|
|
if (memberID == hostSteamID) {
|
|
ping = steamManager.getHostPing();
|
|
if (steamManager.getConnection() != k_HSteamNetConnection_Invalid) {
|
|
relayInfo =
|
|
steamManager.getConnectionRelayInfo(steamManager.getConnection());
|
|
}
|
|
}
|
|
}
|
|
|
|
return {ping, relayInfo};
|
|
};
|
|
|
|
// Lambda to render invite friends UI
|
|
auto renderInviteFriends = [&]() {
|
|
ImGui::InputText("过滤朋友", filterBuffer, IM_ARRAYSIZE(filterBuffer));
|
|
ImGui::Text("朋友:");
|
|
for (const auto &friendPair : SteamUtils::getFriendsList()) {
|
|
std::string nameStr = friendPair.second;
|
|
std::string filterStr(filterBuffer);
|
|
// Convert to lowercase for case-insensitive search
|
|
std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(),
|
|
::tolower);
|
|
std::transform(filterStr.begin(), filterStr.end(), filterStr.begin(),
|
|
::tolower);
|
|
if (filterStr.empty() || nameStr.find(filterStr) != std::string::npos) {
|
|
ImGui::PushID(friendPair.first.ConvertToUint64());
|
|
if (ImGui::Button(("邀请 " + friendPair.second).c_str())) {
|
|
// Send invite via Steam to lobby
|
|
if (SteamMatchmaking()) {
|
|
SteamMatchmaking()->InviteUserToLobby(roomManager.getCurrentLobby(),
|
|
friendPair.first);
|
|
std::cout << "Sent lobby invite to " << friendPair.second
|
|
<< std::endl;
|
|
} else {
|
|
std::cerr << "SteamMatchmaking() is null! Cannot send invite."
|
|
<< std::endl;
|
|
}
|
|
}
|
|
ImGui::PopID();
|
|
}
|
|
}
|
|
};
|
|
|
|
// Frame rate limiting
|
|
const double targetFrameTimeForeground = 1.0 / 60.0; // 60 FPS when focused
|
|
const double targetFrameTimeBackground = 1.0; // 1 FPS when in background
|
|
double lastFrameTime = glfwGetTime();
|
|
|
|
// Main loop
|
|
while (!glfwWindowShouldClose(window)) {
|
|
// Frame rate control based on window focus
|
|
bool isFocused = glfwGetWindowAttrib(window, GLFW_FOCUSED);
|
|
double targetFrameTime =
|
|
isFocused ? targetFrameTimeForeground : targetFrameTimeBackground;
|
|
|
|
double currentTime = glfwGetTime();
|
|
double deltaTime = currentTime - lastFrameTime;
|
|
if (deltaTime < targetFrameTime) {
|
|
std::this_thread::sleep_for(
|
|
std::chrono::duration<double>(targetFrameTime - deltaTime));
|
|
}
|
|
lastFrameTime = glfwGetTime();
|
|
|
|
// Poll events
|
|
glfwPollEvents();
|
|
|
|
SteamAPI_RunCallbacks();
|
|
|
|
// Update Steam networking info
|
|
steamManager.update();
|
|
|
|
// Start ImGui frame
|
|
ImGui_ImplOpenGL3_NewFrame();
|
|
ImGui_ImplGlfw_NewFrame();
|
|
ImGui::NewFrame();
|
|
|
|
// Create a window for online game tool
|
|
ImGui::Begin("在线游戏工具");
|
|
if (server) {
|
|
ImGui::Text("TCP服务器监听端口8888");
|
|
ImGui::Text("已连接客户端: %d", server->getClientCount());
|
|
}
|
|
ImGui::Separator();
|
|
|
|
if (!steamManager.isHost() && !steamManager.isConnected()) {
|
|
if (ImGui::Button("主持游戏房间")) {
|
|
roomManager.startHosting();
|
|
}
|
|
ImGui::InputText("房间ID", joinBuffer, IM_ARRAYSIZE(joinBuffer));
|
|
if (ImGui::Button("加入游戏房间")) {
|
|
uint64 hostID = std::stoull(joinBuffer);
|
|
if (steamManager.joinHost(hostID)) {
|
|
// Start TCP Server
|
|
server = std::make_unique<TCPServer>(8888, &steamManager);
|
|
if (!server->start()) {
|
|
std::cerr << "Failed to start TCP server" << std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (steamManager.isHost() || steamManager.isConnected()) {
|
|
ImGui::Text(steamManager.isHost() ? "正在主持游戏房间。邀请朋友!"
|
|
: "已连接到游戏房间。邀请朋友!");
|
|
ImGui::Separator();
|
|
if (ImGui::Button("断开连接")) {
|
|
roomManager.leaveLobby();
|
|
steamManager.disconnect();
|
|
if (server) {
|
|
server->stop();
|
|
server.reset();
|
|
}
|
|
}
|
|
if (steamManager.isHost()) {
|
|
ImGui::InputInt("本地端口", &localPort);
|
|
}
|
|
ImGui::Separator();
|
|
renderInviteFriends();
|
|
}
|
|
|
|
ImGui::End();
|
|
|
|
// Room status window - only show when hosting or connected
|
|
if ((steamManager.isHost() || steamManager.isConnected()) &&
|
|
roomManager.getCurrentLobby().IsValid()) {
|
|
ImGui::Begin("房间状态");
|
|
ImGui::Text("用户列表:");
|
|
if (ImGui::BeginTable("UserTable", 3,
|
|
ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
|
|
ImGui::TableSetupColumn("名称");
|
|
ImGui::TableSetupColumn("延迟 (ms)");
|
|
ImGui::TableSetupColumn("连接类型");
|
|
ImGui::TableHeadersRow();
|
|
{
|
|
std::vector<CSteamID> members = roomManager.getLobbyMembers();
|
|
CSteamID mySteamID = SteamUser()->GetSteamID();
|
|
CSteamID hostSteamID = steamManager.getHostSteamID();
|
|
for (const auto &memberID : members) {
|
|
ImGui::TableNextRow();
|
|
ImGui::TableNextColumn();
|
|
const char *name = SteamFriends()->GetFriendPersonaName(memberID);
|
|
ImGui::Text("%s", name);
|
|
ImGui::TableNextColumn();
|
|
|
|
if (memberID == mySteamID) {
|
|
ImGui::Text("-");
|
|
ImGui::TableNextColumn();
|
|
ImGui::Text("-");
|
|
} else {
|
|
auto [ping, relayInfo] =
|
|
getMemberConnectionInfo(memberID, hostSteamID);
|
|
|
|
if (relayInfo != "-") {
|
|
ImGui::Text("%d", ping);
|
|
} else {
|
|
ImGui::Text("-");
|
|
}
|
|
ImGui::TableNextColumn();
|
|
ImGui::Text("%s", relayInfo.c_str());
|
|
}
|
|
}
|
|
}
|
|
ImGui::EndTable();
|
|
}
|
|
ImGui::End();
|
|
}
|
|
|
|
// Rendering
|
|
ImGui::Render();
|
|
int display_w, display_h;
|
|
glfwGetFramebufferSize(window, &display_w, &display_h);
|
|
glViewport(0, 0, display_w, display_h);
|
|
glClearColor(0.45f, 0.55f, 0.60f, 1.00f);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
|
|
|
|
// Swap buffers
|
|
glfwSwapBuffers(window);
|
|
}
|
|
|
|
// Stop message handler
|
|
steamManager.stopMessageHandler();
|
|
|
|
// Cleanup
|
|
if (server) {
|
|
server->stop();
|
|
}
|
|
|
|
// Stop io_context and join thread
|
|
work_guard.reset();
|
|
io_context.stop();
|
|
if (io_thread.joinable()) {
|
|
io_thread.join();
|
|
}
|
|
|
|
ImGui_ImplOpenGL3_Shutdown();
|
|
ImGui_ImplGlfw_Shutdown();
|
|
ImGui::DestroyContext();
|
|
glfwDestroyWindow(window);
|
|
glfwTerminate();
|
|
steamManager.shutdown();
|
|
|
|
// Cleanup single instance resources
|
|
cleanupSingleInstance();
|
|
|
|
return 0;
|
|
} |