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