说实话……想玩C++ 版本的人直接把python的版本复制交给AI转化成C++不就行了吗

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <random>
#include <algorithm>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

// 存储用户信息，格式：{用户ID: [用户名, 密码, 分数, 关注列表, 粉丝列表]}
std::unordered_map<std::string, std::vector<std::string>> users;
// 存储在线玩家的连接
std::unordered_map<std::string, int> online_players;
// 存储等待匹配的玩家
std::vector<std::string> waiting_players;
// 互斥锁，用于线程安全
std::mutex mtx;

// 生成随机用户 ID
std::string generate_id() {
    static const std::string digits = "0123456789";
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, digits.size() - 1);
    std::string id;
    for (int i = 0; i < 10; ++i) {
        id += digits[dis(gen)];
    }
    return id;
}

// 保存用户信息到文件
void save_users() {
    std::ofstream file("users.txt");
    if (file.is_open()) {
        for (const auto& user : users) {
            const std::string& user_id = user.first;
            const std::vector<std::string>& info = user.second;
            std::string follow_list_str;
            for (size_t i = 0; i < info[3].size(); ++i) {
                if (i > 0) follow_list_str += "|";
                follow_list_str += info[3][i];
            }
            std::string follower_list_str;
            for (size_t i = 0; i < info[4].size(); ++i) {
                if (i > 0) follower_list_str += "|";
                follower_list_str += info[4][i];
            }
            file << user_id << "," << info[0] << "," << info[1] << "," << info[2] << "," << follow_list_str << "," << follower_list_str << "\n";
        }
        file.close();
    }
}

// 从文件加载用户信息
void load_users() {
    std::ifstream file("users.txt");
    if (file.is_open()) {
        std::string line;
        while (std::getline(file, line)) {
            std::vector<std::string> parts;
            std::stringstream ss(line);
            std::string part;
            while (std::getline(ss, part, ',')) {
                parts.push_back(part);
            }
            std::string user_id = parts[0];
            std::string username = parts[1];
            std::string password = parts[2];
            std::string score = parts[3];
            std::vector<std::string> follow_list;
            if (!parts[4].empty()) {
                std::stringstream ss_follow(parts[4]);
                std::string follow;
                while (std::getline(ss_follow, follow, '|')) {
                    follow_list.push_back(follow);
                }
            }
            std::vector<std::string> follower_list;
            if (!parts[5].empty()) {
                std::stringstream ss_follower(parts[5]);
                std::string follower;
                while (std::getline(ss_follower, follower, '|')) {
                    follower_list.push_back(follower);
                }
            }
            users[user_id] = {username, password, score, follow_list, follower_list};
        }
        file.close();
    }
}

