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