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 = glm::length2(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         cli_ctx.reset(new NetworkCLIFeedback(player, *this));
 443
 444         old_base = PlayerChunks().Base();
 445         ExactLocation::Coarse begin = PlayerChunks().CoordsBegin();
 446         ExactLocation::Coarse end = PlayerChunks().CoordsEnd();
 447         for (ExactLocation::Coarse pos = begin; pos.z < end.z; ++pos.z) {
 448                 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
 449                         for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
 450                                 chunk_queue.push_back(pos);
 451                         }
 452                 }
 453         }
 454         sort(chunk_queue.begin(), chunk_queue.end(), QueueCompare(old_base));
 455         // TODO: should the server do this?
 456         if (HasPlayerModel()) {
 457                 GetPlayerModel().Instantiate(PlayerEntity().GetModel());
 458         }
 459
 460         string msg = "player \"" + player.Name() + "\" joined";
 461         cout << msg << endl;
 462         server.DistributeMessage(0, 0, msg);
 463 }
 464
 465 void ClientConnection::DetachPlayer() {
 466         if (!HasPlayer()) return;
 467         string msg = "player \"" + input->GetPlayer().Name() + "\" left";
 468         cout << msg << endl;
 469         server.DistributeMessage(0, 0, msg);
 470
 471         server.GetWorldSave().Write(input->GetPlayer());
 472         PlayerEntity().Kill();
 473         PlayerEntity().UnRef();
 474         cli_ctx.reset();
 475         input.reset();
 476         transmitter.Abort();
 477         chunk_queue.clear();
 478         old_actions = 0;
 479 }
 480
 481 void ClientConnection::SetPlayerModel(const Model &m) noexcept {
 482         player_model = &m;
 483         if (HasPlayer()) {
 484                 m.Instantiate(PlayerEntity().GetModel());
 485         }
 486 }
 487
 488 bool ClientConnection::HasPlayerModel() const noexcept {
 489         return player_model;
 490 }
 491
 492 const Model &ClientConnection::GetPlayerModel() const noexcept {
 493         return *player_model;
 494 }
 495
 496 void ClientConnection::OnPacketReceived(uint16_t seq) {
 497         if (transmitter.Waiting()) {
 498                 transmitter.Ack(seq);
 499         }
 500         if (!confirm_wait) return;
 501         for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
 502                 if (seq == iter->spawn_pack) {
 503                         iter->spawn_pack = -1;
 504                         --confirm_wait;
 505                         return;
 506                 }
 507                 if (seq == iter->despawn_pack) {
 508                         spawns.erase(iter);
 509                         --confirm_wait;
 510                         return;
 511                 }
 512         }
 513 }
 514
 515 void ClientConnection::OnPacketLost(uint16_t seq) {
 516         if (transmitter.Waiting()) {
 517                 transmitter.Nack(seq);
 518         }
 519         if (!confirm_wait) return;
 520         for (SpawnStatus &status : spawns) {
 521                 if (seq == status.spawn_pack) {
 522                         status.spawn_pack = -1;
 523                         --confirm_wait;
 524                         SendSpawn(status);
 525                         return;
 526                 }
 527                 if (seq == status.despawn_pack) {
 528                         status.despawn_pack = -1;
 529                         --confirm_wait;
 530                         SendDespawn(status);
 531                         return;
 532                 }
 533         }
 534 }
 535
 536 void ClientConnection::On(const Packet::Login &pack) {
 537         string name;
 538         pack.ReadPlayerName(name);
 539
 540         Player *new_player = server.JoinPlayer(name);
 541
 542         if (new_player) {
 543                 // success!
 544                 AttachPlayer(*new_player);
 545                 cout << "accepted login from player \"" << name << '"' << endl;
 546                 auto response = Prepare<Packet::Join>();
 547                 response.WritePlayer(new_player->GetEntity());
 548                 response.WriteWorldName(server.GetWorld().Name());
 549                 Send();
 550                 // set up update tracking
 551                 player_update_state = new_player->GetEntity().GetState();
 552                 player_update_pack = pack.Seq();
 553                 player_update_timer.Reset();
 554                 player_update_timer.Start();
 555         } else {
 556                 // aw no :(
 557                 cout << "rejected login from player \"" << name << '"' << endl;
 558                 Prepare<Packet::Part>();
 559                 Send();
 560                 conn.Close();
 561         }
 562 }
 563
 564 void ClientConnection::On(const Packet::Part &) {
 565         conn.Close();
 566 }
 567
 568 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
 569         if (!HasPlayer()) return;
 570         int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
 571         bool overdue = player_update_timer.HitOnce();
 572         player_update_timer.Reset();
 573         if (pack_diff <= 0 && !overdue) {
 574                 // drop old packets if we have a fairly recent state
 575                 return;
 576         }
 577         glm::vec3 movement(0.0f);
 578         uint8_t new_actions;
 579         uint8_t slot;
 580
 581         player_update_pack = pack.Seq();
 582         pack.ReadPredictedState(player_update_state);
 583         pack.ReadMovement(movement);
 584         pack.ReadActions(new_actions);
 585         pack.ReadSlot(slot);
 586
 587         // accept client's orientation as is
 588         input->GetPlayer().GetEntity().Orientation(player_update_state.orient);
 589         // simulate movement
 590         input->SetMovement(movement);
 591         // rotate head to match client's "prediction"
 592         input->TurnHead(player_update_state.pitch - input->GetPitch(), player_update_state.yaw - input->GetYaw());
 593         // select the given inventory slot
 594         input->SelectInventory(slot);
 595
 596         // check if any actions have been started or stopped
 597         if ((new_actions & 0x01) && !(old_actions & 0x01)) {
 598                 input->StartPrimaryAction();
 599         } else if (!(new_actions & 0x01) && (old_actions & 0x01)) {
 600                 input->StopPrimaryAction();
 601         }
 602         if ((new_actions & 0x02) && !(old_actions & 0x02)) {
 603                 input->StartSecondaryAction();
 604         } else if (!(new_actions & 0x02) && (old_actions & 0x02)) {
 605                 input->StopSecondaryAction();
 606         }
 607         if ((new_actions & 0x04) && !(old_actions & 0x04)) {
 608                 input->StartTertiaryAction();
 609         } else if (!(new_actions & 0x04) && (old_actions & 0x04)) {
 610                 input->StopTertiaryAction();
 611         }
 612         old_actions = new_actions;
 613 }
 614
 615 bool ClientConnection::ChunkInRange(const glm::ivec3 &pos) const noexcept {
 616         return HasPlayer() && PlayerChunks().InRange(pos);
 617 }
 618
 619 void ClientConnection::On(const Packet::ChunkBegin &pack) {
 620         glm::ivec3 pos;
 621         pack.ReadChunkCoords(pos);
 622         if (ChunkInRange(pos)) {
 623                 chunk_queue.push_front(pos);
 624         }
 625 }
 626
 627 void ClientConnection::On(const Packet::Message &pack) {
 628         uint8_t type;
 629         uint32_t ref;
 630         string msg;
 631         pack.ReadType(type);
 632         pack.ReadReferral(ref);
 633         pack.ReadMessage(msg);
 634
 635         if (type == 1 && cli_ctx) {
 636                 server.DispatchMessage(*cli_ctx, msg);
 637         }
 638 }
 639
 640 uint16_t ClientConnection::SendMessage(uint8_t type, uint32_t from, const string &msg) {
 641         auto pack = Prepare<Packet::Message>();
 642         pack.WriteType(type);
 643         pack.WriteReferral(from);
 644         pack.WriteMessage(msg);
 645         return Send(Packet::Message::GetSize(msg));
 646 }
 647
 648
 649 NetworkCLIFeedback::NetworkCLIFeedback(Player &p, ClientConnection &c)
 650 : CLIContext(p)
 651 , conn(c) {
 652
 653 }
 654
 655 void NetworkCLIFeedback::Error(const string &msg) {
 656         conn.SendMessage(0, 0, msg);
 657 }
 658
 659 void NetworkCLIFeedback::Message(const string &msg) {
 660         conn.SendMessage(0, 0, msg);
 661 }
 662
 663 void NetworkCLIFeedback::Broadcast(const string &msg) {
 664         conn.GetServer().DistributeMessage(0, GetPlayer().GetEntity().ID(), msg);
 665 }
 666
 667
 668 Server::Server(
 669         const Config::Network &conf,
 670         World &world,
 671         const World::Config &wc,
 672         const WorldSave &save)
 673 : serv_sock(nullptr)
 674 , serv_pack{ -1, nullptr, 0 }
 675 , serv_set(SDLNet_AllocSocketSet(1))
 676 , clients()
 677 , world(world)
 678 , spawn_index(world.Chunks().MakeIndex(wc.spawn, 3))
 679 , save(save)
 680 , player_model(nullptr)
 681 , cli(world) {
 682         if (!serv_set) {
 683                 throw NetError("SDLNet_AllocSocketSet");
 684         }
 685
 686         serv_sock = SDLNet_UDP_Open(conf.port);
 687         if (!serv_sock) {
 688                 SDLNet_FreeSocketSet(serv_set);
 689                 throw NetError("SDLNet_UDP_Open");
 690         }
 691
 692         if (SDLNet_UDP_AddSocket(serv_set, serv_sock) == -1) {
 693                 SDLNet_UDP_Close(serv_sock);
 694                 SDLNet_FreeSocketSet(serv_set);
 695                 throw NetError("SDLNet_UDP_AddSocket");
 696         }
 697
 698         serv_pack.data = new Uint8[sizeof(Packet)];
 699         serv_pack.maxlen = sizeof(Packet);
 700 }
 701
 702 Server::~Server() {
 703         for (ClientConnection &client : clients) {
 704                 client.Disconnected();
 705         }
 706         clients.clear();
 707         world.Chunks().UnregisterIndex(spawn_index);
 708         delete[] serv_pack.data;
 709         SDLNet_UDP_DelSocket(serv_set, serv_sock);
 710         SDLNet_UDP_Close(serv_sock);
 711         SDLNet_FreeSocketSet(serv_set);
 712 }
 713
 714
 715 void Server::Wait(int dt) noexcept {
 716         SDLNet_CheckSockets(serv_set, dt);
 717 }
 718
 719 bool Server::Ready() noexcept {
 720         return SDLNet_CheckSockets(serv_set, 0) > 0;
 721 }
 722
 723 void Server::Handle() {
 724         int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 725         while (result > 0) {
 726                 HandlePacket(serv_pack);
 727                 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 728         }
 729         if (result == -1) {
 730                 // a boo boo happened
 731                 throw NetError("SDLNet_UDP_Recv");
 732         }
 733 }
 734
 735 void Server::HandlePacket(const UDPpacket &udp_pack) {
 736         if (udp_pack.len < int(sizeof(Packet::Header))) {
 737                 // packet too small, drop
 738                 return;
 739         }
 740         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 741         if (pack.header.tag != Packet::TAG) {
 742                 // mistagged packet, drop
 743                 return;
 744         }
 745
 746         ClientConnection &client = GetClient(udp_pack.address);
 747         client.GetConnection().Received(udp_pack);
 748 }
 749
 750 ClientConnection &Server::GetClient(const IPaddress &addr) {
 751         for (ClientConnection &client : clients) {
 752                 if (client.Matches(addr)) {
 753                         return client;
 754                 }
 755         }
 756         clients.emplace_back(*this, addr);
 757         if (HasPlayerModel()) {
 758                 clients.back().SetPlayerModel(GetPlayerModel());
 759         }
 760         return clients.back();
 761 }
 762
 763 void Server::Update(int dt) {
 764         for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
 765                 client->Update(dt);
 766                 if (client->Disconnected()) {
 767                         client = clients.erase(client);
 768                 } else {
 769                         ++client;
 770                 }
 771         }
 772 }
 773
 774 void Server::SetPlayerModel(const Model &m) noexcept {
 775         player_model = &m;
 776         for (ClientConnection &client : clients) {
 777                 client.SetPlayerModel(m);
 778         }
 779 }
 780
 781 bool Server::HasPlayerModel() const noexcept {
 782         return player_model;
 783 }
 784
 785 const Model &Server::GetPlayerModel() const noexcept {
 786         return *player_model;
 787 }
 788
 789 Player *Server::JoinPlayer(const string &name) {
 790         if (spawn_index.MissingChunks() > 0) {
 791                 return nullptr;
 792         }
 793         Player *player = world.AddPlayer(name);
 794         if (!player) {
 795                 return nullptr;
 796         }
 797         if (save.Exists(*player)) {
 798                 save.Read(*player);
 799         } else {
 800                 // TODO: spawn
 801         }
 802         return player;
 803 }
 804
 805 void Server::SetBlock(Chunk &chunk, int index, const Block &block) {
 806         chunk.SetBlock(index, block);
 807         // TODO: batch chunk changes
 808         auto pack = Packet::Make<Packet::BlockUpdate>(GetPacket());
 809         pack.WriteChunkCoords(chunk.Position());
 810         pack.WriteBlockCount(uint32_t(1));
 811         pack.WriteIndex(index, 0);
 812         pack.WriteBlock(chunk.BlockAt(index), 0);
 813         GetPacket().len = sizeof(Packet::Header) + Packet::BlockUpdate::GetSize(1);
 814         for (ClientConnection &client : clients) {
 815                 if (client.ChunkInRange(chunk.Position())) {
 816                         client.Send();
 817                 }
 818         }
 819 }
 820
 821 void Server::DispatchMessage(CLIContext &ctx, const string &msg) {
 822         if (msg.empty()) {
 823                 return;
 824         }
 825         if (msg[0] == '/' && msg.size() > 1 && msg[1] != '/') {
 826                 cli.Execute(ctx, msg.substr(1));
 827         } else {
 828                 DistributeMessage(1, ctx.GetPlayer().GetEntity().ID(), msg);
 829         }
 830 }
 831
 832 void Server::DistributeMessage(uint8_t type, uint32_t ref, const string &msg) {
 833         auto pack = Packet::Make<Packet::Message>(serv_pack);
 834         pack.WriteType(type);
 835         pack.WriteReferral(ref);
 836         pack.WriteMessage(msg);
 837         serv_pack.len = sizeof(Packet::Header) + Packet::Message::GetSize(msg);
 838         SendAll();
 839 }
 840
 841 void Server::SendAll() {
 842         for (ClientConnection &client : clients) {
 843                 client.GetConnection().Send(serv_pack, serv_sock);
 844         }
 845 }
 846
 847 }
 848 }