// 语言字典
std::unordered_map<std::string, std::unordered_map<std::string, std::string>> LANGUAGES = {
    {"zh", {
        {"register_login_prompt", "1. 注册\n2. 登录\n请选择操作（输入数字）："},
        {"username_exists", "该用户名已被使用，请选择其他用户名。"},
        {"register_success", "注册成功！您的ID为: "},
        {"id_not_found", "该ID不存在，请先注册。"},
        {"password_error", "密码错误，请重新输入。"},
        {"login_success", "登录成功！"},
        {"join_chat", " 加入了聊天！"},
        {"leave_chat", " 离开了聊天！"},
        {"matching", "正在为您匹配对手，请稍候..."},
        {"matched", "已为您匹配到对手: "},
        {"welcome", "欢迎来到恶魔之轮游戏聊天区！"},
        {"invalid_input", "输入无效，请重新输入！"},
        {"game_start", "游戏开始！"},
        {"round_start", "第 %d 轮开始！"},
        {"player_turn", "%s 的回合，请选择操作："},
        {"shoot", "1. 射击"},
        {"use_item", "2. 使用道具"},
        {"skip_round", "3. 跳过本轮"},
        {"shoot_real", "%s 射出实弹，%s 受到 %d 点伤害！"},
        {"shoot_empty", "%s 射出空弹，未造成伤害！"},
        {"item_used", "%s 使用 %s，%s"},
        {"player_wins", "%s 获胜！"},
        {"get_gold", "%s 获得了 %d 枚金币，当前共有 %d 枚金币。"},
        {"shop_prompt", "商店道具及价格："},
        {"shop_item", "%s：%d 枚金币"},
        {"buy_item", "请输入要购买的道具名称（输入 '不买' 退出）："},
        {"not_enough_gold", "金币不足，无法购买！"},
        {"item_bought", "%s 购买了 %s，剩余金币：%d。"},
        {"demon_action", "恶魔行动，随机攻击玩家！"},
        {"minigame_start", "%s 小游戏开始！"},
        {"minigame_result", "%s 小游戏结果：%s"},
        {"no_bullets", "没有子弹了，无法射击！"}
    }},
    {"en", {
        {"register_login_prompt", "1. Register\n2. Login\nPlease select an operation (enter a number): "},
        {"username_exists", "This username is already in use. Please choose another one."},
        {"register_success", "Registration successful! Your ID is: "},
        {"id_not_found", "This ID does not exist. Please register first."},
        {"password_error", "Incorrect password. Please try again."},
        {"login_success", "Login successful!"},
        {"join_chat", " joined the chat!"},
        {"leave_chat", " left the chat!"},
        {"matching", "Matching an opponent for you. Please wait..."},
        {"matched", "You've been matched with: "},
        {"welcome", "Welcome to the Demon's Wheel game chat area!"},
        {"invalid_input", "Invalid input. Please try again!"},
        {"game_start", "Game starts!"},
        {"round_start", "Round %d starts!"},
        {"player_turn", "%s's turn. Please choose an action:"},
        {"shoot", "1. Shoot"},
        {"use_item", "2. Use item"},
        {"skip_round", "3. Skip this round"},
        {"shoot_real", "%s shoots a real bullet. %s takes %d damage!"},
        {"shoot_empty", "%s shoots an empty bullet. No damage!"},
        {"item_used", "%s uses %s. %s"},
        {"player_wins", "%s wins!"},
        {"get_gold", "%s gets %d gold coins. Now has %d gold coins in total."},
        {"shop_prompt", "Shop items and prices:"},
        {"shop_item", "%s: %d gold coins"},
        {"buy_item", "Please enter the name of the item to buy (enter 'No buy' to exit): "},
        {"not_enough_gold", "Not enough gold coins to buy!"},
        {"item_bought", "%s buys %s. Remaining gold coins: %d."},
        {"demon_action", "The demon acts and randomly attacks a player!"},
        {"minigame_start", "%s minigame starts!"},
        {"minigame_result", "%s minigame result: %s"},
        {"no_bullets", "No bullets left. Cannot shoot!"}
    }}
};

// 广播消息给所有在线玩家
void broadcast(const std::string& message, const std::string& lang) {
    std::lock_guard<std::mutex> lock(mtx);
    for (const auto& player : online_players) {
        int socket = player.second;
        if (send(socket, message.c_str(), message.length(), 0) == -1) {
            std::cerr << "Error sending message to " << player.first << std::endl;
        }
    }
}

