src/client/net.cpp

   1 #include "ChunkReceiver.hpp"
   2 #include "ChunkTransmission.hpp"
   3 #include "Client.hpp"
   4 #include "NetworkedInput.hpp"
   5
   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"
  14
  15 #include <iostream>
  16 #include <zlib.h>
  17 #include <glm/gtx/io.hpp>
  18
  19 using namespace std;
  20
  21
  22 namespace blank {
  23 namespace client {
  24
  25
  26 ChunkReceiver::ChunkReceiver(Client &client, ChunkStore &store, const WorldSave &save)
  27 : client(client)
  28 , store(store)
  29 , save(save)
  30 , transmissions()
  31 , timer(5000) {
  32         timer.Start();
  33 }
  34
  35 ChunkReceiver::~ChunkReceiver() {
  36
  37 }
  38
  39 void ChunkReceiver::Update(int dt) {
  40         timer.Update(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);
  46                                 trans.Reset();
  47                                 trans.last_update = timer.Elapsed();
  48                         } else {
  49                                 // well shit
  50                                 trans.Clear();
  51                         }
  52                 }
  53         }
  54         if (transmissions.size() > 3) {
  55                 for (auto iter = transmissions.begin(), end = transmissions.end(); iter != end; ++iter) {
  56                         if (!iter->active) {
  57                                 transmissions.erase(iter);
  58                                 break;
  59                         }
  60                 }
  61         }
  62         LoadN(10);
  63         StoreN(10);
  64 }
  65
  66 int ChunkReceiver::ToLoad() const noexcept {
  67         return store.EstimateMissing();
  68 }
  69
  70 void ChunkReceiver::LoadOne() {
  71         if (!store.HasMissing()) return;
  72
  73         ExactLocation::Coarse pos = store.NextMissing();
  74         Chunk *chunk = store.Allocate(pos);
  75         if (!chunk) {
  76                 // chunk store corrupted?
  77                 return;
  78         }
  79
  80         if (save.Exists(pos)) {
  81                 save.Read(*chunk);
  82         }
  83 }
  84
  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) {
  88                 LoadOne();
  89         }
  90 }
  91
  92 void ChunkReceiver::StoreN(size_t n) {
  93         size_t saved = 0;
  94         for (Chunk &chunk : store) {
  95                 if (chunk.ShouldUpdateSave()) {
  96                         save.Write(chunk);
  97                         ++saved;
  98                         if (saved >= n) {
  99                                 break;
 100                         }
 101                 }
 102         }
 103 }
 104
 105
 106 void ChunkReceiver::Handle(const Packet::ChunkBegin &pack) {
 107         uint32_t id;
 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;
 115         Commit(trans);
 116 }
 117
 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;
 124                 return;
 125         }
 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();
 133         Commit(trans);
 134 }
 135
 136 ChunkTransmission &ChunkReceiver::GetTransmission(uint32_t id) {
 137         // search for ongoing
 138         for (ChunkTransmission &trans : transmissions) {
 139                 if (trans.active && trans.id == id) {
 140                         return trans;
 141                 }
 142         }
 143         // search for unused
 144         for (ChunkTransmission &trans : transmissions) {
 145                 if (!trans.active) {
 146                         trans.active = true;
 147                         trans.id = id;
 148                         return trans;
 149                 }
 150         }
 151         // allocate new
 152         transmissions.emplace_back();
 153         transmissions.back().active = true;
 154         transmissions.back().id = id;
 155         return transmissions.back();
 156 }
 157
 158 void ChunkReceiver::Commit(ChunkTransmission &trans) {
 159         if (!trans.Complete()) return;
 160
 161         Chunk *chunk = store.Allocate(trans.coords);
 162         if (!chunk) {
 163                 // chunk no longer of interest, just drop the data
 164                 // it should probably be cached to disk, but not now :P
 165                 trans.Clear();
 166                 return;
 167         }
 168
 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();
 173
 174         if (trans.Compressed()) {
 175                 if (uncompress(dst, &dst_len, src, src_len) != Z_OK) {
 176                         // omg, now what?
 177                         cout << "got corruped chunk data for " << trans.coords << endl;
 178                         client.SendChunkRequest(trans.coords);
 179                         trans.Reset();
 180                         // chunk data can, and probably will, contain invalid block IDs, so
 181                         // zero it to be safe
 182                         memset(dst, 0, dst_len);
 183                         return;
 184                 }
 185         } else {
 186                 memcpy(dst, src, min(src_len, dst_len));
 187         }
 188         chunk->ScanActive();
 189         chunk->Invalidate();
 190         trans.Clear();
 191 }
 192
 193 ChunkTransmission::ChunkTransmission()
 194 : id(0)
 195 , flags(0)
 196 , coords()
 197 , data_size(0)
 198 , data_received(0)
 199 , last_update(0)
 200 , header_received(false)
 201 , active(false)
 202 , buffer() {
 203
 204 }
 205
 206 void ChunkTransmission::Reset() noexcept {
 207         data_size = 0;
 208         data_received = 0;
 209         last_update = 0;
 210         header_received = false;
 211 }
 212
 213 void ChunkTransmission::Clear() noexcept {
 214         Reset();
 215         active = false;
 216 }
 217
 218 bool ChunkTransmission::Complete() const noexcept {
 219         return header_received && data_received == data_size;
 220 }
 221
 222 bool ChunkTransmission::Compressed() const noexcept {
 223         return flags & 1;
 224 }
 225
 226
 227 namespace {
 228
 229 UDPsocket client_bind(Uint16 port) {
 230         UDPsocket sock = SDLNet_UDP_Open(port);
 231         if (!sock) {
 232                 throw NetError("SDLNet_UDP_Open");
 233         }
 234         return sock;
 235 }
 236
 237 IPaddress client_resolve(const char *host, Uint16 port) {
 238         IPaddress addr;
 239         if (SDLNet_ResolveHost(&addr, host, port) != 0) {
 240                 throw NetError("SDLNet_ResolveHost");
 241         }
 242         return addr;
 243 }
 244
 245 }
 246
 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
 254         SendPing();
 255 }
 256
 257 Client::~Client() {
 258         delete[] client_pack.data;
 259         SDLNet_UDP_Close(client_sock);
 260 }
 261
 262
 263 void Client::Handle() {
 264         int result = SDLNet_UDP_Recv(client_sock, &client_pack);
 265         while (result > 0) {
 266                 HandlePacket(client_pack);
 267                 result = SDLNet_UDP_Recv(client_sock, &client_pack);
 268         }
 269         if (result == -1) {
 270                 // a boo boo happened
 271                 throw NetError("SDLNet_UDP_Recv");
 272         }
 273 }
 274
 275 void Client::HandlePacket(const UDPpacket &udp_pack) {
 276         if (!conn.Matches(udp_pack.address)) {
 277                 // packet came from somewhere else, drop
 278                 return;
 279         }
 280         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 281         if (pack.header.tag != Packet::TAG) {
 282                 // mistagged packet, drop
 283                 return;
 284         }
 285
 286         conn.Received(udp_pack);
 287 }
 288
 289 void Client::Update(int dt) {
 290         conn.Update(dt);
 291         if (conn.ShouldPing()) {
 292                 SendPing();
 293         }
 294 }
 295
 296 uint16_t Client::SendPing() {
 297         return conn.SendPing(client_pack, client_sock);
 298 }
 299
 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);
 304 }
 305
 306 uint16_t Client::SendPlayerUpdate(
 307         const EntityState &prediction,
 308         const glm::vec3 &movement,
 309         float pitch,
 310         float yaw,
 311         uint8_t actions,
 312         uint8_t slot
 313 ) {
 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);
 320 }
 321
 322 uint16_t Client::SendPart() {
 323         Packet::Make<Packet::Part>(client_pack);
 324         return conn.Send(client_pack, client_sock);
 325 }
 326
 327 uint16_t Client::SendChunkRequest(
 328         const glm::ivec3 &coords
 329 ) {
 330         auto pack = Packet::Make<Packet::ChunkBegin>(client_pack);
 331         pack.WriteChunkCoords(coords);
 332         return conn.Send(client_pack, client_sock);
 333 }
 334
 335 uint16_t Client::SendMessage(
 336         uint8_t type,
 337         uint32_t ref,
 338         const string &msg
 339 ) {
 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);
 346 }
 347
 348 NetworkedInput::NetworkedInput(World &world, Player &player, Client &client)
 349 : PlayerController(world, player)
 350 , client(client)
 351 , player_hist()
 352 , old_movement(0.0f)
 353 , old_actions(0)
 354 , actions(0) {
 355
 356 }
 357
 358 bool NetworkedInput::UpdateImportant() const noexcept {
 359         return old_actions != actions || !iszero(old_movement - GetMovement());
 360 }
 361
 362 void NetworkedInput::Update(Entity &, float dt) {
 363         Invalidate();
 364         UpdatePlayer();
 365 }
 366
 367 void NetworkedInput::PushPlayerUpdate(int dt) {
 368         const EntityState &state = GetPlayer().GetEntity().GetState();
 369
 370         uint16_t packet = client.SendPlayerUpdate(
 371                 state,
 372                 GetMovement(),
 373                 GetPitch(),
 374                 GetYaw(),
 375                 actions,
 376                 InventorySlot()
 377         );
 378         if (player_hist.size() < 16) {
 379                 player_hist.emplace_back(state, GetMovement(), dt * 0.001f, packet);
 380         } else {
 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);
 387         }
 388         old_movement = GetMovement();
 389         old_actions = actions;
 390 }
 391
 392 void NetworkedInput::MergePlayerCorrection(uint16_t seq, const EntityState &corrected_state) {
 393         if (player_hist.empty()) return;
 394
 395         auto entry = player_hist.begin();
 396         auto end = player_hist.end();
 397
 398         // we may have received an older packet
 399         int pack_diff = int16_t(seq) - int16_t(entry->packet);
 400         if (pack_diff < 0) {
 401                 // indeed we have, just ignore it
 402                 return;
 403         }
 404
 405         // drop anything older than the fix
 406         while (entry != end) {
 407                 pack_diff = int16_t(seq) - int16_t(entry->packet);
 408                 if (pack_diff > 0) {
 409                         entry = player_hist.erase(entry);
 410                 } else {
 411                         break;
 412                 }
 413         }
 414
 415         glm::vec3 restore_movement(GetMovement());
 416
 417         EntityState player_state = GetPlayer().GetEntity().GetState();
 418         Entity replay(GetPlayer().GetEntity());
 419         replay.SetState(corrected_state);
 420
 421         if (entry != end) {
 422                 entry->state.pos = replay.GetState().pos;
 423                 ++entry;
 424         }
 425
 426         vector<WorldCollision> col;
 427         while (entry != end) {
 428                 SetMovement(entry->movement);
 429                 replay.Update(GetWorld(), entry->delta_t);
 430                 entry->state.pos = replay.GetState().pos;
 431                 ++entry;
 432         }
 433
 434         glm::vec3 displacement(replay.GetState().Diff(player_state));
 435         const float disp_squared = glm::dot(displacement, displacement);
 436
 437         if (disp_squared < 16.0f * numeric_limits<float>::epsilon()) {
 438                 SetMovement(restore_movement);
 439                 return;
 440         }
 441
 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
 447
 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;
 452         } else {
 453                 displacement *= 0.01f / sqrt(disp_squared);
 454                 player_state.pos.block += displacement;
 455         }
 456         GetPlayer().GetEntity().SetState(player_state);
 457         SetMovement(restore_movement);
 458 }
 459
 460 void NetworkedInput::StartPrimaryAction() {
 461         actions |= 0x01;
 462 }
 463
 464 void NetworkedInput::StopPrimaryAction() {
 465         actions &= ~0x01;
 466 }
 467
 468 void NetworkedInput::StartSecondaryAction() {
 469         actions |= 0x02;
 470 }
 471
 472 void NetworkedInput::StopSecondaryAction() {
 473         actions &= ~0x02;
 474 }
 475
 476 void NetworkedInput::StartTertiaryAction() {
 477         actions |= 0x04;
 478 }
 479
 480 void NetworkedInput::StopTertiaryAction() {
 481         actions &= ~0x04;
 482 }
 483
 484 }
 485 }