1
// KCP 的使用方式（纯算法库，不涉及网络 IO）
2
#include "ikcp.h"
3

4
// 1. 创建 KCP 对象
5
ikcpcb* kcp = ikcp_create(0x1234, user_data);
6

7
// 2. 设置输出回调（KCP 要发数据时调用你的 UDP sendto）
8
ikcp_setoutput(kcp, [](const char* buf, int len, ikcpcb* kcp, void* user) -> int {
9
    return sendto(udp_sock, buf, len, 0, /*...*/);
10
});
11

12
// 3. 收到 UDP 数据时喂给 KCP
13
char buf[1500];
14
int n = recvfrom(udp_sock, buf, sizeof(buf), 0, /*...*/);
15
ikcp_input(kcp, buf, n);
16

17
// 4. 从 KCP 读取可靠有序的数据
18
char data[1024];
19
int len = ikcp_recv(kcp, data, sizeof(data));
20
if (len > 0) {
21
    processGameMessage(data, len);
22
}
23

24
// 5. 发送数据（KCP 自动拆分、排序、重传）
25
ikcp_send(kcp, msg, msg_len);
26

27
// 6. 定时驱动 KCP（通常每 10~20ms 调用一次）
28
ikcp_update(kcp, current_ms);

1
// 简化版可靠发送：序列号 + ACK + 超时重传
2
class ReliableUDP {
3
    struct PendingPacket {
4
        uint32_t seq;
5
        std::vector<uint8_t> data;
6
        std::chrono::steady_clock::time_point send_time;
7
        int retries = 0;
8
    };
9

10
    int _sock;
11
    sockaddr_in _remote;
12
    uint32_t _next_seq = 0;
13
    uint32_t _remote_ack = 0;
14
    std::deque<PendingPacket> _pending;
15
    static constexpr auto RTO = std::chrono::milliseconds(100);
16

17
public:
18
    void sendReliable(const void* data, size_t len) {
19
        // 加上序列号头部
20
        uint32_t seq = _next_seq++;
21
        std::vector<uint8_t> packet(sizeof(seq) + len);
22
        std::memcpy(packet.data(), &seq, sizeof(seq));
23
        std::memcpy(packet.data() + sizeof(seq), data, len);
24

25
        sendto(_sock, packet.data(), packet.size(), 0,
26
               (sockaddr*)&_remote, sizeof(_remote));
27

28
        _pending.push_back({seq, packet,
29
            std::chrono::steady_clock::now()});
30
    }
31

32
    void onAckReceived(uint32_t ack_seq) {
33
        // 移除已确认的包
34
        while (!_pending.empty() && _pending.front().seq <= ack_seq) {
35
            _pending.pop_front();
36
        }
37
    }
38

39
    void tick() {
40
        auto now = std::chrono::steady_clock::now();
41
        for (auto& pkt : _pending) {
42
            if (now - pkt.send_time > RTO) {
43
                // 超时重传
44
                sendto(_sock, pkt.data.data(), pkt.data.size(), 0,
45
                       (sockaddr*)&_remote, sizeof(_remote));
46
                pkt.send_time = now;
47
                pkt.retries++;
48
            }
49
        }
50
    }
51
};