src/net/net.cpp

   1 #include "Client.hpp"
   2 #include "ClientConnection.hpp"
   3 #include "Connection.hpp"
   4 #include "ConnectionHandler.hpp"
   5 #include "io.hpp"
   6 #include "Packet.hpp"
   7 #include "Server.hpp"
   8
   9 #include "../app/init.hpp"
  10 #include "../model/CompositeModel.hpp"
  11 #include "../world/Entity.hpp"
  12 #include "../world/EntityState.hpp"
  13 #include "../world/World.hpp"
  14
  15 #include <cstring>
  16 #include <iostream>
  17 #include <glm/gtx/io.hpp>
  18
  19 using namespace std;
  20
  21
  22 namespace blank {
  23
  24 constexpr size_t Packet::Ping::MAX_LEN;
  25 constexpr size_t Packet::Login::MAX_LEN;
  26 constexpr size_t Packet::Join::MAX_LEN;
  27 constexpr size_t Packet::Part::MAX_LEN;
  28 constexpr size_t Packet::PlayerUpdate::MAX_LEN;
  29 constexpr size_t Packet::SpawnEntity::MAX_LEN;
  30 constexpr size_t Packet::DespawnEntity::MAX_LEN;
  31 constexpr size_t Packet::EntityUpdate::MAX_LEN;
  32 constexpr size_t Packet::PlayerCorrection::MAX_LEN;
  33
  34 namespace {
  35
  36 UDPsocket client_bind(Uint16 port) {
  37         UDPsocket sock = SDLNet_UDP_Open(port);
  38         if (!sock) {
  39                 throw NetError("SDLNet_UDP_Open");
  40         }
  41         return sock;
  42 }
  43
  44 IPaddress client_resolve(const char *host, Uint16 port) {
  45         IPaddress addr;
  46         if (SDLNet_ResolveHost(&addr, host, port) != 0) {
  47                 throw NetError("SDLNet_ResolveHost");
  48         }
  49         return addr;
  50 }
  51
  52 }
  53
  54 Client::Client(const Config &conf)
  55 : conn(client_resolve(conf.host.c_str(), conf.port))
  56 , client_sock(client_bind(0))
  57 , client_pack{ -1, nullptr, 0 } {
  58         client_pack.data = new Uint8[sizeof(Packet)];
  59         client_pack.maxlen = sizeof(Packet);
  60         // establish connection
  61         SendPing();
  62 }
  63
  64 Client::~Client() {
  65         delete[] client_pack.data;
  66         SDLNet_UDP_Close(client_sock);
  67 }
  68
  69
  70 void Client::Handle() {
  71         int result = SDLNet_UDP_Recv(client_sock, &client_pack);
  72         while (result > 0) {
  73                 HandlePacket(client_pack);
  74                 result = SDLNet_UDP_Recv(client_sock, &client_pack);
  75         }
  76         if (result == -1) {
  77                 // a boo boo happened
  78                 throw NetError("SDLNet_UDP_Recv");
  79         }
  80 }
  81
  82 void Client::HandlePacket(const UDPpacket &udp_pack) {
  83         if (!conn.Matches(udp_pack.address)) {
  84                 // packet came from somewhere else, drop
  85                 return;
  86         }
  87         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
  88         if (pack.header.tag != Packet::TAG) {
  89                 // mistagged packet, drop
  90                 return;
  91         }
  92
  93         conn.Received(udp_pack);
  94 }
  95
  96 void Client::Update(int dt) {
  97         conn.Update(dt);
  98         if (conn.ShouldPing()) {
  99                 SendPing();
 100         }
 101 }
 102
 103 uint16_t Client::SendPing() {
 104         return conn.SendPing(client_pack, client_sock);
 105 }
 106
 107 uint16_t Client::SendLogin(const string &name) {
 108         auto pack = Packet::Make<Packet::Login>(client_pack);
 109         pack.WritePlayerName(name);
 110         return conn.Send(client_pack, client_sock);
 111 }
 112
 113 uint16_t Client::SendPlayerUpdate(const Entity &player) {
 114         auto pack = Packet::Make<Packet::PlayerUpdate>(client_pack);
 115         pack.WritePlayer(player);
 116         return conn.Send(client_pack, client_sock);
 117 }
 118
 119 uint16_t Client::SendPart() {
 120         Packet::Make<Packet::Part>(client_pack);
 121         return conn.Send(client_pack, client_sock);
 122 }
 123
 124
 125 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
 126 : server(server)
 127 , conn(addr)
 128 , player(nullptr)
 129 , spawns()
 130 , confirm_wait(0)
 131 , player_update_pack(0)
 132 , player_update_timer(1500) {
 133         conn.SetHandler(this);
 134 }
 135
 136 ClientConnection::~ClientConnection() {
 137         DetachPlayer();
 138 }
 139
 140 void ClientConnection::Update(int dt) {
 141         conn.Update(dt);
 142         if (Disconnected()) {
 143                 return;
 144         }
 145         if (HasPlayer()) {
 146                 // sync entities
 147                 auto global_iter = server.GetWorld().Entities().begin();
 148                 auto global_end = server.GetWorld().Entities().end();
 149                 auto local_iter = spawns.begin();
 150                 auto local_end = spawns.end();
 151
 152                 while (global_iter != global_end && local_iter != local_end) {
 153                         if (global_iter->ID() == local_iter->entity->ID()) {
 154                                 // they're the same
 155                                 if (CanDespawn(*global_iter)) {
 156                                         SendDespawn(*local_iter);
 157                                 } else {
 158                                         // update
 159                                         SendUpdate(*local_iter);
 160                                 }
 161                                 ++global_iter;
 162                                 ++local_iter;
 163                         } else if (global_iter->ID() < local_iter->entity->ID()) {
 164                                 // global entity was inserted
 165                                 if (CanSpawn(*global_iter)) {
 166                                         auto spawned = spawns.emplace(local_iter, *global_iter);
 167                                         SendSpawn(*spawned);
 168                                 }
 169                                 ++global_iter;
 170                         } else {
 171                                 // global entity was removed
 172                                 SendDespawn(*local_iter);
 173                                 ++local_iter;
 174                         }
 175                 }
 176
 177                 // leftover spawns
 178                 while (global_iter != global_end) {
 179                         if (CanSpawn(*global_iter)) {
 180                                 spawns.emplace_back(*global_iter);
 181                                 SendSpawn(spawns.back());
 182                         }
 183                         ++global_iter;
 184                 }
 185
 186                 // leftover despawns
 187                 while (local_iter != local_end) {
 188                         SendDespawn(*local_iter);
 189                         ++local_iter;
 190                 }
 191
 192                 CheckPlayerFix();
 193         }
 194         if (conn.ShouldPing()) {
 195                 conn.SendPing(server.GetPacket(), server.GetSocket());
 196         }
 197 }
 198
 199 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
 200 : entity(&e)
 201 , spawn_pack(-1)
 202 , despawn_pack(-1) {
 203         entity->Ref();
 204 }
 205
 206 ClientConnection::SpawnStatus::~SpawnStatus() {
 207         entity->UnRef();
 208 }
 209
 210 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
 211         return
 212                 &e != player &&
 213                 !e.Dead() &&
 214                 manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) < 7;
 215 }
 216
 217 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
 218         return
 219                 e.Dead() ||
 220                 manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) > 7;
 221 }
 222
 223 void ClientConnection::SendSpawn(SpawnStatus &status) {
 224         // don't double spawn
 225         if (status.spawn_pack != -1) return;
 226
 227         auto pack = Packet::Make<Packet::SpawnEntity>(server.GetPacket());
 228         pack.WriteEntity(*status.entity);
 229         status.spawn_pack = conn.Send(server.GetPacket(), server.GetSocket());
 230         ++confirm_wait;
 231 }
 232
 233 void ClientConnection::SendDespawn(SpawnStatus &status) {
 234         // don't double despawn
 235         if (status.despawn_pack != -1) return;
 236
 237         auto pack = Packet::Make<Packet::DespawnEntity>(server.GetPacket());
 238         pack.WriteEntityID(status.entity->ID());
 239         status.despawn_pack = conn.Send(server.GetPacket(), server.GetSocket());
 240         ++confirm_wait;
 241 }
 242
 243 void ClientConnection::SendUpdate(SpawnStatus &status) {
 244         // don't send updates while spawn not ack'd or despawn sent
 245         if (status.spawn_pack != -1 || status.despawn_pack != -1) return;
 246
 247         // TODO: pack entity updates
 248         auto pack = Packet::Make<Packet::EntityUpdate>(server.GetPacket());
 249         pack.WriteEntityCount(1);
 250         pack.WriteEntity(*status.entity, 0);
 251         server.GetPacket().len = Packet::EntityUpdate::GetSize(1);
 252         conn.Send(server.GetPacket(), server.GetSocket());
 253 }
 254
 255 void ClientConnection::CheckPlayerFix() {
 256         // check always succeeds for now ;)
 257         auto pack = Packet::Make<Packet::PlayerCorrection>(server.GetPacket());
 258         pack.WritePacketSeq(player_update_pack);
 259         pack.WritePlayer(Player());
 260         conn.Send(server.GetPacket(), server.GetSocket());
 261 }
 262
 263 void ClientConnection::AttachPlayer(Entity &new_player) {
 264         DetachPlayer();
 265         player = &new_player;
 266         player->Ref();
 267         cout << "player \"" << player->Name() << "\" joined" << endl;
 268 }
 269
 270 void ClientConnection::DetachPlayer() {
 271         if (!player) return;
 272         player->Kill();
 273         player->UnRef();
 274         cout << "player \"" << player->Name() << "\" left" << endl;
 275         player = nullptr;
 276 }
 277
 278 void ClientConnection::OnPacketReceived(uint16_t seq) {
 279         if (!confirm_wait) return;
 280         for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
 281                 if (seq == iter->spawn_pack) {
 282                         iter->spawn_pack = -1;
 283                         --confirm_wait;
 284                         return;
 285                 }
 286                 if (seq == iter->despawn_pack) {
 287                         spawns.erase(iter);
 288                         --confirm_wait;
 289                         return;
 290                 }
 291         }
 292 }
 293
 294 void ClientConnection::OnPacketLost(uint16_t seq) {
 295         if (!confirm_wait) return;
 296         for (SpawnStatus &status : spawns) {
 297                 if (seq == status.spawn_pack) {
 298                         status.spawn_pack = -1;
 299                         --confirm_wait;
 300                         SendSpawn(status);
 301                         return;
 302                 }
 303                 if (seq == status.despawn_pack) {
 304                         status.despawn_pack = -1;
 305                         --confirm_wait;
 306                         SendDespawn(status);
 307                         return;
 308                 }
 309         }
 310 }
 311
 312 void ClientConnection::On(const Packet::Login &pack) {
 313         string name;
 314         pack.ReadPlayerName(name);
 315
 316         Entity *new_player = server.GetWorld().AddPlayer(name).entity;
 317
 318         if (new_player) {
 319                 // success!
 320                 AttachPlayer(*new_player);
 321                 cout << "accepted login from player \"" << name << '"' << endl;
 322                 auto response = Packet::Make<Packet::Join>(server.GetPacket());
 323                 response.WritePlayer(*new_player);
 324                 response.WriteWorldName(server.GetWorld().Name());
 325                 conn.Send(server.GetPacket(), server.GetSocket());
 326                 // set up update tracking
 327                 player_update_pack = pack.Seq();
 328                 player_update_timer.Reset();
 329                 player_update_timer.Start();
 330         } else {
 331                 // aw no :(
 332                 cout << "rejected login from player \"" << name << '"' << endl;
 333                 Packet::Make<Packet::Part>(server.GetPacket());
 334                 conn.Send(server.GetPacket(), server.GetSocket());
 335                 conn.Close();
 336         }
 337 }
 338
 339 void ClientConnection::On(const Packet::Part &) {
 340         conn.Close();
 341 }
 342
 343 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
 344         if (!HasPlayer()) return;
 345         int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
 346         bool overdue = player_update_timer.HitOnce();
 347         player_update_timer.Reset();
 348         if (pack_diff > 0 || overdue) {
 349                 player_update_pack = pack.Seq();
 350                 // TODO: do client input validation here
 351                 EntityState new_state;
 352                 pack.ReadPlayerState(new_state);
 353                 Player().Velocity(new_state.velocity);
 354                 Player().Orientation(new_state.orient);
 355         }
 356 }
 357
 358
 359 Connection::Connection(const IPaddress &addr)
 360 : handler(nullptr)
 361 , addr(addr)
 362 , send_timer(500)
 363 , recv_timer(10000)
 364 , ctrl_out{ 0, 0xFFFF, 0xFFFFFFFF }
 365 , ctrl_in{ 0, 0xFFFF, 0xFFFFFFFF }
 366 , closed(false) {
 367         send_timer.Start();
 368         recv_timer.Start();
 369 }
 370
 371 bool Connection::Matches(const IPaddress &remote) const noexcept {
 372         return memcmp(&addr, &remote, sizeof(IPaddress)) == 0;
 373 }
 374
 375 void Connection::FlagSend() noexcept {
 376         send_timer.Reset();
 377 }
 378
 379 void Connection::FlagRecv() noexcept {
 380         recv_timer.Reset();
 381 }
 382
 383 bool Connection::ShouldPing() const noexcept {
 384         return !closed && send_timer.HitOnce();
 385 }
 386
 387 bool Connection::TimedOut() const noexcept {
 388         return recv_timer.HitOnce();
 389 }
 390
 391 void Connection::Update(int dt) {
 392         send_timer.Update(dt);
 393         recv_timer.Update(dt);
 394         if (TimedOut()) {
 395                 Close();
 396                 if (HasHandler()) {
 397                         Handler().OnTimeout();
 398                 }
 399         }
 400 }
 401
 402
 403 uint16_t Connection::Send(UDPpacket &udp_pack, UDPsocket sock) {
 404         Packet &pack = *reinterpret_cast<Packet *>(udp_pack.data);
 405         pack.header.ctrl = ctrl_out;
 406         uint16_t seq = ctrl_out.seq++;
 407
 408         udp_pack.address = addr;
 409         if (SDLNet_UDP_Send(sock, -1, &udp_pack) == 0) {
 410                 throw NetError("SDLNet_UDP_Send");
 411         }
 412
 413         FlagSend();
 414         return seq;
 415 }
 416
 417 void Connection::Received(const UDPpacket &udp_pack) {
 418         Packet &pack = *reinterpret_cast<Packet *>(udp_pack.data);
 419
 420         // ack to the remote
 421         int16_t diff = int16_t(pack.header.ctrl.seq) - int16_t(ctrl_out.ack);
 422         if (diff > 0) {
 423                 if (diff >= 32) {
 424                         ctrl_out.hist = 0;
 425                 } else {
 426                         ctrl_out.hist <<= diff;
 427                         ctrl_out.hist |= 1 << (diff - 1);
 428                 }
 429         } else if (diff < 0 && diff >= -32) {
 430                 ctrl_out.hist |= 1 << (-diff - 1);
 431         }
 432         ctrl_out.ack = pack.header.ctrl.seq;
 433         FlagRecv();
 434
 435         if (!HasHandler()) {
 436                 return;
 437         }
 438
 439         Packet::TControl ctrl_new = pack.header.ctrl;
 440         Handler().Handle(udp_pack);
 441
 442         if (diff > 0) {
 443                 // if the packet holds more recent information
 444                 // check if remote failed to ack one of our packets
 445                 diff = int16_t(ctrl_new.ack) - int16_t(ctrl_in.ack);
 446                 // should always be true, but you never know…
 447                 if (diff > 0) {
 448                         for (int i = 0; i < diff; ++i) {
 449                                 if (i > 32 || (i < 32 && (ctrl_in.hist & (1 << (31 - i))) == 0)) {
 450                                         Handler().OnPacketLost(ctrl_in.ack - 32 + i);
 451                                 }
 452                         }
 453                 }
 454                 // check for newly ack'd packets
 455                 for (uint16_t s = ctrl_new.AckBegin(); s != ctrl_new.AckEnd(); ++s) {
 456                         if (ctrl_new.Acks(s) && !ctrl_in.Acks(s)) {
 457                                 Handler().OnPacketReceived(s);
 458                         }
 459                 }
 460                 ctrl_in = ctrl_new;
 461         }
 462 }
 463
 464 bool Packet::TControl::Acks(uint16_t s) const noexcept {
 465         int16_t diff = int16_t(ack) - int16_t(s);
 466         if (diff == 0) return true;
 467         if (diff < 0 || diff > 32) return false;
 468         return (hist & (1 << (diff - 1))) != 0;
 469 }
 470
 471 uint16_t Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) {
 472         Packet::Make<Packet::Ping>(udp_pack);
 473         return Send(udp_pack, sock);
 474 }
 475
 476
 477 ostream &operator <<(ostream &out, const IPaddress &addr) {
 478         const unsigned char *host = reinterpret_cast<const unsigned char *>(&addr.host);
 479         out << int(host[0])
 480                 << '.' << int(host[1])
 481                 << '.' << int(host[2])
 482                 << '.' << int(host[3]);
 483         if (addr.port) {
 484                 out << ':' << SDLNet_Read16(&addr.port);
 485         }
 486         return out;
 487 }
 488
 489
 490 const char *Packet::Type2String(uint8_t t) noexcept {
 491         switch (t) {
 492                 case Ping::TYPE:
 493                         return "Ping";
 494                 case Login::TYPE:
 495                         return "Login";
 496                 case Join::TYPE:
 497                         return "Join";
 498                 case Part::TYPE:
 499                         return "Part";
 500                 case PlayerUpdate::TYPE:
 501                         return "PlayerUpdate";
 502                 case SpawnEntity::TYPE:
 503                         return "SpawnEntity";
 504                 case DespawnEntity::TYPE:
 505                         return "DespawnEntity";
 506                 case EntityUpdate::TYPE:
 507                         return "EntityUpdate";
 508                 case PlayerCorrection::TYPE:
 509                         return "PlayerCorrection";
 510                 default:
 511                         return "Unknown";
 512         }
 513 }
 514
 515 template<class T>
 516 void Packet::Payload::Write(const T &src, size_t off) noexcept {
 517         if ((length - off) < sizeof(T)) {
 518                 // dismiss out of bounds write
 519                 return;
 520         }
 521         *reinterpret_cast<T *>(&data[off]) = src;
 522 }
 523
 524 template<class T>
 525 void Packet::Payload::Read(T &dst, size_t off) const noexcept {
 526         if ((length - off) < sizeof(T)) {
 527                 // dismiss out of bounds read
 528                 return;
 529         }
 530         dst = *reinterpret_cast<T *>(&data[off]);
 531 }
 532
 533 void Packet::Payload::WriteString(const string &src, size_t off, size_t maxlen) noexcept {
 534         uint8_t *dst = &data[off];
 535         size_t len = min(maxlen, length - off);
 536         if (src.size() < len) {
 537                 memset(dst, '\0', len);
 538                 memcpy(dst, src.c_str(), src.size());
 539         } else {
 540                 memcpy(dst, src.c_str(), len);
 541         }
 542 }
 543
 544 void Packet::Payload::ReadString(string &dst, size_t off, size_t maxlen) const noexcept {
 545         size_t len = min(maxlen, length - off);
 546         dst.clear();
 547         dst.reserve(len);
 548         for (size_t i = 0; i < len && data[off + i] != '\0'; ++i) {
 549                 dst.push_back(data[off + i]);
 550         }
 551 }
 552
 553
 554 void Packet::Login::WritePlayerName(const string &name) noexcept {
 555         WriteString(name, 0, 32);
 556 }
 557
 558 void Packet::Login::ReadPlayerName(string &name) const noexcept {
 559         ReadString(name, 0, 32);
 560 }
 561
 562 void Packet::Join::WritePlayer(const Entity &player) noexcept {
 563         Write(player.ID(), 0);
 564         Write(player.GetState(), 4);
 565 }
 566
 567 void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept {
 568         Read(id, 0);
 569 }
 570
 571 void Packet::Join::ReadPlayerState(EntityState &state) const noexcept {
 572         Read(state, 4);
 573 }
 574
 575 void Packet::Join::WriteWorldName(const string &name) noexcept {
 576         WriteString(name, 68, 32);
 577 }
 578
 579 void Packet::Join::ReadWorldName(string &name) const noexcept {
 580         ReadString(name, 68, 32);
 581 }
 582
 583 void Packet::PlayerUpdate::WritePlayer(const Entity &player) noexcept {
 584         Write(player.GetState(), 0);
 585 }
 586
 587 void Packet::PlayerUpdate::ReadPlayerState(EntityState &state) const noexcept {
 588         Read(state, 0);
 589 }
 590
 591 void Packet::SpawnEntity::WriteEntity(const Entity &e) noexcept {
 592         Write(e.ID(), 0);
 593         if (e.GetModel()) {
 594                 Write(e.GetModel().GetModel().ID(), 4);
 595         } else {
 596                 Write(uint32_t(0), 4);
 597         }
 598         Write(e.GetState(), 8);
 599         Write(e.Bounds(), 72);
 600         uint32_t flags = 0;
 601         if (e.WorldCollidable()) {
 602                 flags |= 1;
 603         }
 604         Write(flags, 96);
 605         WriteString(e.Name(), 100, 32);
 606 }
 607
 608 void Packet::SpawnEntity::ReadEntityID(uint32_t &id) const noexcept {
 609         Read(id, 0);
 610 }
 611
 612 void Packet::SpawnEntity::ReadSkeletonID(uint32_t &id) const noexcept {
 613         Read(id, 4);
 614 }
 615
 616 void Packet::SpawnEntity::ReadEntity(Entity &e) const noexcept {
 617         EntityState state;
 618         AABB bounds;
 619         uint32_t flags = 0;
 620         string name;
 621
 622         Read(state, 8);
 623         Read(bounds, 72);
 624         Read(flags, 96);
 625         ReadString(name, 100, 32);
 626
 627         e.SetState(state);
 628         e.Bounds(bounds);
 629         e.WorldCollidable(flags & 1);
 630         e.Name(name);
 631 }
 632
 633 void Packet::DespawnEntity::WriteEntityID(uint32_t id) noexcept {
 634         Write(id, 0);
 635 }
 636
 637 void Packet::DespawnEntity::ReadEntityID(uint32_t &id) const noexcept {
 638         Read(id, 0);
 639 }
 640
 641 void Packet::EntityUpdate::WriteEntityCount(uint32_t count) noexcept {
 642         Write(count, 0);
 643 }
 644
 645 void Packet::EntityUpdate::ReadEntityCount(uint32_t &count) const noexcept {
 646         Read(count, 0);
 647 }
 648
 649 void Packet::EntityUpdate::WriteEntity(const Entity &entity, uint32_t num) noexcept {
 650         uint32_t off = 4 + (num * 64);
 651
 652         Write(entity.ID(), off);
 653         Write(entity.GetState(), off + 4);
 654 }
 655
 656 void Packet::EntityUpdate::ReadEntityID(uint32_t &id, uint32_t num) const noexcept {
 657         Read(id, 4 + (num * 64));
 658 }
 659
 660 void Packet::EntityUpdate::ReadEntityState(EntityState &state, uint32_t num) const noexcept {
 661         uint32_t off = 4 + (num * 64);
 662         Read(state, off + 4);
 663 }
 664
 665 void Packet::PlayerCorrection::WritePacketSeq(std::uint16_t s) noexcept {
 666         Write(s, 0);
 667 }
 668
 669 void Packet::PlayerCorrection::ReadPacketSeq(std::uint16_t &s) const noexcept {
 670         Read(s, 0);
 671 }
 672
 673 void Packet::PlayerCorrection::WritePlayer(const Entity &player) noexcept {
 674         Write(player.GetState(), 2);
 675 }
 676
 677 void Packet::PlayerCorrection::ReadPlayerState(EntityState &state) const noexcept {
 678         Read(state, 2);
 679 }
 680
 681
 682 void ConnectionHandler::Handle(const UDPpacket &udp_pack) {
 683         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 684         switch (pack.Type()) {
 685                 case Packet::Ping::TYPE:
 686                         On(Packet::As<Packet::Ping>(udp_pack));
 687                         break;
 688                 case Packet::Login::TYPE:
 689                         On(Packet::As<Packet::Login>(udp_pack));
 690                         break;
 691                 case Packet::Join::TYPE:
 692                         On(Packet::As<Packet::Join>(udp_pack));
 693                         break;
 694                 case Packet::Part::TYPE:
 695                         On(Packet::As<Packet::Part>(udp_pack));
 696                         break;
 697                 case Packet::PlayerUpdate::TYPE:
 698                         On(Packet::As<Packet::PlayerUpdate>(udp_pack));
 699                         break;
 700                 case Packet::SpawnEntity::TYPE:
 701                         On(Packet::As<Packet::SpawnEntity>(udp_pack));
 702                         break;
 703                 case Packet::DespawnEntity::TYPE:
 704                         On(Packet::As<Packet::DespawnEntity>(udp_pack));
 705                         break;
 706                 case Packet::EntityUpdate::TYPE:
 707                         On(Packet::As<Packet::EntityUpdate>(udp_pack));
 708                         break;
 709                 case Packet::PlayerCorrection::TYPE:
 710                         On(Packet::As<Packet::PlayerCorrection>(udp_pack));
 711                         break;
 712                 default:
 713                         // drop unknown or unhandled packets
 714                         break;
 715         }
 716 }
 717
 718
 719 Server::Server(const Config &conf, World &world)
 720 : serv_sock(nullptr)
 721 , serv_pack{ -1, nullptr, 0 }
 722 , clients()
 723 , world(world) {
 724         serv_sock = SDLNet_UDP_Open(conf.port);
 725         if (!serv_sock) {
 726                 throw NetError("SDLNet_UDP_Open");
 727         }
 728
 729         serv_pack.data = new Uint8[sizeof(Packet)];
 730         serv_pack.maxlen = sizeof(Packet);
 731 }
 732
 733 Server::~Server() {
 734         delete[] serv_pack.data;
 735         SDLNet_UDP_Close(serv_sock);
 736 }
 737
 738
 739 void Server::Handle() {
 740         int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 741         while (result > 0) {
 742                 HandlePacket(serv_pack);
 743                 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
 744         }
 745         if (result == -1) {
 746                 // a boo boo happened
 747                 throw NetError("SDLNet_UDP_Recv");
 748         }
 749 }
 750
 751 void Server::HandlePacket(const UDPpacket &udp_pack) {
 752         if (udp_pack.len < int(sizeof(Packet::Header))) {
 753                 // packet too small, drop
 754                 return;
 755         }
 756         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
 757         if (pack.header.tag != Packet::TAG) {
 758                 // mistagged packet, drop
 759                 return;
 760         }
 761
 762         ClientConnection &client = GetClient(udp_pack.address);
 763         client.GetConnection().Received(udp_pack);
 764 }
 765
 766 ClientConnection &Server::GetClient(const IPaddress &addr) {
 767         for (ClientConnection &client : clients) {
 768                 if (client.Matches(addr)) {
 769                         return client;
 770                 }
 771         }
 772         clients.emplace_back(*this, addr);
 773         return clients.back();
 774 }
 775
 776 void Server::Update(int dt) {
 777         for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
 778                 client->Update(dt);
 779                 if (client->Disconnected()) {
 780                         client = clients.erase(client);
 781                 } else {
 782                         ++client;
 783                 }
 784         }
 785 }
 786
 787 }