// 处理客户端连接
void handle_client(int client_socket, sockaddr_in client_address) {
    try {
        // 选择语言
        std::string lang_choice_prompt = "1. 中文\n2. English\n请选择语言 (Enter 1 or 2): ";
        if (send(client_socket, lang_choice_prompt.c_str(), lang_choice_prompt.length(), 0) == -1) {
            std::cerr << "Error sending language choice prompt" << std::endl;
            close(client_socket);
            return;
        }
        char buffer[1024];
        ssize_t bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
        if (bytes_received == -1) {
            std::cerr << "Error receiving language choice" << std::endl;
            close(client_socket);
            return;
        }
        std::string lang_choice(buffer, bytes_received);
        std::string lang = (lang_choice == "1") ? "zh" : "en";

        // 登录或注册
        std::string user_id;
        while (true) {
            std::string prompt = LANGUAGES[lang]["register_login_prompt"];
            if (send(client_socket, prompt.c_str(), prompt.length(), 0) == -1) {
                std::cerr << "Error sending register/login prompt" << std::endl;
                close(client_socket);
                return;
            }
            bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
            if (bytes_received == -1) {
                std::cerr << "Error receiving register/login choice" << std::endl;
                close(client_socket);
                return;
            }
            std::string choice(buffer, bytes_received);
            if (choice == "1") {
                std::string username_prompt = (lang == "zh") ? "请输入要注册的用户名: " : "Please enter a username to register: ";
                if (send(client_socket, username_prompt.c_str(), username_prompt.length(), 0) == -1) {
                    std::cerr << "Error sending username prompt" << std::endl;
                    close(client_socket);
                    return;
                }
                bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
                if (bytes_received == -1) {
                    std::cerr << "Error receiving username" << std::endl;
                    close(client_socket);
                    return;
                }
                std::string username(buffer, bytes_received);
                bool username_exists = false;
                for (const auto& user : users) {
                    if (user.second[0] == username) {
                        username_exists = true;
                        break;
                    }
                }
                if (username_exists) {
                    std::string error_msg = LANGUAGES[lang]["username_exists"];
                    if (send(client_socket, error_msg.c_str(), error_msg.length(), 0) == -1) {
                        std::cerr << "Error sending username exists message" << std::endl;
                        close(client_socket);
                        return;
                    }
                    continue;
                }
                std::string password_prompt = (lang == "zh") ? "请输入密码: " : "Please enter a password: ";
                if (send(client_socket, password_prompt.c_str(), password_prompt.length(), 0) == -1) {
                    std::cerr << "Error sending password prompt" << std::endl;
                    close(client_socket);
                    return;
                }
                bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
                if (bytes_received == -1) {
                    std::cerr << "Error receiving password" << std::endl;
                    close(client_socket);
                    return;
                }
                std::string password(buffer, bytes_received);
                user_id = generate_id();
                users[user_id] = {username, password, "0", {}, {}};
                save_users();
                std::string success_msg = LANGUAGES[lang]["register_success"] + user_id;
                if (send(client_socket, success_msg.c_str(), success_msg.length(), 0) == -1) {
                    std::cerr << "Error sending registration success message" << std::endl;
                    close(client_socket);
                    return;
                }
                break;
            } else if (choice == "2") {
                std::string id_prompt = (lang == "zh") ? "请输入您的ID: " : "Please enter your ID: ";
                if (send(client_socket, id_prompt.c_str(), id_prompt.length(), 0) == -1) {
                    std::cerr << "Error sending ID prompt" << std::endl;
                    close(client_socket);
                    return;
                }
                bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
                if (bytes_received == -1) {
                    std::cerr << "Error receiving ID" << std::endl;
                    close(client_socket);
                    return;
                }
                user_id = std::string(buffer, bytes_received);
                if (users.find(user_id) == users.end()) {
                    std::string error_msg = LANGUAGES[lang]["id_not_found"];
                    if (send(client_socket, error_msg.c_str(), error_msg.length(), 0) == -1) {
                        std::cerr << "Error sending ID not found message" << std::endl;
                        close(client_socket);
                        return;
                    }
                    continue;
                }
                std::string password_prompt = (lang == "zh") ? "请输入密码: " : "Please enter a password: ";
                if (send(client_socket, password_prompt.c_str(), password_prompt.length(), 0) == -1) {
                    std::cerr << "Error sending password prompt" << std::endl;
                    close(client_socket);
                    return;
                }
                bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
                if (bytes_received == -1) {
                    std::cerr << "Error receiving password" << std::endl;
                    close(client_socket);
                    return;
                }
                std::string password(buffer, bytes_received);
                if (password == users[user_id][1]) {
                    std::string success_msg = LANGUAGES[lang]["login_success"];
                    if (send(client_socket, success_msg.c_str(), success_msg.length(), 0) == -1) {
                        std::cerr << "Error sending login success message" << std::endl;
                        close(client_socket);
                        return;
                    }
                    break;
                } else {
                    std::string error_msg = LANGUAGES[lang]["password_error"];
                    if (send(client_socket, error_msg.c_str(), error_msg.length(), 0) == -1) {
                        std::cerr << "Error sending password error message" << std::endl;
                        close(client_socket);
                        return;
                    }
                }
            }
        }

        // 加入在线玩家列表
        {
            std::lock_guard<std::mutex> lock(mtx);
            online_players[user_id] = client_socket;
        }
        std::string username = users[user_id][0];
        std::string join_msg = username + LANGUAGES[lang]["join_chat"];
        broadcast(join_msg, lang);
        std::string welcome_msg = LANGUAGES[lang]["welcome"];
        if (send(client_socket, welcome_msg.c_str(), welcome_msg.length(), 0) == -1) {
            std::cerr << "Error sending welcome message" << std::endl;
            close(client_socket);
            return;
        }

        while (true) {
            bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
            if (bytes_received <= 0) {
                break;
            }
            std::string message(buffer, bytes_received);
            if (message == "!match") {
                {
                    std::lock_guard<std::mutex> lock(mtx);
                    waiting_players.push_back(user_id);
                }
                std::string matching_msg = LANGUAGES[lang]["matching"];
                if (send(client_socket, matching_msg.c_str(), matching_msg.length(), 0) == -1) {
                    std::cerr << "Error sending matching message" << std::endl;
                    close(client_socket);
                    return;
                }
                // match_players(lang);
            } else {
                std::string chat_msg = username + ": " + message;
                broadcast(chat_msg, lang);
            }
        }
    } catch (const std::exception& e) {
        std::cerr << "Error handling client: " << e.what() << std::endl;
    }
    {
        std::lock_guard<std::mutex> lock(mtx);
        if (online_players.find(user_id) != online_players.end()) {
            online_players.erase(user_id);
            std::string username = users[user_id][0];
            std::string leave_msg = username + LANGUAGES[lang]["leave_chat"];
            broadcast(leave_msg, lang);
        }
    }
    close(client_socket);
}

