2 #include "ClientConnection.hpp"
3 #include "Connection.hpp"
4 #include "ConnectionHandler.hpp"
9 #include "../app/init.hpp"
10 #include "../world/World.hpp"
14 #include <glm/gtx/io.hpp>
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;
32 UDPsocket client_bind(Uint16 port) {
33 UDPsocket sock = SDLNet_UDP_Open(port);
35 throw NetError("SDLNet_UDP_Open");
40 IPaddress client_resolve(const char *host, Uint16 port) {
42 if (SDLNet_ResolveHost(&addr, host, port) != 0) {
43 throw NetError("SDLNet_ResolveHost");
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
61 delete[] client_pack.data;
62 SDLNet_UDP_Close(client_sock);
66 void Client::Handle() {
67 int result = SDLNet_UDP_Recv(client_sock, &client_pack);
69 HandlePacket(client_pack);
70 result = SDLNet_UDP_Recv(client_sock, &client_pack);
74 throw NetError("SDLNet_UDP_Recv");
78 void Client::HandlePacket(const UDPpacket &udp_pack) {
79 if (!conn.Matches(udp_pack.address)) {
80 // packet came from somewhere else, drop
83 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
84 if (pack.header.tag != Packet::TAG) {
85 // mistagged packet, drop
89 conn.Received(udp_pack);
92 void Client::Update(int dt) {
94 if (conn.ShouldPing()) {
99 uint16_t Client::SendPing() {
100 return conn.SendPing(client_pack, client_sock);
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);
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);
115 uint16_t Client::SendPart() {
116 Packet::Make<Packet::Part>(client_pack);
117 return conn.Send(client_pack, client_sock);
121 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
127 conn.SetHandler(this);
130 ClientConnection::~ClientConnection() {
134 void ClientConnection::Update(int dt) {
136 if (Disconnected()) {
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();
146 while (global_iter != global_end && local_iter != local_end) {
147 if (global_iter->ID() == local_iter->entity->ID()) {
149 if (CanDespawn(*global_iter)) {
150 SendDespawn(*local_iter);
153 SendUpdate(*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);
165 // global entity was removed
166 SendDespawn(*local_iter);
172 while (global_iter != global_end) {
173 if (CanSpawn(*global_iter)) {
174 spawns.emplace_back(*global_iter);
175 SendSpawn(spawns.back());
181 while (local_iter != local_end) {
182 SendDespawn(*local_iter);
186 if (conn.ShouldPing()) {
187 conn.SendPing(server.GetPacket(), server.GetSocket());
191 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
198 ClientConnection::SpawnStatus::~SpawnStatus() {
202 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
206 manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) < 7;
209 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
212 manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) > 7;
215 void ClientConnection::SendSpawn(SpawnStatus &status) {
216 // don't double spawn
217 if (status.spawn_pack != -1) return;
219 auto pack = Packet::Make<Packet::SpawnEntity>(server.GetPacket());
220 pack.WriteEntity(*status.entity);
221 status.spawn_pack = conn.Send(server.GetPacket(), server.GetSocket());
225 void ClientConnection::SendDespawn(SpawnStatus &status) {
226 // don't double despawn
227 if (status.despawn_pack != -1) return;
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());
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;
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());
247 void ClientConnection::AttachPlayer(Entity &new_player) {
249 player = &new_player;
251 cout << "player \"" << player->Name() << "\" joined" << endl;
254 void ClientConnection::DetachPlayer() {
258 cout << "player \"" << player->Name() << "\" left" << endl;
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;
270 if (seq == iter->despawn_pack) {
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;
287 if (seq == status.despawn_pack) {
288 status.despawn_pack = -1;
296 void ClientConnection::On(const Packet::Login &pack) {
298 pack.ReadPlayerName(name);
300 Entity *new_player = server.GetWorld().AddPlayer(name);
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());
312 cout << "rejected login from player \"" << name << '"' << endl;
313 Packet::Make<Packet::Part>(server.GetPacket());
314 conn.Send(server.GetPacket(), server.GetSocket());
319 void ClientConnection::On(const Packet::Part &) {
323 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
324 if (!HasPlayer()) return;
325 pack.ReadPlayer(Player());
329 Connection::Connection(const IPaddress &addr)
334 , ctrl_out{ 0, 0xFFFF, 0xFFFFFFFF }
335 , ctrl_in{ 0, 0xFFFF, 0xFFFFFFFF }
341 bool Connection::Matches(const IPaddress &remote) const noexcept {
342 return memcmp(&addr, &remote, sizeof(IPaddress)) == 0;
345 void Connection::FlagSend() noexcept {
349 void Connection::FlagRecv() noexcept {
353 bool Connection::ShouldPing() const noexcept {
354 return !closed && send_timer.HitOnce();
357 bool Connection::TimedOut() const noexcept {
358 return recv_timer.HitOnce();
361 void Connection::Update(int dt) {
362 send_timer.Update(dt);
363 recv_timer.Update(dt);
367 Handler().OnTimeout();
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++;
378 udp_pack.address = addr;
379 if (SDLNet_UDP_Send(sock, -1, &udp_pack) == 0) {
380 throw NetError("SDLNet_UDP_Send");
387 void Connection::Received(const UDPpacket &udp_pack) {
388 Packet &pack = *reinterpret_cast<Packet *>(udp_pack.data);
391 int16_t diff = int16_t(pack.header.ctrl.seq) - int16_t(ctrl_out.ack);
396 ctrl_out.hist <<= diff;
397 ctrl_out.hist |= 1 << (diff - 1);
399 } else if (diff < 0 && diff >= -32) {
400 ctrl_out.hist |= 1 << (-diff - 1);
402 ctrl_out.ack = pack.header.ctrl.seq;
409 Packet::TControl ctrl_new = pack.header.ctrl;
410 Handler().Handle(udp_pack);
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…
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);
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);
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;
441 uint16_t Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) {
442 Packet::Make<Packet::Ping>(udp_pack);
443 return Send(udp_pack, sock);
447 ostream &operator <<(ostream &out, const IPaddress &addr) {
448 const unsigned char *host = reinterpret_cast<const unsigned char *>(&addr.host);
450 << '.' << int(host[1])
451 << '.' << int(host[2])
452 << '.' << int(host[3]);
454 out << ':' << SDLNet_Read16(&addr.port);
460 const char *Packet::Type2String(uint8_t t) noexcept {
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";
484 void Packet::Payload::Write(const T &src, size_t off) noexcept {
485 if ((length - off) < sizeof(T)) {
486 // dismiss out of bounds write
489 *reinterpret_cast<T *>(&data[off]) = src;
493 void Packet::Payload::Read(T &dst, size_t off) const noexcept {
494 if ((length - off) < sizeof(T)) {
495 // dismiss out of bounds read
498 dst = *reinterpret_cast<T *>(&data[off]);
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());
508 memcpy(dst, src.c_str(), len);
512 void Packet::Payload::ReadString(string &dst, size_t off, size_t maxlen) const noexcept {
513 size_t len = min(maxlen, length - off);
516 for (size_t i = 0; i < len && data[off + i] != '\0'; ++i) {
517 dst.push_back(data[off + i]);
522 void Packet::Login::WritePlayerName(const string &name) noexcept {
523 WriteString(name, 0, 32);
526 void Packet::Login::ReadPlayerName(string &name) const noexcept {
527 ReadString(name, 0, 32);
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);
539 void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept {
543 void Packet::Join::ReadPlayer(Entity &player) const noexcept {
544 glm::ivec3 chunk_coords(0);
550 Read(chunk_coords, 4);
556 player.Position(chunk_coords, pos);
557 player.Velocity(vel);
558 player.Orientation(rot);
559 player.AngularVelocity(ang);
562 void Packet::Join::WriteWorldName(const string &name) noexcept {
563 WriteString(name, 68, 32);
566 void Packet::Join::ReadWorldName(string &name) const noexcept {
567 ReadString(name, 68, 32);
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);
578 void Packet::PlayerUpdate::ReadPlayer(Entity &player) const noexcept {
579 glm::ivec3 chunk_coords(0);
585 Read(chunk_coords, 0);
591 player.Position(chunk_coords, pos);
592 player.Velocity(vel);
593 player.Orientation(rot);
594 player.AngularVelocity(ang);
597 void Packet::SpawnEntity::WriteEntity(const Entity &e) noexcept {
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);
606 if (e.WorldCollidable()) {
610 WriteString(e.Name(), 96, 32);
613 void Packet::SpawnEntity::ReadEntityID(uint32_t &id) const noexcept {
617 void Packet::SpawnEntity::ReadEntity(Entity &e) const noexcept {
618 glm::ivec3 chunk_coords(0);
627 Read(chunk_coords, 4);
634 ReadString(name, 96, 32);
636 e.Position(chunk_coords, pos);
639 e.AngularVelocity(ang);
641 e.WorldCollidable(flags & 1);
645 void Packet::DespawnEntity::WriteEntityID(uint32_t id) noexcept {
649 void Packet::DespawnEntity::ReadEntityID(uint32_t &id) const noexcept {
653 void Packet::EntityUpdate::WriteEntityCount(uint32_t count) noexcept {
657 void Packet::EntityUpdate::ReadEntityCount(uint32_t &count) const noexcept {
661 void Packet::EntityUpdate::WriteEntity(const Entity &entity, uint32_t num) noexcept {
662 uint32_t off = 4 + (num * 64);
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);
672 void Packet::EntityUpdate::ReadEntityID(uint32_t &id, uint32_t num) const noexcept {
673 Read(id, 4 + (num * 64));
676 void Packet::EntityUpdate::ReadEntity(Entity &entity, uint32_t num) const noexcept {
677 uint32_t off = 4 + (num * 64);
679 glm::ivec3 chunk_coords(0);
685 Read(chunk_coords, off + 4);
691 entity.Position(chunk_coords, pos);
692 entity.Velocity(vel);
693 entity.Orientation(rot);
694 entity.AngularVelocity(ang);
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));
704 case Packet::Login::TYPE:
705 On(Packet::As<Packet::Login>(udp_pack));
707 case Packet::Join::TYPE:
708 On(Packet::As<Packet::Join>(udp_pack));
710 case Packet::Part::TYPE:
711 On(Packet::As<Packet::Part>(udp_pack));
713 case Packet::PlayerUpdate::TYPE:
714 On(Packet::As<Packet::PlayerUpdate>(udp_pack));
716 case Packet::SpawnEntity::TYPE:
717 On(Packet::As<Packet::SpawnEntity>(udp_pack));
719 case Packet::DespawnEntity::TYPE:
720 On(Packet::As<Packet::DespawnEntity>(udp_pack));
722 case Packet::EntityUpdate::TYPE:
723 On(Packet::As<Packet::EntityUpdate>(udp_pack));
726 // drop unknown or unhandled packets
732 Server::Server(const Config &conf, World &world)
734 , serv_pack{ -1, nullptr, 0 }
737 serv_sock = SDLNet_UDP_Open(conf.port);
739 throw NetError("SDLNet_UDP_Open");
742 serv_pack.data = new Uint8[sizeof(Packet)];
743 serv_pack.maxlen = sizeof(Packet);
747 delete[] serv_pack.data;
748 SDLNet_UDP_Close(serv_sock);
752 void Server::Handle() {
753 int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
755 HandlePacket(serv_pack);
756 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
759 // a boo boo happened
760 throw NetError("SDLNet_UDP_Recv");
764 void Server::HandlePacket(const UDPpacket &udp_pack) {
765 if (udp_pack.len < int(sizeof(Packet::Header))) {
766 // packet too small, drop
769 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
770 if (pack.header.tag != Packet::TAG) {
771 // mistagged packet, drop
775 ClientConnection &client = GetClient(udp_pack.address);
776 client.GetConnection().Received(udp_pack);
779 ClientConnection &Server::GetClient(const IPaddress &addr) {
780 for (ClientConnection &client : clients) {
781 if (client.Matches(addr)) {
785 clients.emplace_back(*this, addr);
786 return clients.back();
789 void Server::Update(int dt) {
790 for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
792 if (client->Disconnected()) {
793 client = clients.erase(client);