C++ 网络版斗地主多人在线游戏开发实战

• 主通道走 TCP → 负责核心逻辑（登录、发牌、叫地主）
• 辅通道走 UDP → 负责高频事件（倒计时同步、表情弹幕）

class GameNetwork {
private:
    int tcp_sockfd; // 主通道
    int udp_sockfd; // 辅通道
public:
    void send_critical_cmd(const Command& cmd); // 使用 TCP
    void send_realtime_event(const Event& evt); // 使用 UDP
};

自定义协议设计：让机器之间'说人话'

很多新手喜欢直接发 JSON 字符串，但在高性能服务端这是大忌。真正的工业级做法是设计一套二进制协议，结构清晰、效率高、兼容性强。

协议头部怎么定？

推荐格式：固定头部 + 可变载荷

总共才 13 字节 ，小巧精致！

#pragma pack(push, 1)
struct ProtocolHeader {
    uint16_t magic_number; // 0xAAAA
    uint8_t version;       // 当前版本 1
    uint16_t command_id;   // 操作码
    uint32_t payload_length; // 数据体长度
    uint32_t sequence_id;  // 请求序号
};
#pragma pack(pop)

注意这里的 #pragma pack(1)，它能强制结构体按 1 字节对齐，避免编译器自动填充导致跨平台解析错误。

如何处理粘包拆包？

TCP 是字节流协议，没有消息边界概念。解决办法很简单：基于长度字段分包。

class PacketReader {
private:
    std::vector<char> buffer_;
public:
    void on_data_received(const char* data, size_t len) {
        buffer_.insert(buffer_.end(), data, data + len);
        while (buffer_.size() >= sizeof(ProtocolHeader)) {
            auto* hdr = (ProtocolHeader*)buffer_.data();
            size_t expected_size = sizeof(ProtocolHeader) + hdr->payload_length;
            if (buffer_.size() >= expected_size) {
                process_full_packet(buffer_.data(), expected_size);
                buffer_.erase(buffer_.begin(), buffer_.begin() + expected_size);
            } else {
                break;
            }
        }
    }
};

只要坚持'先读头、再看长、凑够再处理'的原则，就能完美避开粘包坑。

斗地主游戏状态机：规则驱动的状态跃迁

正确的姿势是使用 有限状态机（FSM） 来建模整个游戏生命周期。

每个状态代表一种上下文环境，决定了此时允许做什么、禁止做什么。

例如，在 Bid 状态下，只能处理'叫分'请求；若收到'出牌'指令，直接拒绝即可。

bool GameStateMachine::transitionTo(GameState nextState) {
    auto validTransitions = getValidTransitions(currentState);
    if (std::find(validTransitions.begin(), validTransitions.end(), nextState) != validTransitions.end()) {
        logStateChange(currentState, nextState);
        currentState = nextState;
        notifyObservers();
        return true;
    }
    throw std::invalid_argument("Invalid state transition!");
}

核心算法实现：洗牌、叫地主、出牌识别

洗牌算法

正确的方式是使用 Fisher-Yates Shuffle 算法：

void Deck::shuffle() {
    for (int i = 53; i > 0; --i) {
        std::uniform_int_distribution<int> dist(0, i);
        int j = dist(rng);
        std::swap(cards[i], cards[j]);
    }
}

它的数学证明表明：每种排列出现的概率完全相等，才是真正公平的洗牌。

叫地主逻辑

通常采用三轮叫分制，每人可选 0~3 分，最终分数最高者胜出。若全部弃权，则重新洗牌。

void Game::processBid(int playerId, int score) {
    if (score > currentMaxScore) {
        currentMaxScore = score;
        landlordCandidate = playerId;
    }
    moveToNextBidder();
    if (allPassed() || bidsCompleted()) {
        if (landlordCandidate == -1) {
            restartRound();
        } else {
            assignLandlord(landlordCandidate);
        }
    }
}

出牌组合识别

我们可以定义一个识别结构体：

struct PlayPattern {
    PatternType type;
    int rank;      // 主牌点数
    int length;    // 连续长度
};
PlayPattern recognizePattern(const std::vector<Card>& cards);

压制关系比较规则如下：

记住一句话：除了炸弹和火箭，其他牌都不能跨类型压制。

面向对象建模：Player 与 Game 的职责划分

Player 类