// 匹配玩家
void match_players(const std::string& lang) {
    std::lock_guard<std::mutex> lock(mtx);
    if (waiting_players.size() >= 2) {
        std::string player1_id = waiting_players.front();
        waiting_players.erase(waiting_players.begin());
        std::string player2_id = waiting_players.front();
        waiting_players.erase(waiting_players.begin());
        int player1_socket = online_players[player1_id];
        int player2_socket = online_players[player2_id];
        std::string player1_name = users[player1_id][0];
        std::string player2_name = users[player2_id][0];
        std::string matched_msg1 = LANGUAGES[lang]["matched"] + player2_name;
        std::string matched_msg2 = LANGUAGES[lang]["matched"] + player1_name;
        if (send(player1_socket, matched_msg1.c_str(), matched_msg1.length(), 0) == -1) {
            std::cerr << "Error sending match message to player 1" << std::endl;
        }
        if (send(player2_socket, matched_msg2.c_str(), matched_msg2.length(), 0) == -1) {
            std::cerr << "Error sending match message to player 2" << std::endl;
        }
        // start_game(player1_socket, player2_socket, player1_id, player2_id, lang);
    }
}

// 主函数
int main() {
    load_users();
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        std::cerr << "Error creating socket" << std::endl;
        return 1;
    }
    sockaddr_in server_address;
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = INADDR_ANY;
    server_address.sin_port = htons(8888);
    if (bind(server_socket, (struct sockaddr*)&server_address, sizeof(server_address)) == -1) {
        std::cerr << "Error binding socket" << std::endl;
        close(server_socket);
        return 1;
    }
    if (listen(server_socket, 5) == -1) {
        std::cerr << "Error listening on socket" << std::endl;
        close(server_socket);
        return 1;
    }
    std::cout << "Server is listening on port 8888..." << std::endl;

    while (true) {
        sockaddr_in client_address;
        socklen_t client_address_length = sizeof(client_address);
        int client_socket = accept(server_socket, (struct sockaddr*)&client_address, &client_address_length);
        if (client_socket == -1) {
            std::cerr << "Error accepting client connection" << std::endl;
            continue;
        }
        std::cout << "Accepted connection from " << inet_ntoa(client_address.sin_addr) << ":" << ntohs(client_address.sin_port) << std::endl;
        std::thread client_handler(handle_client, client_socket, client_address);
        client_handler.detach();
    }

    close(server_socket);
    return 0;
}