blob: 38cb947774f8ef4c245ee1c3d367a5903482c928 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
#include "NetworkClient.hpp"
#include <easylogging++.h>
#include "Network.hpp"
NetworkClient::NetworkClient(std::string address, unsigned short port, std::string username) {
network = std::make_unique<Network>(address, port);
state = Handshaking;
PacketHandshake handshake;
handshake.protocolVersion = 338;
handshake.serverAddress = address;
handshake.serverPort = port;
handshake.nextState = 2;
network->SendPacket(handshake);
state = Login;
PacketLoginStart loginStart;
loginStart.Username = username;
network->SendPacket(loginStart);
auto packet = network->ReceivePacket(Login);
while (!packet)
packet = network->ReceivePacket(Login);
if (packet->GetPacketId() == PacketNameLoginCB::SetCompression) {
auto compPacket = std::static_pointer_cast<PacketSetCompression>(packet);
LOG(INFO) << "Compression threshold: " << compPacket->Threshold;
compressionThreshold = compPacket->Threshold;
packet.reset();
while (!packet)
packet = network->ReceivePacket(Login, compressionThreshold >= 0);
}
auto response = std::static_pointer_cast<PacketLoginSuccess>(packet);
if (response->Username != username) {
throw std::logic_error("Received username is not sended username: "+response->Username+" != "+username);
}
timeOfLastKeepAlivePacket = std::chrono::steady_clock::now();
state = Play;
}
NetworkClient::~NetworkClient() {
}
std::shared_ptr<Packet> NetworkClient::ReceivePacket() {
if (toReceive.empty())
return std::shared_ptr < Packet > (nullptr);
auto ret = toReceive.front();
toReceive.pop();
return ret;
}
void NetworkClient::SendPacket(std::shared_ptr<Packet> packet) {
toSend.push(packet);
}
void NetworkClient::UpdatePacket() {
while (!toSend.empty()) {
if (toSend.front() != nullptr)
network->SendPacket(*toSend.front(), compressionThreshold);
toSend.pop();
}
auto packet = network->ReceivePacket(state, compressionThreshold >= 0);
if (packet.get() != nullptr) {
if (packet->GetPacketId() != PacketNamePlayCB::KeepAliveCB) {
toReceive.push(packet);
}
else {
timeOfLastKeepAlivePacket = std::chrono::steady_clock::now();
auto packetKeepAlive = std::static_pointer_cast<PacketKeepAliveCB>(packet);
auto packetKeepAliveSB = std::make_shared<PacketKeepAliveSB>(packetKeepAlive->KeepAliveId);
network->SendPacket(*packetKeepAliveSB, compressionThreshold);
}
}
using namespace std::chrono_literals;
if (std::chrono::steady_clock::now() - timeOfLastKeepAlivePacket > 20s) {
auto disconnectPacket = std::make_shared<PacketDisconnectPlay>();
disconnectPacket->Reason = "Timeout: server not respond";
toReceive.push(disconnectPacket);
}
}
|
