1 #include "ChunkReceiver.hpp"
2 #include "ChunkTransmission.hpp"
4 #include "NetworkedInput.hpp"
6 #include "../app/init.hpp"
7 #include "../geometry/distance.hpp"
8 #include "../io/WorldSave.hpp"
9 #include "../net/Packet.hpp"
10 #include "../world/Chunk.hpp"
11 #include "../world/ChunkStore.hpp"
12 #include "../world/Player.hpp"
13 #include "../world/World.hpp"
17 #include <glm/gtx/io.hpp>
26 ChunkReceiver::ChunkReceiver(Client &client, ChunkStore &store, const WorldSave &save)
35 ChunkReceiver::~ChunkReceiver() {
39 void ChunkReceiver::Update(int dt) {
41 for (ChunkTransmission &trans : transmissions) {
42 if (trans.active && (timer.Elapsed() - trans.last_update) > timer.Interval()) {
43 cout << "timeout for transmission of chunk " << trans.coords << endl;
44 if (trans.header_received) {
45 client.SendChunkRequest(trans.coords);
47 trans.last_update = timer.Elapsed();
54 if (transmissions.size() > 3) {
55 for (auto iter = transmissions.begin(), end = transmissions.end(); iter != end; ++iter) {
57 transmissions.erase(iter);
66 int ChunkReceiver::ToLoad() const noexcept {
67 return store.EstimateMissing();
70 void ChunkReceiver::LoadOne() {
71 if (!store.HasMissing()) return;
73 ExactLocation::Coarse pos = store.NextMissing();
74 Chunk *chunk = store.Allocate(pos);
76 // chunk store corrupted?
80 if (save.Exists(pos)) {
85 void ChunkReceiver::LoadN(size_t n) {
86 size_t end = min(n, size_t(ToLoad()));
87 for (size_t i = 0; i < end && store.HasMissing(); ++i) {
92 void ChunkReceiver::StoreN(size_t n) {
94 for (Chunk &chunk : store) {
95 if (chunk.ShouldUpdateSave()) {
106 void ChunkReceiver::Handle(const Packet::ChunkBegin &pack) {
108 pack.ReadTransmissionId(id);
109 ChunkTransmission &trans = GetTransmission(id);
110 pack.ReadFlags(trans.flags);
111 pack.ReadChunkCoords(trans.coords);
112 pack.ReadDataSize(trans.data_size);
113 trans.last_update = timer.Elapsed();
114 trans.header_received = true;
118 void ChunkReceiver::Handle(const Packet::ChunkData &pack) {
119 uint32_t id, pos, size;
120 pack.ReadTransmissionId(id);
121 pack.ReadDataOffset(pos);
122 if (pos >= sizeof(ChunkTransmission::buffer)) {
123 cout << "received chunk data offset outside of buffer size" << endl;
126 pack.ReadDataSize(size);
127 ChunkTransmission &trans = GetTransmission(id);
128 size_t len = min(size_t(size), sizeof(ChunkTransmission::buffer) - pos);
129 pack.ReadData(&trans.buffer[pos], len);
130 // TODO: this method breaks when a packet arrives twice
131 trans.data_received += len;
132 trans.last_update = timer.Elapsed();
136 ChunkTransmission &ChunkReceiver::GetTransmission(uint32_t id) {
137 // search for ongoing
138 for (ChunkTransmission &trans : transmissions) {
139 if (trans.active && trans.id == id) {
144 for (ChunkTransmission &trans : transmissions) {
152 transmissions.emplace_back();
153 transmissions.back().active = true;
154 transmissions.back().id = id;
155 return transmissions.back();
158 void ChunkReceiver::Commit(ChunkTransmission &trans) {
159 if (!trans.Complete()) return;
161 Chunk *chunk = store.Allocate(trans.coords);
163 // chunk no longer of interest, just drop the data
164 // it should probably be cached to disk, but not now :P
169 const Byte *src = &trans.buffer[0];
170 uLong src_len = min(size_t(trans.data_size), sizeof(ChunkTransmission::buffer));
171 Byte *dst = reinterpret_cast<Byte *>(chunk->BlockData());
172 uLong dst_len = Chunk::BlockSize();
174 if (trans.Compressed()) {
175 if (uncompress(dst, &dst_len, src, src_len) != Z_OK) {
177 cout << "got corruped chunk data for " << trans.coords << endl;
178 client.SendChunkRequest(trans.coords);
180 // chunk data can, and probably will, contain invalid block IDs, so
181 // zero it to be safe
182 memset(dst, 0, dst_len);
186 memcpy(dst, src, min(src_len, dst_len));
193 ChunkTransmission::ChunkTransmission()
200 , header_received(false)
206 void ChunkTransmission::Reset() noexcept {
210 header_received = false;
213 void ChunkTransmission::Clear() noexcept {
218 bool ChunkTransmission::Complete() const noexcept {
219 return header_received && data_received == data_size;
222 bool ChunkTransmission::Compressed() const noexcept {
229 UDPsocket client_bind(Uint16 port) {
230 UDPsocket sock = SDLNet_UDP_Open(port);
232 throw NetError("SDLNet_UDP_Open");
237 IPaddress client_resolve(const char *host, Uint16 port) {
239 if (SDLNet_ResolveHost(&addr, host, port) != 0) {
240 throw NetError("SDLNet_ResolveHost");
247 Client::Client(const Config::Network &conf)
248 : conn(client_resolve(conf.host.c_str(), conf.port))
249 , client_sock(client_bind(0))
250 , client_pack{ -1, nullptr, 0 } {
251 client_pack.data = new Uint8[sizeof(Packet)];
252 client_pack.maxlen = sizeof(Packet);
253 // establish connection
258 delete[] client_pack.data;
259 SDLNet_UDP_Close(client_sock);
263 void Client::Handle() {
264 int result = SDLNet_UDP_Recv(client_sock, &client_pack);
266 HandlePacket(client_pack);
267 result = SDLNet_UDP_Recv(client_sock, &client_pack);
270 // a boo boo happened
271 throw NetError("SDLNet_UDP_Recv");
275 void Client::HandlePacket(const UDPpacket &udp_pack) {
276 if (!conn.Matches(udp_pack.address)) {
277 // packet came from somewhere else, drop
280 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
281 if (pack.header.tag != Packet::TAG) {
282 // mistagged packet, drop
286 conn.Received(udp_pack);
289 void Client::Update(int dt) {
291 if (conn.ShouldPing()) {
296 uint16_t Client::SendPing() {
297 return conn.SendPing(client_pack, client_sock);
300 uint16_t Client::SendLogin(const string &name) {
301 auto pack = Packet::Make<Packet::Login>(client_pack);
302 pack.WritePlayerName(name);
303 return conn.Send(client_pack, client_sock);
306 uint16_t Client::SendPlayerUpdate(
307 const EntityState &prediction,
308 const glm::vec3 &movement,
314 auto pack = Packet::Make<Packet::PlayerUpdate>(client_pack);
315 pack.WritePredictedState(prediction);
316 pack.WriteMovement(movement);
317 pack.WriteActions(actions);
318 pack.WriteSlot(slot);
319 return conn.Send(client_pack, client_sock);
322 uint16_t Client::SendPart() {
323 Packet::Make<Packet::Part>(client_pack);
324 return conn.Send(client_pack, client_sock);
327 uint16_t Client::SendChunkRequest(
328 const glm::ivec3 &coords
330 auto pack = Packet::Make<Packet::ChunkBegin>(client_pack);
331 pack.WriteChunkCoords(coords);
332 return conn.Send(client_pack, client_sock);
335 uint16_t Client::SendMessage(
340 auto pack = Packet::Make<Packet::Message>(client_pack);
341 pack.WriteType(type);
342 pack.WriteReferral(ref);
343 pack.WriteMessage(msg);
344 client_pack.len = sizeof(Packet::Header) + Packet::Message::GetSize(msg);
345 return conn.Send(client_pack, client_sock);
348 NetworkedInput::NetworkedInput(World &world, Player &player, Client &client)
349 : PlayerController(world, player)
358 bool NetworkedInput::UpdateImportant() const noexcept {
359 return old_actions != actions || !iszero(old_movement - GetMovement());
362 void NetworkedInput::Update(Entity &, float dt) {
367 void NetworkedInput::PushPlayerUpdate(int dt) {
368 const EntityState &state = GetPlayer().GetEntity().GetState();
370 uint16_t packet = client.SendPlayerUpdate(
378 if (player_hist.size() < 16) {
379 player_hist.emplace_back(state, GetMovement(), dt * 0.001f, packet);
381 auto entry = player_hist.begin();
382 entry->state = state;
383 entry->movement = GetMovement();
384 entry->delta_t = dt * 0.001f;
385 entry->packet = packet;
386 player_hist.splice(player_hist.end(), player_hist, entry);
388 old_movement = GetMovement();
389 old_actions = actions;
392 void NetworkedInput::MergePlayerCorrection(uint16_t seq, const EntityState &corrected_state) {
393 if (player_hist.empty()) return;
395 auto entry = player_hist.begin();
396 auto end = player_hist.end();
398 // we may have received an older packet
399 int pack_diff = int16_t(seq) - int16_t(entry->packet);
401 // indeed we have, just ignore it
405 // drop anything older than the fix
406 while (entry != end) {
407 pack_diff = int16_t(seq) - int16_t(entry->packet);
409 entry = player_hist.erase(entry);
415 glm::vec3 restore_movement(GetMovement());
417 EntityState player_state = GetPlayer().GetEntity().GetState();
418 Entity replay(GetPlayer().GetEntity());
419 replay.SetState(corrected_state);
422 entry->state.pos = replay.GetState().pos;
426 vector<WorldCollision> col;
427 while (entry != end) {
428 SetMovement(entry->movement);
429 GetWorld().Update(replay, entry->delta_t);
430 entry->state.pos = replay.GetState().pos;
434 glm::vec3 displacement(replay.GetState().Diff(player_state));
435 const float disp_squared = dot(displacement, displacement);
437 if (disp_squared < 16.0f * numeric_limits<float>::epsilon()) {
438 SetMovement(restore_movement);
442 // if offset > 10cm, warp the player
443 // otherwise, move at most 1cm per frame towards
444 // the fixed position (160ms, so shouldn't be too noticeable)
445 constexpr float warp_thresh = 0.01f; // (1/10)^2
446 constexpr float max_disp = 0.0001f; // (1/100)^2
448 if (disp_squared > warp_thresh) {
449 player_state.pos = replay.GetState().pos;
450 } else if (disp_squared < max_disp) {
451 player_state.pos.block += displacement;
453 displacement *= 0.01f / sqrt(disp_squared);
454 player_state.pos.block += displacement;
456 GetPlayer().GetEntity().SetState(player_state);
457 SetMovement(restore_movement);
460 void NetworkedInput::StartPrimaryAction() {
464 void NetworkedInput::StopPrimaryAction() {
468 void NetworkedInput::StartSecondaryAction() {
472 void NetworkedInput::StopSecondaryAction() {
476 void NetworkedInput::StartTertiaryAction() {
480 void NetworkedInput::StopTertiaryAction() {