src/server/net.cpp

   1 #include "ClientConnection.hpp"
   2 #include "ChunkTransmitter.hpp"
   3 #include "Server.hpp"
   4
   5 #include "../app/init.hpp"
   6 #include "../geometry/distance.hpp"
   7 #include "../io/WorldSave.hpp"
   8 #include "../model/Model.hpp"
   9 #include "../world/ChunkIndex.hpp"
  10 #include "../world/Entity.hpp"
  11 #include "../world/World.hpp"
  12
  13 #include <algorithm>
  14 #include <iostream>
  15 #include <zlib.h>
  16 #include <glm/gtx/io.hpp>
  17
  18 using namespace std;
  19
  20
  21 namespace blank {
  22 namespace server {
  23
  24 ChunkTransmitter::ChunkTransmitter(ClientConnection &conn)
  25 : conn(conn)
  26 , current(nullptr)
  27 , buffer_size(Chunk::BlockSize() + 10)
  28 , buffer(new uint8_t[buffer_size])
  29 , buffer_len(0)
  30 , packet_len(Packet::ChunkData::MAX_DATA_LEN)
  31 , cursor(0)
  32 , num_packets(0)
  33 , begin_packet(-1)
  34 , data_packets()
  35 , confirm_wait(0)
  36 , trans_id(0)
  37 , compressed(false) {
  38
  39 }
  40
  41 ChunkTransmitter::~ChunkTransmitter() {
  42         Abort();
  43 }
  44
  45 bool ChunkTransmitter::Idle() const noexcept {
  46         return !Transmitting() && !Waiting();
  47 }
  48
  49 bool ChunkTransmitter::Transmitting() const noexcept {
  50         return cursor < num_packets;
  51 }
  52
  53 void ChunkTransmitter::Transmit() {
  54         if (cursor < num_packets) {
  55                 SendData(cursor);
  56                 ++cursor;
  57         }
  58 }
  59
  60 bool ChunkTransmitter::Waiting() const noexcept {
  61         return confirm_wait > 0;
  62 }
  63
  64 void ChunkTransmitter::Ack(uint16_t seq) {
  65         if (!Waiting()) {
  66                 return;
  67         }
  68         if (seq == begin_packet) {
  69                 begin_packet = -1;
  70                 --confirm_wait;
  71                 if (Idle()) {
  72                         Release();
  73                 }
  74                 return;
  75         }
  76         for (int i = 0, end = data_packets.size(); i < end; ++i) {
  77                 if (seq == data_packets[i]) {
  78                         data_packets[i] = -1;
  79                         --confirm_wait;
  80                         if (Idle()) {
  81                                 Release();
  82                         }
  83                         return;
  84                 }
  85         }
  86 }
  87
  88 void ChunkTransmitter::Nack(uint16_t seq) {
  89         if (!Waiting()) {
  90                 return;
  91         }
  92         if (seq == begin_packet) {
  93                 SendBegin();
  94                 return;
  95         }
  96         for (size_t i = 0, end = data_packets.size(); i < end; ++i) {
  97                 if (seq == data_packets[i]) {
  98                         SendData(i);
  99                         return;
 100                 }
 101         }
 102 }
 103
 104 void ChunkTransmitter::Abort() {
 105         if (!current) return;
 106
 107         Release();
 108
 109         begin_packet = -1;
 110         data_packets.clear();
 111         confirm_wait = 0;
 112 }
 113
 114 void ChunkTransmitter::Send(Chunk &chunk) {
 115         // abort current chunk, if any
 116         Abort();
 117
 118         current = &chunk;
 119         current->Ref();
 120
 121         // load new chunk data
 122         compressed = true;
 123         buffer_len = buffer_size;
 124         if (compress(buffer.get(), &buffer_len, reinterpret_cast<const Bytef *>(chunk.BlockData()), Chunk::BlockSize()) != Z_OK) {
 125                 // compression failed, send it uncompressed
 126                 buffer_len = Chunk::BlockSize();
 127                 memcpy(buffer.get(), chunk.BlockData(), buffer_len);
 128                 compressed = false;
 129         }
 130         cursor = 0;
 131         num_packets = (buffer_len / packet_len) + (buffer_len % packet_len != 0);
 132         data_packets.resize(num_packets, -1);
 133
 134         ++trans_id;
 135         SendBegin();
 136 }
 137
 138 void ChunkTransmitter::SendBegin() {
 139         uint32_t flags = compressed;
 140         auto pack = conn.Prepare<Packet::ChunkBegin>();
 141         pack.WriteTransmissionId(trans_id);
 142         pack.WriteFlags(flags);
 143         pack.WriteChunkCoords(current->Position());
 144         pack.WriteDataSize(buffer_len);
 145         if (begin_packet == -1) {
 146                 ++confirm_wait;
 147         }
 148         begin_packet = conn.Send();
 149 }
 150
 151 void ChunkTransmitter::SendData(size_t i) {
 152         int pos = i * packet_len;
 153         int len = min(packet_len, buffer_len - pos);
 154         const uint8_t *data = &buffer[pos];
 155
 156         auto pack = conn.Prepare<Packet::ChunkData>();
 157         pack.WriteTransmissionId(trans_id);
 158         pack.WriteDataOffset(pos);
 159         pack.WriteDataSize(len);
 160         pack.WriteData(data, len);
 161
 162         if (data_packets[i] == -1) {
 163                 ++confirm_wait;
 164         }
 165         data_packets[i] = conn.Send(Packet::ChunkData::GetSize(len));
 166 }
 167
 168 void ChunkTransmitter::Release() {
 169         if (current) {
 170                 current->UnRef();
 171                 current = nullptr;
 172         }
 173 }
 174
 175
 176 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
 177 : server(server)
 178 , conn(addr)
 179 , input()
 180 , player_model(nullptr)
 181 , spawns()
 182 , confirm_wait(0)
 183 , entity_updates()
 184 , entity_updates_skipped(0)
 185 , player_update_state()
 186 , player_update_pack(0)
 187 , player_update_timer(1500)
 188 , old_actions(0)
 189 , transmitter(*this)
 190 , chunk_queue()
 191 , old_base()
 192 , chunk_blocks_skipped(0) {
 193         conn.SetHandler(this);
 194 }
 195
 196 ClientConnection::~ClientConnection() {
 197         DetachPlayer();
 198 }
 199
 200 void ClientConnection::Update(int dt) {
 201         conn.Update(dt);
 202         if (Disconnected()) {
 203                 return;
 204         }
 205         if (HasPlayer()) {
 206                 CheckPlayerFix();
 207                 CheckChunkQueue();
 208                 CheckEntities();
 209                 SendUpdates();
 210         }
 211         if (conn.ShouldPing()) {
 212                 conn.SendPing(server.GetPacket(), server.GetSocket());
 213         }
 214 }
 215
 216 void ClientConnection::CheckEntities() {
 217         auto global_iter = server.GetWorld().Entities().begin();
 218         auto global_end = server.GetWorld().Entities().end();
 219         auto local_iter = spawns.begin();
 220         auto local_end = spawns.end();
 221
 222         while (global_iter != global_end && local_iter != local_end) {
 223                 if (global_iter->ID() == local_iter->entity->ID()) {
 224                         // they're the same
 225                         if (CanDespawn(*global_iter)) {
 226                                 SendDespawn(*local_iter);
 227                         } else if (SendingUpdates()) {
 228                                 // update
 229                                 QueueUpdate(*local_iter);
 230                         }
 231                         ++global_iter;
 232                         ++local_iter;
 233                 } else if (global_iter->ID() < local_iter->entity->ID()) {
 234                         // global entity was inserted
 235                         if (CanSpawn(*global_iter)) {
 236                                 auto spawned = spawns.emplace(local_iter, *global_iter);
 237                                 SendSpawn(*spawned);
 238                         }
 239                         ++global_iter;
 240                 } else {
 241                         // global entity was removed
 242                         SendDespawn(*local_iter);
 243                         ++local_iter;
 244                 }
 245         }
 246
 247         // leftover spawns
 248         while (global_iter != global_end) {
 249                 if (CanSpawn(*global_iter)) {
 250                         spawns.emplace_back(*global_iter);
 251                         SendSpawn(spawns.back());
 252                 }
 253                 ++global_iter;
 254         }
 255
 256         // leftover despawns
 257         while (local_iter != local_end) {
 258                 SendDespawn(*local_iter);
 259                 ++local_iter;
 260         }
 261 }
 262
 263 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
 264 : entity(&e)
 265 , spawn_pack(-1)
 266 , despawn_pack(-1) {
 267         entity->Ref();
 268 }
 269
 270 ClientConnection::SpawnStatus::~SpawnStatus() {
 271         entity->UnRef();
 272 }
 273
 274 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
 275         return
 276                 &e != &PlayerEntity() &&
 277                 !e.Dead() &&
 278                 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) < 7;
 279 }
 280
 281 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
 282         return
 283                 e.Dead() ||
 284                 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) > 7;
 285 }
 286
 287 uint16_t ClientConnection::Send() {
 288         return conn.Send(server.GetPacket(), server.GetSocket());
 289 }
 290
 291 uint16_t ClientConnection::Send(size_t len) {
 292         server.GetPacket().len = sizeof(Packet::Header) + len;
 293         return Send();
 294 }
 295
 296 void ClientConnection::SendSpawn(SpawnStatus &status) {
 297         // don't double spawn
 298         if (status.spawn_pack != -1) return;
 299
 300         auto pack = Prepare<Packet::SpawnEntity>();
 301         pack.WriteEntity(*status.entity);
 302         status.spawn_pack = Send();
 303         ++confirm_wait;
 304 }
 305
 306 void ClientConnection::SendDespawn(SpawnStatus &status) {
 307         // don't double despawn
 308         if (status.despawn_pack != -1) return;
 309
 310         auto pack = Prepare<Packet::DespawnEntity>();
 311         pack.WriteEntityID(status.entity->ID());
 312         status.despawn_pack = Send();
 313         ++confirm_wait;
 314 }
 315
 316 bool ClientConnection::SendingUpdates() const noexcept {
 317         return entity_updates_skipped >= NetStat().SuggestedPacketHold();
 318 }
 319
 320 void ClientConnection::QueueUpdate(SpawnStatus &status) {
 321         // don't send updates while spawn not ack'd or despawn sent
 322         if (status.spawn_pack == -1 && status.despawn_pack == -1) {
 323                 entity_updates.push_back(&status);
 324         }
 325 }
 326
 327 void ClientConnection::SendUpdates() {
 328         if (!SendingUpdates()) {
 329                 entity_updates.clear();
 330                 ++entity_updates_skipped;
 331                 return;
 332         }
 333         auto base = PlayerChunks().Base();
 334         auto pack = Prepare<Packet::EntityUpdate>();
 335         pack.WriteChunkBase(base);
 336         int entity_pos = 0;
 337         for (SpawnStatus *status : entity_updates) {
 338                 pack.WriteEntity(*status->entity, base, entity_pos);
 339                 ++entity_pos;
 340                 if (entity_pos == Packet::EntityUpdate::MAX_ENTITIES) {
 341                         pack.WriteEntityCount(entity_pos);
 342                         Send(Packet::EntityUpdate::GetSize(entity_pos));
 343                         pack = Prepare<Packet::EntityUpdate>();
 344                         entity_pos = 0;
 345                 }
 346         }
 347         if (entity_pos > 0) {
 348                 pack.WriteEntityCount(entity_pos);
 349                 Send(Packet::EntityUpdate::GetSize(entity_pos));
 350         }
 351         entity_updates.clear();
 352         entity_updates_skipped = 0;
 353 }
 354
 355 void ClientConnection::CheckPlayerFix() {
 356         // player_update_state's position holds the client's most recent prediction
 357         glm::vec3 diff = player_update_state.Diff(PlayerEntity().GetState());
 358         float dist_squared = dot(diff, diff);
 359
 360         // if client's prediction is off by more than 1cm, send
 361         // our (authoritative) state back so it can fix it
 362         constexpr float fix_thresh = 0.0001f;
 363
 364         if (dist_squared > fix_thresh) {
 365                 auto pack = Prepare<Packet::PlayerCorrection>();
 366                 pack.WritePacketSeq(player_update_pack);
 367                 pack.WritePlayer(PlayerEntity());
 368                 Send();
 369         }
 370 }
 371
 372 namespace {
 373
 374 struct QueueCompare {
 375         explicit QueueCompare(const glm::ivec3 &base)
 376         : base(base) { }
 377         bool operator ()(const glm::ivec3 &left, const glm::ivec3 &right) const noexcept {
 378                 const glm::ivec3 ld(left - base);
 379                 const glm::ivec3 rd(right - base);
 380                 return
 381                         ld.x * ld.x + ld.y * ld.y + ld.z * ld.z <
 382                         rd.x * rd.x + rd.y * rd.y + rd.z * rd.z;
 383         }
 384         const glm::ivec3 &base;
 385 };
 386
 387 }
 388
 389 void ClientConnection::CheckChunkQueue() {
 390         if (PlayerChunks().Base() != old_base) {
 391                 ExactLocation::Coarse begin = PlayerChunks().CoordsBegin();
 392                 ExactLocation::Coarse end = PlayerChunks().CoordsEnd();
 393                 for (ExactLocation::Coarse pos = begin; pos.z < end.z; ++pos.z) {
 394                         for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
 395                                 for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
 396                                         if (manhattan_radius(pos - old_base) > PlayerChunks().Extent()) {
 397                                                 chunk_queue.push_back(pos);
 398                                         }
 399                                 }
 400                         }
 401                 }
 402                 old_base = PlayerChunks().Base();
 403                 sort(chunk_queue.begin(), chunk_queue.end(), QueueCompare(old_base));
 404                 chunk_queue.erase(unique(chunk_queue.begin(), chunk_queue.end()), chunk_queue.end());
 405         }
 406         // don't push entity updates and chunk data in the same tick
 407         if (chunk_blocks_skipped >= NetStat().SuggestedPacketHold() && !SendingUpdates()) {
 408                 ++chunk_blocks_skipped;
 409                 return;
 410         }
 411         if (transmitter.Transmitting()) {
 412                 transmitter.Transmit();
 413                 chunk_blocks_skipped = 0;
 414                 return;
 415         }
 416         if (transmitter.Idle()) {
 417                 int count = 0;
 418                 constexpr int max = 64;
 419                 while (count < max && !chunk_queue.empty()) {
 420                         ExactLocation::Coarse pos = chunk_queue.front();
 421                         chunk_queue.pop_front();
 422                         if (PlayerChunks().InRange(pos)) {
 423                                 Chunk *chunk = PlayerChunks().Get(pos);
 424                                 if (chunk) {
 425                                         transmitter.Send(*chunk);
 426                                         chunk_blocks_skipped = 0;
 427                                         return;
 428                                 } else {
 429                                         chunk_queue.push_back(pos);
 430                                 }
 431                                 ++count;
 432                         }
 433                 }
 434         }
 435 }
 436
 437 void ClientConnection::AttachPlayer(Player &player) {
 438         DetachPlayer();
 439         input.reset(new DirectInput(server.GetWorld(), player, server));
 440         PlayerEntity().Ref();
 441
 442         old_base = PlayerChunks().Base();
 443         ExactLocation::Coarse begin = PlayerChunks().CoordsBegin();
 444         ExactLocation::Coarse end = PlayerChunks().CoordsEnd();
 445         for (ExactLocation::Coarse pos = begin; pos.z < end.z; ++pos.z) {
 446                 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
 447                         for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
 448                                 chunk_queue.push_back(pos);
 449                         }
 450                 }
 451         }
 452         sort(chunk_queue.begin(), chunk_queue.end(), QueueCompare(old_base));
 453         // TODO: should the server do this?
 454         if (HasPlayerModel()) {
 455                 GetPlayerModel().Instantiate(PlayerEntity().GetModel());
 456         }
 457
 458         string msg = "player \"" + player.Name() + "\" joined";
 459         cout << msg << endl;
 460         server.DistributeMessage(0, 0, msg);
 461 }
 462
 463 void ClientConnection::DetachPlayer() {
 464         if (!HasPlayer()) return;
 465         string msg = "player \"" + input->GetPlayer().Name() + "\" left";
 466         cout << msg << endl;
 467         server.DistributeMessage(0, 0, msg);
 468
 469         server.GetWorldSave().Write(input->GetPlayer());
 470         PlayerEntity().Kill();
 471         PlayerEntity().UnRef();
 472         input.reset();
 473         transmitter.Abort();
 474         chunk_queue.clear();
 475         old_actions = 0;
 476 }
 477
 478 void ClientConnection::SetPlayerModel(const Model &m) noexcept {
 479         player_model = &m;
 480         if (HasPlayer()) {
 481                 m.Instantiate(PlayerEntity().GetModel());
 482         }
 483 }
 484
 485 bool ClientConnection::HasPlayerModel() const noexcept {
 486         return player_model;
 487 }
 488
 489 const Model &ClientConnection::GetPlayerModel() const noexcept {
 490         return *player_model;
 491 }
 492
 493 void ClientConnection::OnPacketReceived(uint16_t seq) {
 494         if (transmitter.Waiting()) {
 495                 transmitter.Ack(seq);
 496         }
 497         if (!confirm_wait) return;
 498         for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
 499                 if (seq == iter->spawn_pack) {
 500                         iter->spawn_pack = -1;
 501                         --confirm_wait;
 502                         return;
 503                 }
 504                 if (seq == iter->despawn_pack) {
 505                         spawns.erase(iter);
 506                         --confirm_wait;
 507                         return;
 508                 }
 509         }
 510 }
 511
 512 void ClientConnection::OnPacketLost(uint16_t seq) {
 513         if (transmitter.Waiting()) {
 514                 transmitter.Nack(seq);
 515         }
 516         if (!confirm_wait) return;
 517         for (SpawnStatus &status : spawns) {
 518                 if (seq == status.spawn_pack) {
 519                         status.spawn_pack = -1;
 520                         --confirm_wait;
 521                         SendSpawn(status);
 522                         return;
 523                 }
 524                 if (seq == status.despawn_pack) {
 525                         status.despawn_pack = -1;
 526                         --confirm_wait;
 527                         SendDespawn(status);
 528                         return;
 529                 }
 530         }
 531 }
 532
 533 void ClientConnection::On(const Packet::Login &pack) {
 534         string name;
 535         pack.ReadPlayerName(name);
 536
 537         Player *new_player = server.JoinPlayer(name);
 538
 539         if (new_player) {
 540                 // success!
 541                 AttachPlayer(*new_player);
 542                 cout << "accepted login from player \"" << name << '"' << endl;
 543                 auto response = Prepare<Packet::Join>();
 544                 response.WritePlayer(new_player->GetEntity());
 545                 response.WriteWorldName(server.GetWorld().Name());
 546                 Send();
 547                 // set up update tracking
 548                 player_update_state = new_player->GetEntity().GetState();
 549                 player_update_pack = pack.Seq();
 550                 player_update_timer.Reset();
 551                 player_update_timer.Start();
 552         } else {
 553                 // aw no :(
 554                 cout << "rejected login from player \"" << name << '"' << endl;
 555                 Prepare<Packet::Part>();
 556                 Send();
 557                 conn.Close();
 558         }
 559 }
 560
 561 void ClientConnection::On(const Packet::Part &) {
 562         conn.Close();
 563 }
 564
 565 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
 566         if (!HasPlayer()) return;
 567         int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
 568         bool overdue = player_update_timer.HitOnce();
 569         player_update_timer.Reset();
 570         if (pack_diff <= 0 && !overdue) {
 571                 // drop old packets if we have a fairly recent state
 572                 return;
 573         }
 574         glm::vec3 movement(0.0f);
 575         uint8_t new_actions;
 576         uint8_t slot;
 577
 578         player_update_pack = pack.Seq();
 579         pack.ReadPredictedState(player_update_state);
 580         pack.ReadMovement(movement);
 581         pack.ReadActions(new_actions);
 582         pack.ReadSlot(slot);
 583
 584         // accept client's orientation as is
 585         input->GetPlayer().GetEntity().Orientation(player_update_state.orient);
 586         // simulate movement
 587         input->SetMovement(movement);
 588         // rotate head to match client's "prediction"
 589         input->TurnHead(player_update_state.pitch - input->GetPitch(), player_update_state.yaw - input->GetYaw());
 590         // select the given inventory slot
 591         input->SelectInventory(slot);
 592
 593         // check if any actions have been started or stopped
 594         if ((new_actions & 0x01) && !(old_actions & 0x01)) {
 595                 input->StartPrimaryAction();
 596         } else if (!(new_actions & 0x01) && (old_actions & 0x01)) {
 597                 input->StopPrimaryAction();
 598         }
 599         if ((new_actions & 0x02) && !(old_actions & 0x02)) {
 600                 input->StartSecondaryAction();
 601         } else if (!(new_actions & 0x02) && (old_actions & 0x02)) {
 602                 input->StopSecondaryAction();
 603         }
 604         if ((new_actions & 0x04) && !(old_actions & 0x04)) {
 605                 input->StartTertiaryAction();
 606         } else if (!(new_actions & 0x04) && (old_actions & 0x04)) {
 607                 input->StopTertiaryAction();
 608         }
 609         old_actions = new_actions;
 610 }
 611
 612 bool ClientConnection::ChunkInRange(const glm::ivec3 &pos) const noexcept {
 613         return HasPlayer() && PlayerChunks().InRange(pos);
 614 }
 615
 616 void ClientConnection::On(const Packet::ChunkBegin &pack) {
 617         glm::ivec3 pos;
 618         pack.ReadChunkCoords(pos);
 619         if (ChunkInRange(pos)) {
 620                 chunk_queue.push_front(pos);
 621         }
 622 }
 623
 624 void ClientConnection::On(const Packet::Message &pack) {
 625         uint8_t type;
 626         uint32_t ref;
 627         string msg;
 628         pack.ReadType(type);
 629         pack.ReadReferral(ref);
 630         pack.ReadMessage(msg);
 631
 632         if (type == 1 && HasPlayer()) {
 633                 server.DispatchMessage(input->GetPlayer(), msg);
 634         }
 635 }
 636
 637
 638 Server::Server(
 639         const Config::Network &conf,
 640         World &world,
 641         const World::Config &wc,
 642         const WorldSave &save)
 643 : serv_sock(nullptr)
 644 , serv_pack{ -1, nullptr, 0 }
 645 , serv_set(SDLNet_AllocSocketSet(1))
 646 , clients()
 647 , world(world)
 648 , spawn_index(world.Chunks().MakeIndex(wc.spawn, 3))
 649 , save(save)
 650 , player_model(nullptr)
 651 , cli(world) {
 652         if (!serv_set) {
 653                 throw NetError("SDLNet_AllocSocketSet");
 654         }
 655
 656         serv_sock = SDLNet_UDP_Open(conf.port);
 657         if (!serv_sock) {
 658                 SDLNet_FreeSocketSet(serv_set);
 659                 throw NetError("SDLNet_UDP_Open");
 660         }
 661
 662         if (SDLNet_UDP_AddSocket(serv_set, serv_sock) == -1) {
 663                 SDLNet_UDP_Close(serv_sock);
 664                 SDLNet_FreeSocketSet(serv_set);
 665                 throw NetError("SDLNet_UDP_AddSocket");
 666         }
 667
 668         serv_pack.data = new Uint8[sizeof(Packet)];
 669         serv_pack.maxlen = sizeof(Packet);
 670 }
 671
 672 Server::~Server() {
 673         for (ClientConnection &client : clients) {
 674                 client.Disconnected();
 675         }
 676         clients.clear();
 677         world.Chunks().UnregisterIndex(spawn_index);
 678         delete[] serv_pack.data;
 679         SDLNet_UDP_DelSocket(serv_set, serv_sock);
 680         SDLNet_UDP_Close(serv_sock);
 681         SDLNet_FreeSocketSet(serv_set);
 682 }
 683
 684
 685 void Server::Wait(int dt) noexcept {
 686         SDLNet_CheckSockets(serv_set, dt);
 687 }
 688
 689 bool Server::Ready() noexcept {
 690         return SDLNet_CheckSockets(serv_set, 0) > 0;
 691 }
 692
 693 void Server::Handle() {
 694         int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 695         while (result > 0) {
 696                 HandlePacket(serv_pack);
 697                 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 698         }
 699         if (result == -1) {
 700                 // a boo boo happened
 701                 throw NetError("SDLNet_UDP_Recv");
 702         }
 703 }
 704
 705 void Server::HandlePacket(const UDPpacket &udp_pack) {
 706         if (udp_pack.len < int(sizeof(Packet::Header))) {
 707                 // packet too small, drop
 708                 return;
 709         }
 710         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 711         if (pack.header.tag != Packet::TAG) {
 712                 // mistagged packet, drop
 713                 return;
 714         }
 715
 716         ClientConnection &client = GetClient(udp_pack.address);
 717         client.GetConnection().Received(udp_pack);
 718 }
 719
 720 ClientConnection &Server::GetClient(const IPaddress &addr) {
 721         for (ClientConnection &client : clients) {
 722                 if (client.Matches(addr)) {
 723                         return client;
 724                 }
 725         }
 726         clients.emplace_back(*this, addr);
 727         if (HasPlayerModel()) {
 728                 clients.back().SetPlayerModel(GetPlayerModel());
 729         }
 730         return clients.back();
 731 }
 732
 733 void Server::Update(int dt) {
 734         for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
 735                 client->Update(dt);
 736                 if (client->Disconnected()) {
 737                         client = clients.erase(client);
 738                 } else {
 739                         ++client;
 740                 }
 741         }
 742 }
 743
 744 void Server::SetPlayerModel(const Model &m) noexcept {
 745         player_model = &m;
 746         for (ClientConnection &client : clients) {
 747                 client.SetPlayerModel(m);
 748         }
 749 }
 750
 751 bool Server::HasPlayerModel() const noexcept {
 752         return player_model;
 753 }
 754
 755 const Model &Server::GetPlayerModel() const noexcept {
 756         return *player_model;
 757 }
 758
 759 Player *Server::JoinPlayer(const string &name) {
 760         if (spawn_index.MissingChunks() > 0) {
 761                 return nullptr;
 762         }
 763         Player *player = world.AddPlayer(name);
 764         if (!player) {
 765                 return nullptr;
 766         }
 767         if (save.Exists(*player)) {
 768                 save.Read(*player);
 769         } else {
 770                 // TODO: spawn
 771         }
 772         return player;
 773 }
 774
 775 void Server::SetBlock(Chunk &chunk, int index, const Block &block) {
 776         chunk.SetBlock(index, block);
 777         // TODO: batch chunk changes
 778         auto pack = Packet::Make<Packet::BlockUpdate>(GetPacket());
 779         pack.WriteChunkCoords(chunk.Position());
 780         pack.WriteBlockCount(uint32_t(1));
 781         pack.WriteIndex(index, 0);
 782         pack.WriteBlock(chunk.BlockAt(index), 0);
 783         GetPacket().len = sizeof(Packet::Header) + Packet::BlockUpdate::GetSize(1);
 784         for (ClientConnection &client : clients) {
 785                 if (client.ChunkInRange(chunk.Position())) {
 786                         client.Send();
 787                 }
 788         }
 789 }
 790
 791 void Server::DispatchMessage(Player &player, const string &msg) {
 792         if (msg.empty()) {
 793                 return;
 794         }
 795         if (msg[0] == '/' && msg.size() > 1 && msg[1] != '/') {
 796                 cli.Execute(player, msg.substr(1));
 797         } else {
 798                 DistributeMessage(1, player.GetEntity().ID(), msg);
 799         }
 800 }
 801
 802 void Server::DistributeMessage(uint8_t type, uint32_t ref, const string &msg) {
 803         auto pack = Packet::Make<Packet::Message>(serv_pack);
 804         pack.WriteType(type);
 805         pack.WriteReferral(ref);
 806         pack.WriteMessage(msg);
 807         serv_pack.len = sizeof(Packet::Header) + Packet::Message::GetSize(msg);
 808         SendAll();
 809 }
 810
 811 void Server::SendAll() {
 812         for (ClientConnection &client : clients) {
 813                 client.GetConnection().Send(serv_pack, serv_sock);
 814         }
 815 }
 816
 817 }
 818 }