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(ChunkStore &store, const WorldSave &save)
34 ChunkReceiver::~ChunkReceiver() {
38 void ChunkReceiver::Update(int dt) {
40 for (ChunkTransmission &trans : transmissions) {
41 if (trans.active && (timer.Elapsed() - trans.last_update) > timer.Interval()) {
42 cout << "timeout for transmission of chunk " << trans.coords << endl;
46 if (transmissions.size() > 3) {
47 for (auto iter = transmissions.begin(), end = transmissions.end(); iter != end; ++iter) {
49 transmissions.erase(iter);
58 int ChunkReceiver::ToLoad() const noexcept {
59 return store.EstimateMissing();
62 void ChunkReceiver::LoadOne() {
63 if (!store.HasMissing()) return;
65 Chunk::Pos pos = store.NextMissing();
66 Chunk *chunk = store.Allocate(pos);
68 // chunk store corrupted?
72 if (save.Exists(pos)) {
77 void ChunkReceiver::LoadN(size_t n) {
78 size_t end = min(n, size_t(ToLoad()));
79 for (size_t i = 0; i < end && store.HasMissing(); ++i) {
84 void ChunkReceiver::StoreN(size_t n) {
86 for (Chunk &chunk : store) {
87 if (chunk.ShouldUpdateSave()) {
98 void ChunkReceiver::Handle(const Packet::ChunkBegin &pack) {
100 pack.ReadTransmissionId(id);
101 ChunkTransmission &trans = GetTransmission(id);
102 pack.ReadFlags(trans.flags);
103 pack.ReadChunkCoords(trans.coords);
104 pack.ReadDataSize(trans.data_size);
105 trans.last_update = timer.Elapsed();
106 trans.header_received = true;
110 void ChunkReceiver::Handle(const Packet::ChunkData &pack) {
111 uint32_t id, pos, size;
112 pack.ReadTransmissionId(id);
113 pack.ReadDataOffset(pos);
114 if (pos >= sizeof(ChunkTransmission::buffer)) {
115 cout << "received chunk data offset outside of buffer size" << endl;
118 pack.ReadDataSize(size);
119 ChunkTransmission &trans = GetTransmission(id);
120 size_t len = min(size_t(size), sizeof(ChunkTransmission::buffer) - pos);
121 pack.ReadData(&trans.buffer[pos], len);
122 // TODO: this method breaks when a packet arrives twice
123 trans.data_received += len;
124 trans.last_update = timer.Elapsed();
128 ChunkTransmission &ChunkReceiver::GetTransmission(uint32_t id) {
129 // search for ongoing
130 for (ChunkTransmission &trans : transmissions) {
131 if (trans.active && trans.id == id) {
136 for (ChunkTransmission &trans : transmissions) {
144 transmissions.emplace_back();
145 transmissions.back().active = true;
146 transmissions.back().id = id;
147 return transmissions.back();
150 void ChunkReceiver::Commit(ChunkTransmission &trans) {
151 if (!trans.Complete()) return;
153 Chunk *chunk = store.Allocate(trans.coords);
155 // chunk no longer of interes, just drop the data
156 // it should probably be cached to disk, but not now :P
161 const Byte *src = &trans.buffer[0];
162 uLong src_len = min(size_t(trans.data_size), sizeof(ChunkTransmission::buffer));
163 Byte *dst = reinterpret_cast<Byte *>(chunk->BlockData());
164 uLong dst_len = Chunk::BlockSize();
166 if (trans.Compressed()) {
167 if (uncompress(dst, &dst_len, src, src_len) != Z_OK) {
169 cout << "got corruped chunk data for " << trans.coords << endl;
172 memcpy(dst, src, min(src_len, dst_len));
178 ChunkTransmission::ChunkTransmission()
185 , header_received(false)
191 void ChunkTransmission::Clear() noexcept {
195 header_received = false;
199 bool ChunkTransmission::Complete() const noexcept {
200 return header_received && data_received == data_size;
203 bool ChunkTransmission::Compressed() const noexcept {
210 UDPsocket client_bind(Uint16 port) {
211 UDPsocket sock = SDLNet_UDP_Open(port);
213 throw NetError("SDLNet_UDP_Open");
218 IPaddress client_resolve(const char *host, Uint16 port) {
220 if (SDLNet_ResolveHost(&addr, host, port) != 0) {
221 throw NetError("SDLNet_ResolveHost");
228 Client::Client(const Config::Network &conf)
229 : conn(client_resolve(conf.host.c_str(), conf.port))
230 , client_sock(client_bind(0))
231 , client_pack{ -1, nullptr, 0 } {
232 client_pack.data = new Uint8[sizeof(Packet)];
233 client_pack.maxlen = sizeof(Packet);
234 // establish connection
239 delete[] client_pack.data;
240 SDLNet_UDP_Close(client_sock);
244 void Client::Handle() {
245 int result = SDLNet_UDP_Recv(client_sock, &client_pack);
247 HandlePacket(client_pack);
248 result = SDLNet_UDP_Recv(client_sock, &client_pack);
251 // a boo boo happened
252 throw NetError("SDLNet_UDP_Recv");
256 void Client::HandlePacket(const UDPpacket &udp_pack) {
257 if (!conn.Matches(udp_pack.address)) {
258 // packet came from somewhere else, drop
261 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
262 if (pack.header.tag != Packet::TAG) {
263 // mistagged packet, drop
267 conn.Received(udp_pack);
270 void Client::Update(int dt) {
272 if (conn.ShouldPing()) {
277 uint16_t Client::SendPing() {
278 return conn.SendPing(client_pack, client_sock);
281 uint16_t Client::SendLogin(const string &name) {
282 auto pack = Packet::Make<Packet::Login>(client_pack);
283 pack.WritePlayerName(name);
284 return conn.Send(client_pack, client_sock);
287 uint16_t Client::SendPlayerUpdate(
288 const EntityState &prediction,
289 const glm::vec3 &movement,
295 auto pack = Packet::Make<Packet::PlayerUpdate>(client_pack);
296 pack.WritePredictedState(prediction);
297 pack.WriteMovement(movement);
298 pack.WriteActions(actions);
299 pack.WriteSlot(slot);
300 return conn.Send(client_pack, client_sock);
303 uint16_t Client::SendPart() {
304 Packet::Make<Packet::Part>(client_pack);
305 return conn.Send(client_pack, client_sock);
308 uint16_t Client::SendMessage(
313 auto pack = Packet::Make<Packet::Message>(client_pack);
314 pack.WriteType(type);
315 pack.WriteReferral(ref);
316 pack.WriteMessage(msg);
317 client_pack.len = sizeof(Packet::Header) + Packet::Message::GetSize(msg);
318 return conn.Send(client_pack, client_sock);
321 NetworkedInput::NetworkedInput(World &world, Player &player, Client &client)
322 : PlayerController(world, player)
331 bool NetworkedInput::UpdateImportant() const noexcept {
332 return old_actions != actions || !iszero(old_movement - GetMovement());
335 void NetworkedInput::Update(Entity &, float dt) {
340 void NetworkedInput::PushPlayerUpdate(int dt) {
341 const EntityState &state = GetPlayer().GetEntity().GetState();
343 uint16_t packet = client.SendPlayerUpdate(
351 if (player_hist.size() < 16) {
352 player_hist.emplace_back(state, GetMovement(), dt * 0.001f, packet);
354 auto entry = player_hist.begin();
355 entry->state = state;
356 entry->movement = GetMovement();
357 entry->delta_t = dt * 0.001f;
358 entry->packet = packet;
359 player_hist.splice(player_hist.end(), player_hist, entry);
361 old_movement = GetMovement();
362 old_actions = actions;
365 void NetworkedInput::MergePlayerCorrection(uint16_t seq, const EntityState &corrected_state) {
366 if (player_hist.empty()) return;
368 auto entry = player_hist.begin();
369 auto end = player_hist.end();
371 // we may have received an older packet
372 int pack_diff = int16_t(seq) - int16_t(entry->packet);
374 // indeed we have, just ignore it
378 // drop anything older than the fix
379 while (entry != end) {
380 pack_diff = int16_t(seq) - int16_t(entry->packet);
382 entry = player_hist.erase(entry);
388 glm::vec3 restore_movement(GetMovement());
390 EntityState player_state = GetPlayer().GetEntity().GetState();
391 Entity replay(GetPlayer().GetEntity());
392 replay.SetState(corrected_state);
395 entry->state.chunk_pos = replay.GetState().chunk_pos;
396 entry->state.block_pos = replay.GetState().block_pos;
400 vector<WorldCollision> col;
401 while (entry != end) {
402 SetMovement(entry->movement);
403 GetWorld().Update(replay, entry->delta_t);
404 entry->state.chunk_pos = replay.GetState().chunk_pos;
405 entry->state.block_pos = replay.GetState().block_pos;
409 glm::vec3 displacement(replay.GetState().Diff(player_state));
410 const float disp_squared = dot(displacement, displacement);
412 if (disp_squared < 16.0f * numeric_limits<float>::epsilon()) {
413 SetMovement(restore_movement);
417 // if offset > 10cm, warp the player
418 // otherwise, move at most 1cm per frame towards
419 // the fixed position (160ms, so shouldn't be too noticeable)
420 constexpr float warp_thresh = 0.01f; // (1/10)^2
421 constexpr float max_disp = 0.0001f; // (1/100)^2
423 if (disp_squared > warp_thresh) {
424 player_state.chunk_pos = replay.GetState().chunk_pos;
425 player_state.block_pos = replay.GetState().block_pos;
426 } else if (disp_squared < max_disp) {
427 player_state.block_pos += displacement;
429 displacement *= 0.01f / sqrt(disp_squared);
430 player_state.block_pos += displacement;
432 GetPlayer().GetEntity().SetState(player_state);
433 SetMovement(restore_movement);
436 void NetworkedInput::StartPrimaryAction() {
440 void NetworkedInput::StopPrimaryAction() {
444 void NetworkedInput::StartSecondaryAction() {
448 void NetworkedInput::StopSecondaryAction() {
452 void NetworkedInput::StartTertiaryAction() {
456 void NetworkedInput::StopTertiaryAction() {