class Player {
private:
    int id;
    std::string name;
    std::vector<Card> handCards;
    bool online;
    bool isLandlord;
    int socketFd;
    std::queue<std::string> msgQueue;
public:
    void addCard(const Card& card);
    bool playCards(const std::vector<Card>& cards, const IRuleChecker* checker);
    bool hasNoCards() const;
    void notify(const std::string& msg);
};

重点在于：手牌私有化，外部不能直接访问；出牌必须经过规则校验器；提供 notify() 接口用于推送消息。

Game 类

class Game {
private:
    GameState state;
    std::array<Player*, 3> players;
    std::unique_ptr<IRuleChecker> ruleChecker;
    Player* currentPlayer;
    Timer turnTimer;
public:
    void onPlayerAction(Player* p, const Action& action);
    void proceedToNextStage();
    void broadcast(const std::string& msg);
};

Game 的任务是管理状态流转、转发玩家行为、触发广播通知、控制倒计时。所有具体规则交给 IRuleChecker 去判断，实现解耦。

多线程与异步 IO：支撑高并发的秘密武器

单线程干不过来！尤其是服务器要同时处理几十甚至上百个房间时。我们需要引入多线程和异步 IO 机制。

为什么要解耦网络 IO 和游戏逻辑？

如果网络收发也在同一个线程，那这条消息就得一直等到 AI 回应才能被读取——用户体验直接崩盘。

解决方案：独立 IO 线程池

void start_io_thread(int client_fd) {
    io_thread_ = std::thread([this, client_fd]() {
        while (true) {
            ssize_t n = recv(client_fd, buffer, sizeof(buffer), 0);
            if (n <= 0) break;
            Message msg = parse(buffer, n);
            {
                std::lock_guard<std::mutex> lock(queue_mutex_);
                message_queue_.push(msg);
            }
        }
    });
}

IO 线程只负责收包入队，主逻辑线程定期消费队列，两者互不干扰。

异步任务

对于耗时较长的操作（如 AI 决策），可以用 std::async 异步执行：

auto future_move = std::async(std::launch::async, [&](){
    return ai_strategy.decide(hand, table);
});
while (!future_move.wait_for(1ms)) {
    handle_user_input();
}
CardCombination move = future_move.get();

既不影响流畅度，又能拿到最终结果。

共享资源保护

多个线程访问同一块内存时，必须加锁：

std::mutex game_mutex;
void Game::broadcast(const std::string& msg) {
    std::lock_guard<std::mutex> lock(game_mutex);
    for (auto* p : players) {
        p->notify(msg);
    }
}

否则可能出现'通知了一半断开'的诡异 bug。建议统一加锁顺序，防止死锁。

进阶：Boost.Asio 构建百万级异步框架

如果追求极致性能，可以考虑使用 Boost.Asio 替代原生 socket。

它基于 Reactor 模式，用一个线程就能管理数千连接。

boost::asio::io_context io;
tcp::acceptor acceptor(io, tcp::endpoint(tcp::v4(), 8080));
acceptor.async_accept([&](error_code ec, tcp::socket socket) {
    if (!ec) {
        std::make_shared<Session>(std::move(socket))->start();
    }
    acceptor.async_accept(...);
});

配合 strand 还能自动序列化回调，彻底告别手动加锁。

安全与容错：打造生产级系统

断线重连机制

玩家掉线后，保留其状态最多 2 分钟：

{
  "session_id": "abc123",
  "reconnect_token": "xyz789",
  "hand_cards": ["S3", "H5", "DK"],
  "last_active": "2025-04-05T10:23:45Z"
}

重新连接时凭 token 恢复身份和手牌，体验无缝衔接。

日志审计系统

所有关键操作记日志，结合 ELK 栈做集中分析，出问题秒定位。

TLS 加密通信

为防止账号被盗、数据被篡改，务必启用 SSL/TLS：

ssl::context ctx(ssl::context::tlsv12);
ctx.use_certificate_file("server.pem", ssl::pem);
ctx.use_private_key_file("key.pem", ssl::pem);
ssl::stream<tcp::socket> secure_sock(io, ctx);

从此告别明文传输，安全等级拉满。

结语

做一个稳定的多人在线游戏，远不止'能连上就行'。它是一整套工程体系的集合：协议设计、状态管理、并发模型、安全机制。而这套体系的核心语言，正是 C++。它给了你足够的底层控制力，又不失高级抽象能力。