src/server/net.cpp

   1 #include "ClientConnection.hpp"
   2 #include "ChunkTransmitter.hpp"
   3 #include "Server.hpp"
   4
   5 #include "../app/init.hpp"
   6 #include "../model/CompositeModel.hpp"
   7 #include "../world/ChunkIndex.hpp"
   8 #include "../world/Entity.hpp"
   9 #include "../world/World.hpp"
  10
  11 #include <iostream>
  12 #include <zlib.h>
  13
  14 using namespace std;
  15
  16
  17 namespace blank {
  18 namespace server {
  19
  20 ChunkTransmitter::ChunkTransmitter(ClientConnection &conn)
  21 : conn(conn)
  22 , current(nullptr)
  23 , buffer_size(Chunk::BlockSize() + 10)
  24 , buffer(new uint8_t[buffer_size])
  25 , buffer_len(0)
  26 , packet_len(Packet::ChunkData::MAX_DATA_LEN)
  27 , cursor(0)
  28 , num_packets(0)
  29 , begin_packet(-1)
  30 , data_packets()
  31 , confirm_wait(0)
  32 , trans_id(0)
  33 , compressed(false) {
  34
  35 }
  36
  37 ChunkTransmitter::~ChunkTransmitter() {
  38         Abort();
  39 }
  40
  41 bool ChunkTransmitter::Idle() const noexcept {
  42         return !Transmitting() && !Waiting();
  43 }
  44
  45 bool ChunkTransmitter::Transmitting() const noexcept {
  46         return cursor < num_packets;
  47 }
  48
  49 void ChunkTransmitter::Transmit() {
  50         if (cursor < num_packets) {
  51                 SendData(cursor);
  52                 ++cursor;
  53         }
  54 }
  55
  56 bool ChunkTransmitter::Waiting() const noexcept {
  57         return confirm_wait > 0;
  58 }
  59
  60 void ChunkTransmitter::Ack(uint16_t seq) {
  61         if (!Waiting()) {
  62                 return;
  63         }
  64         if (seq == begin_packet) {
  65                 begin_packet = -1;
  66                 --confirm_wait;
  67                 if (Idle()) {
  68                         Release();
  69                 }
  70                 return;
  71         }
  72         for (int i = 0, end = data_packets.size(); i < end; ++i) {
  73                 if (seq == data_packets[i]) {
  74                         data_packets[i] = -1;
  75                         --confirm_wait;
  76                         if (Idle()) {
  77                                 Release();
  78                         }
  79                         return;
  80                 }
  81         }
  82 }
  83
  84 void ChunkTransmitter::Nack(uint16_t seq) {
  85         if (!Waiting()) {
  86                 return;
  87         }
  88         if (seq == begin_packet) {
  89                 SendBegin();
  90                 return;
  91         }
  92         for (size_t i = 0, end = data_packets.size(); i < end; ++i) {
  93                 if (seq == data_packets[i]) {
  94                         SendData(i);
  95                         return;
  96                 }
  97         }
  98 }
  99
 100 void ChunkTransmitter::Abort() {
 101         if (!current) return;
 102
 103         Release();
 104
 105         begin_packet = -1;
 106         data_packets.clear();
 107         confirm_wait = 0;
 108 }
 109
 110 void ChunkTransmitter::Send(Chunk &chunk) {
 111         // abort current chunk, if any
 112         Abort();
 113
 114         current = &chunk;
 115         current->Ref();
 116
 117         // load new chunk data
 118         compressed = true;
 119         buffer_len = buffer_size;
 120         if (compress(buffer.get(), &buffer_len, reinterpret_cast<const Bytef *>(chunk.BlockData()), Chunk::BlockSize()) != Z_OK) {
 121                 // compression failed, send it uncompressed
 122                 buffer_len = Chunk::BlockSize();
 123                 memcpy(buffer.get(), chunk.BlockData(), buffer_len);
 124                 compressed = false;
 125         }
 126         cursor = 0;
 127         num_packets = (buffer_len / packet_len) + (buffer_len % packet_len != 0);
 128         data_packets.resize(num_packets, -1);
 129
 130         ++trans_id;
 131         SendBegin();
 132 }
 133
 134 void ChunkTransmitter::SendBegin() {
 135         uint32_t flags = compressed;
 136         auto pack = conn.Prepare<Packet::ChunkBegin>();
 137         pack.WriteTransmissionId(trans_id);
 138         pack.WriteFlags(flags);
 139         pack.WriteChunkCoords(current->Position());
 140         pack.WriteDataSize(buffer_len);
 141         if (begin_packet == -1) {
 142                 ++confirm_wait;
 143         }
 144         begin_packet = conn.Send();
 145 }
 146
 147 void ChunkTransmitter::SendData(size_t i) {
 148         int pos = i * packet_len;
 149         int len = min(packet_len, buffer_len - pos);
 150         const uint8_t *data = &buffer[pos];
 151
 152         auto pack = conn.Prepare<Packet::ChunkData>();
 153         pack.WriteTransmissionId(trans_id);
 154         pack.WriteDataOffset(pos);
 155         pack.WriteDataSize(len);
 156         pack.WriteData(data, len);
 157
 158         if (data_packets[i] == -1) {
 159                 ++confirm_wait;
 160         }
 161         data_packets[i] = conn.Send();
 162 }
 163
 164 void ChunkTransmitter::Release() {
 165         if (current) {
 166                 current->UnRef();
 167                 current = nullptr;
 168         }
 169 }
 170
 171
 172 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
 173 : server(server)
 174 , conn(addr)
 175 , player(nullptr, nullptr)
 176 , player_model(nullptr)
 177 , spawns()
 178 , confirm_wait(0)
 179 , entity_updates()
 180 , player_update_state()
 181 , player_update_pack(0)
 182 , player_update_timer(1500)
 183 , transmitter(*this)
 184 , chunk_queue()
 185 , old_base() {
 186         conn.SetHandler(this);
 187 }
 188
 189 ClientConnection::~ClientConnection() {
 190         DetachPlayer();
 191 }
 192
 193 void ClientConnection::Update(int dt) {
 194         conn.Update(dt);
 195         if (Disconnected()) {
 196                 return;
 197         }
 198         if (HasPlayer()) {
 199                 // sync entities
 200                 auto global_iter = server.GetWorld().Entities().begin();
 201                 auto global_end = server.GetWorld().Entities().end();
 202                 auto local_iter = spawns.begin();
 203                 auto local_end = spawns.end();
 204
 205                 while (global_iter != global_end && local_iter != local_end) {
 206                         if (global_iter->ID() == local_iter->entity->ID()) {
 207                                 // they're the same
 208                                 if (CanDespawn(*global_iter)) {
 209                                         SendDespawn(*local_iter);
 210                                 } else {
 211                                         // update
 212                                         QueueUpdate(*local_iter);
 213                                 }
 214                                 ++global_iter;
 215                                 ++local_iter;
 216                         } else if (global_iter->ID() < local_iter->entity->ID()) {
 217                                 // global entity was inserted
 218                                 if (CanSpawn(*global_iter)) {
 219                                         auto spawned = spawns.emplace(local_iter, *global_iter);
 220                                         SendSpawn(*spawned);
 221                                 }
 222                                 ++global_iter;
 223                         } else {
 224                                 // global entity was removed
 225                                 SendDespawn(*local_iter);
 226                                 ++local_iter;
 227                         }
 228                 }
 229
 230                 // leftover spawns
 231                 while (global_iter != global_end) {
 232                         if (CanSpawn(*global_iter)) {
 233                                 spawns.emplace_back(*global_iter);
 234                                 SendSpawn(spawns.back());
 235                         }
 236                         ++global_iter;
 237                 }
 238
 239                 // leftover despawns
 240                 while (local_iter != local_end) {
 241                         SendDespawn(*local_iter);
 242                         ++local_iter;
 243                 }
 244                 SendUpdates();
 245
 246                 CheckPlayerFix();
 247                 CheckChunkQueue();
 248         }
 249         if (conn.ShouldPing()) {
 250                 conn.SendPing(server.GetPacket(), server.GetSocket());
 251         }
 252 }
 253
 254 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
 255 : entity(&e)
 256 , spawn_pack(-1)
 257 , despawn_pack(-1) {
 258         entity->Ref();
 259 }
 260
 261 ClientConnection::SpawnStatus::~SpawnStatus() {
 262         entity->UnRef();
 263 }
 264
 265 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
 266         return
 267                 &e != player.entity &&
 268                 !e.Dead() &&
 269                 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) < 7;
 270 }
 271
 272 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
 273         return
 274                 e.Dead() ||
 275                 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) > 7;
 276 }
 277
 278 uint16_t ClientConnection::Send() {
 279         return conn.Send(server.GetPacket(), server.GetSocket());
 280 }
 281
 282 uint16_t ClientConnection::Send(size_t len) {
 283         server.GetPacket().len = len;
 284         return Send();
 285 }
 286
 287 void ClientConnection::SendSpawn(SpawnStatus &status) {
 288         // don't double spawn
 289         if (status.spawn_pack != -1) return;
 290
 291         auto pack = Prepare<Packet::SpawnEntity>();
 292         pack.WriteEntity(*status.entity);
 293         status.spawn_pack = Send();
 294         ++confirm_wait;
 295 }
 296
 297 void ClientConnection::SendDespawn(SpawnStatus &status) {
 298         // don't double despawn
 299         if (status.despawn_pack != -1) return;
 300
 301         auto pack = Prepare<Packet::DespawnEntity>();
 302         pack.WriteEntityID(status.entity->ID());
 303         status.despawn_pack = Send();
 304         ++confirm_wait;
 305 }
 306
 307 void ClientConnection::QueueUpdate(SpawnStatus &status) {
 308         // don't send updates while spawn not ack'd or despawn sent
 309         if (status.spawn_pack == -1 && status.despawn_pack == -1) {
 310                 entity_updates.push_back(&status);
 311         }
 312 }
 313
 314 void ClientConnection::SendUpdates() {
 315         auto pack = Prepare<Packet::EntityUpdate>();
 316         int entity_pos = 0;
 317         for (SpawnStatus *status : entity_updates) {
 318                 pack.WriteEntity(*status->entity, entity_pos);
 319                 ++entity_pos;
 320                 if (entity_pos == Packet::EntityUpdate::MAX_ENTITIES) {
 321                         pack.WriteEntityCount(entity_pos);
 322                         Send(Packet::EntityUpdate::GetSize(entity_pos));
 323                         pack = Prepare<Packet::EntityUpdate>();
 324                         entity_pos = 0;
 325                 }
 326         }
 327         if (entity_pos > 0) {
 328                 pack.WriteEntityCount(entity_pos);
 329                 Send(Packet::EntityUpdate::GetSize(entity_pos));
 330         }
 331         entity_updates.clear();
 332 }
 333
 334 void ClientConnection::CheckPlayerFix() {
 335         // player_update_state's position holds the client's most recent prediction
 336         glm::vec3 diff = player_update_state.Diff(PlayerEntity().GetState());
 337         float dist_squared = dot(diff, diff);
 338
 339         // if client's prediction is off by more than 1cm, send
 340         // our (authoritative) state back so it can fix it
 341         constexpr float fix_thresh = 0.0001f;
 342
 343         if (dist_squared > fix_thresh) {
 344                 auto pack = Prepare<Packet::PlayerCorrection>();
 345                 pack.WritePacketSeq(player_update_pack);
 346                 pack.WritePlayer(PlayerEntity());
 347                 Send();
 348         }
 349 }
 350
 351 void ClientConnection::CheckChunkQueue() {
 352         if (PlayerChunks().Base() != old_base) {
 353                 Chunk::Pos begin = PlayerChunks().CoordsBegin();
 354                 Chunk::Pos end = PlayerChunks().CoordsEnd();
 355                 for (Chunk::Pos pos = begin; pos.z < end.z; ++pos.z) {
 356                         for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
 357                                 for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
 358                                         if (manhattan_radius(pos - old_base) > PlayerChunks().Extent()) {
 359                                                 chunk_queue.push_back(pos);
 360                                         }
 361                                 }
 362                         }
 363                 }
 364                 old_base = PlayerChunks().Base();
 365         }
 366         if (transmitter.Transmitting()) {
 367                 transmitter.Transmit();
 368                 return;
 369         }
 370         if (transmitter.Idle()) {
 371                 int count = 0;
 372                 constexpr int max = 64;
 373                 while (count < max && !chunk_queue.empty()) {
 374                         Chunk::Pos pos = chunk_queue.front();
 375                         chunk_queue.pop_front();
 376                         if (PlayerChunks().InRange(pos)) {
 377                                 Chunk *chunk = PlayerChunks().Get(pos);
 378                                 if (chunk) {
 379                                         transmitter.Send(*chunk);
 380                                         return;
 381                                 } else {
 382                                         chunk_queue.push_back(pos);
 383                                 }
 384                                 ++count;
 385                         }
 386                 }
 387         }
 388 }
 389
 390 void ClientConnection::AttachPlayer(const Player &new_player) {
 391         DetachPlayer();
 392         player = new_player;
 393         player.entity->Ref();
 394
 395         old_base = player.chunks->Base();
 396         Chunk::Pos begin = player.chunks->CoordsBegin();
 397         Chunk::Pos end = player.chunks->CoordsEnd();
 398         for (Chunk::Pos pos = begin; pos.z < end.z; ++pos.z) {
 399                 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
 400                         for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
 401                                 chunk_queue.push_back(pos);
 402                         }
 403                 }
 404         }
 405         if (HasPlayerModel()) {
 406                 GetPlayerModel().Instantiate(player.entity->GetModel());
 407         }
 408
 409         cout << "player \"" << player.entity->Name() << "\" joined" << endl;
 410 }
 411
 412 void ClientConnection::DetachPlayer() {
 413         if (!HasPlayer()) return;
 414         cout << "player \"" << player.entity->Name() << "\" left" << endl;
 415         player.entity->Kill();
 416         player.entity->UnRef();
 417         player.entity = nullptr;
 418         player.chunks = nullptr;
 419         transmitter.Abort();
 420         chunk_queue.clear();
 421 }
 422
 423 void ClientConnection::SetPlayerModel(const CompositeModel &m) noexcept {
 424         player_model = &m;
 425         if (HasPlayer()) {
 426                 m.Instantiate(PlayerEntity().GetModel());
 427         }
 428 }
 429
 430 bool ClientConnection::HasPlayerModel() const noexcept {
 431         return player_model;
 432 }
 433
 434 const CompositeModel &ClientConnection::GetPlayerModel() const noexcept {
 435         return *player_model;
 436 }
 437
 438 void ClientConnection::OnPacketReceived(uint16_t seq) {
 439         if (transmitter.Waiting()) {
 440                 transmitter.Ack(seq);
 441         }
 442         if (!confirm_wait) return;
 443         for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
 444                 if (seq == iter->spawn_pack) {
 445                         iter->spawn_pack = -1;
 446                         --confirm_wait;
 447                         return;
 448                 }
 449                 if (seq == iter->despawn_pack) {
 450                         spawns.erase(iter);
 451                         --confirm_wait;
 452                         return;
 453                 }
 454         }
 455 }
 456
 457 void ClientConnection::OnPacketLost(uint16_t seq) {
 458         if (transmitter.Waiting()) {
 459                 transmitter.Nack(seq);
 460         }
 461         if (!confirm_wait) return;
 462         for (SpawnStatus &status : spawns) {
 463                 if (seq == status.spawn_pack) {
 464                         status.spawn_pack = -1;
 465                         --confirm_wait;
 466                         SendSpawn(status);
 467                         return;
 468                 }
 469                 if (seq == status.despawn_pack) {
 470                         status.despawn_pack = -1;
 471                         --confirm_wait;
 472                         SendDespawn(status);
 473                         return;
 474                 }
 475         }
 476 }
 477
 478 void ClientConnection::On(const Packet::Login &pack) {
 479         string name;
 480         pack.ReadPlayerName(name);
 481
 482         Player new_player = server.GetWorld().AddPlayer(name);
 483
 484         if (new_player.entity) {
 485                 // success!
 486                 AttachPlayer(new_player);
 487                 cout << "accepted login from player \"" << name << '"' << endl;
 488                 auto response = Prepare<Packet::Join>();
 489                 response.WritePlayer(*new_player.entity);
 490                 response.WriteWorldName(server.GetWorld().Name());
 491                 Send();
 492                 // set up update tracking
 493                 player_update_state = new_player.entity->GetState();
 494                 player_update_pack = pack.Seq();
 495                 player_update_timer.Reset();
 496                 player_update_timer.Start();
 497         } else {
 498                 // aw no :(
 499                 cout << "rejected login from player \"" << name << '"' << endl;
 500                 Prepare<Packet::Part>();
 501                 Send();
 502                 conn.Close();
 503         }
 504 }
 505
 506 void ClientConnection::On(const Packet::Part &) {
 507         conn.Close();
 508 }
 509
 510 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
 511         if (!HasPlayer()) return;
 512         int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
 513         bool overdue = player_update_timer.HitOnce();
 514         player_update_timer.Reset();
 515         if (pack_diff > 0 || overdue) {
 516                 player_update_pack = pack.Seq();
 517                 pack.ReadPlayerState(player_update_state);
 518                 // accept velocity and orientation as "user input"
 519                 PlayerEntity().Velocity(player_update_state.velocity);
 520                 PlayerEntity().Orientation(player_update_state.orient);
 521         }
 522 }
 523
 524
 525 Server::Server(const Config &conf, World &world)
 526 : serv_sock(nullptr)
 527 , serv_pack{ -1, nullptr, 0 }
 528 , clients()
 529 , world(world)
 530 , player_model(nullptr) {
 531         serv_sock = SDLNet_UDP_Open(conf.port);
 532         if (!serv_sock) {
 533                 throw NetError("SDLNet_UDP_Open");
 534         }
 535
 536         serv_pack.data = new Uint8[sizeof(Packet)];
 537         serv_pack.maxlen = sizeof(Packet);
 538 }
 539
 540 Server::~Server() {
 541         delete[] serv_pack.data;
 542         SDLNet_UDP_Close(serv_sock);
 543 }
 544
 545
 546 void Server::Handle() {
 547         int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 548         while (result > 0) {
 549                 HandlePacket(serv_pack);
 550                 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 551         }
 552         if (result == -1) {
 553                 // a boo boo happened
 554                 throw NetError("SDLNet_UDP_Recv");
 555         }
 556 }
 557
 558 void Server::HandlePacket(const UDPpacket &udp_pack) {
 559         if (udp_pack.len < int(sizeof(Packet::Header))) {
 560                 // packet too small, drop
 561                 return;
 562         }
 563         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 564         if (pack.header.tag != Packet::TAG) {
 565                 // mistagged packet, drop
 566                 return;
 567         }
 568
 569         ClientConnection &client = GetClient(udp_pack.address);
 570         client.GetConnection().Received(udp_pack);
 571 }
 572
 573 ClientConnection &Server::GetClient(const IPaddress &addr) {
 574         for (ClientConnection &client : clients) {
 575                 if (client.Matches(addr)) {
 576                         return client;
 577                 }
 578         }
 579         clients.emplace_back(*this, addr);
 580         if (HasPlayerModel()) {
 581                 clients.back().SetPlayerModel(GetPlayerModel());
 582         }
 583         return clients.back();
 584 }
 585
 586 void Server::Update(int dt) {
 587         for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
 588                 client->Update(dt);
 589                 if (client->Disconnected()) {
 590                         client = clients.erase(client);
 591                 } else {
 592                         ++client;
 593                 }
 594         }
 595 }
 596
 597 void Server::SetPlayerModel(const CompositeModel &m) noexcept {
 598         player_model = &m;
 599         for (ClientConnection &client : clients) {
 600                 client.SetPlayerModel(m);
 601         }
 602 }
 603
 604 bool Server::HasPlayerModel() const noexcept {
 605         return player_model;
 606 }
 607
 608 const CompositeModel &Server::GetPlayerModel() const noexcept {
 609         return *player_model;
 610 }
 611
 612 }
 613 }