2 #include "ClientConnection.hpp"
3 #include "Connection.hpp"
4 #include "ConnectionHandler.hpp"
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"
17 #include <glm/gtx/io.hpp>
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;
36 UDPsocket client_bind(Uint16 port) {
37 UDPsocket sock = SDLNet_UDP_Open(port);
39 throw NetError("SDLNet_UDP_Open");
44 IPaddress client_resolve(const char *host, Uint16 port) {
46 if (SDLNet_ResolveHost(&addr, host, port) != 0) {
47 throw NetError("SDLNet_ResolveHost");
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
65 delete[] client_pack.data;
66 SDLNet_UDP_Close(client_sock);
70 void Client::Handle() {
71 int result = SDLNet_UDP_Recv(client_sock, &client_pack);
73 HandlePacket(client_pack);
74 result = SDLNet_UDP_Recv(client_sock, &client_pack);
78 throw NetError("SDLNet_UDP_Recv");
82 void Client::HandlePacket(const UDPpacket &udp_pack) {
83 if (!conn.Matches(udp_pack.address)) {
84 // packet came from somewhere else, drop
87 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
88 if (pack.header.tag != Packet::TAG) {
89 // mistagged packet, drop
93 conn.Received(udp_pack);
96 void Client::Update(int dt) {
98 if (conn.ShouldPing()) {
103 uint16_t Client::SendPing() {
104 return conn.SendPing(client_pack, client_sock);
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);
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);
119 uint16_t Client::SendPart() {
120 Packet::Make<Packet::Part>(client_pack);
121 return conn.Send(client_pack, client_sock);
125 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
131 , player_update_state()
132 , player_update_pack(0)
133 , player_update_timer(1500) {
134 conn.SetHandler(this);
137 ClientConnection::~ClientConnection() {
141 void ClientConnection::Update(int dt) {
143 if (Disconnected()) {
148 auto global_iter = server.GetWorld().Entities().begin();
149 auto global_end = server.GetWorld().Entities().end();
150 auto local_iter = spawns.begin();
151 auto local_end = spawns.end();
153 while (global_iter != global_end && local_iter != local_end) {
154 if (global_iter->ID() == local_iter->entity->ID()) {
156 if (CanDespawn(*global_iter)) {
157 SendDespawn(*local_iter);
160 SendUpdate(*local_iter);
164 } else if (global_iter->ID() < local_iter->entity->ID()) {
165 // global entity was inserted
166 if (CanSpawn(*global_iter)) {
167 auto spawned = spawns.emplace(local_iter, *global_iter);
172 // global entity was removed
173 SendDespawn(*local_iter);
179 while (global_iter != global_end) {
180 if (CanSpawn(*global_iter)) {
181 spawns.emplace_back(*global_iter);
182 SendSpawn(spawns.back());
188 while (local_iter != local_end) {
189 SendDespawn(*local_iter);
195 if (conn.ShouldPing()) {
196 conn.SendPing(server.GetPacket(), server.GetSocket());
200 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
207 ClientConnection::SpawnStatus::~SpawnStatus() {
211 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
215 manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) < 7;
218 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
221 manhattan_radius(e.ChunkCoords() - Player().ChunkCoords()) > 7;
224 void ClientConnection::SendSpawn(SpawnStatus &status) {
225 // don't double spawn
226 if (status.spawn_pack != -1) return;
228 auto pack = Packet::Make<Packet::SpawnEntity>(server.GetPacket());
229 pack.WriteEntity(*status.entity);
230 status.spawn_pack = conn.Send(server.GetPacket(), server.GetSocket());
234 void ClientConnection::SendDespawn(SpawnStatus &status) {
235 // don't double despawn
236 if (status.despawn_pack != -1) return;
238 auto pack = Packet::Make<Packet::DespawnEntity>(server.GetPacket());
239 pack.WriteEntityID(status.entity->ID());
240 status.despawn_pack = conn.Send(server.GetPacket(), server.GetSocket());
244 void ClientConnection::SendUpdate(SpawnStatus &status) {
245 // don't send updates while spawn not ack'd or despawn sent
246 if (status.spawn_pack != -1 || status.despawn_pack != -1) return;
248 // TODO: pack entity updates
249 auto pack = Packet::Make<Packet::EntityUpdate>(server.GetPacket());
250 pack.WriteEntityCount(1);
251 pack.WriteEntity(*status.entity, 0);
252 server.GetPacket().len = Packet::EntityUpdate::GetSize(1);
253 conn.Send(server.GetPacket(), server.GetSocket());
256 void ClientConnection::CheckPlayerFix() {
257 // player_update_state's position holds the client's most recent prediction
258 glm::vec3 diff = player_update_state.Diff(Player().GetState());
259 float dist_squared = dot(diff, diff);
261 // if client's prediction is off by more than 1cm, send
262 // our (authoritative) state back so it can fix it
263 constexpr float fix_thresh = 0.0001f;
265 if (dist_squared > fix_thresh) {
266 auto pack = Packet::Make<Packet::PlayerCorrection>(server.GetPacket());
267 pack.WritePacketSeq(player_update_pack);
268 pack.WritePlayer(Player());
269 conn.Send(server.GetPacket(), server.GetSocket());
273 void ClientConnection::AttachPlayer(Entity &new_player) {
275 player = &new_player;
277 cout << "player \"" << player->Name() << "\" joined" << endl;
280 void ClientConnection::DetachPlayer() {
284 cout << "player \"" << player->Name() << "\" left" << endl;
288 void ClientConnection::OnPacketReceived(uint16_t seq) {
289 if (!confirm_wait) return;
290 for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
291 if (seq == iter->spawn_pack) {
292 iter->spawn_pack = -1;
296 if (seq == iter->despawn_pack) {
304 void ClientConnection::OnPacketLost(uint16_t seq) {
305 if (!confirm_wait) return;
306 for (SpawnStatus &status : spawns) {
307 if (seq == status.spawn_pack) {
308 status.spawn_pack = -1;
313 if (seq == status.despawn_pack) {
314 status.despawn_pack = -1;
322 void ClientConnection::On(const Packet::Login &pack) {
324 pack.ReadPlayerName(name);
326 Entity *new_player = server.GetWorld().AddPlayer(name).entity;
330 AttachPlayer(*new_player);
331 cout << "accepted login from player \"" << name << '"' << endl;
332 auto response = Packet::Make<Packet::Join>(server.GetPacket());
333 response.WritePlayer(*new_player);
334 response.WriteWorldName(server.GetWorld().Name());
335 conn.Send(server.GetPacket(), server.GetSocket());
336 // set up update tracking
337 player_update_state = new_player->GetState();
338 player_update_pack = pack.Seq();
339 player_update_timer.Reset();
340 player_update_timer.Start();
343 cout << "rejected login from player \"" << name << '"' << endl;
344 Packet::Make<Packet::Part>(server.GetPacket());
345 conn.Send(server.GetPacket(), server.GetSocket());
350 void ClientConnection::On(const Packet::Part &) {
354 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
355 if (!HasPlayer()) return;
356 int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
357 bool overdue = player_update_timer.HitOnce();
358 player_update_timer.Reset();
359 if (pack_diff > 0 || overdue) {
360 player_update_pack = pack.Seq();
361 pack.ReadPlayerState(player_update_state);
362 // accept velocity and orientation as "user input"
363 Player().Velocity(player_update_state.velocity);
364 Player().Orientation(player_update_state.orient);
369 Connection::Connection(const IPaddress &addr)
374 , ctrl_out{ 0, 0xFFFF, 0xFFFFFFFF }
375 , ctrl_in{ 0, 0xFFFF, 0xFFFFFFFF }
381 bool Connection::Matches(const IPaddress &remote) const noexcept {
382 return memcmp(&addr, &remote, sizeof(IPaddress)) == 0;
385 void Connection::FlagSend() noexcept {
389 void Connection::FlagRecv() noexcept {
393 bool Connection::ShouldPing() const noexcept {
394 return !closed && send_timer.HitOnce();
397 bool Connection::TimedOut() const noexcept {
398 return recv_timer.HitOnce();
401 void Connection::Update(int dt) {
402 send_timer.Update(dt);
403 recv_timer.Update(dt);
407 Handler().OnTimeout();
413 uint16_t Connection::Send(UDPpacket &udp_pack, UDPsocket sock) {
414 Packet &pack = *reinterpret_cast<Packet *>(udp_pack.data);
415 pack.header.ctrl = ctrl_out;
416 uint16_t seq = ctrl_out.seq++;
418 udp_pack.address = addr;
419 if (SDLNet_UDP_Send(sock, -1, &udp_pack) == 0) {
420 throw NetError("SDLNet_UDP_Send");
427 void Connection::Received(const UDPpacket &udp_pack) {
428 Packet &pack = *reinterpret_cast<Packet *>(udp_pack.data);
431 int16_t diff = int16_t(pack.header.ctrl.seq) - int16_t(ctrl_out.ack);
436 ctrl_out.hist <<= diff;
437 ctrl_out.hist |= 1 << (diff - 1);
439 } else if (diff < 0 && diff >= -32) {
440 ctrl_out.hist |= 1 << (-diff - 1);
442 ctrl_out.ack = pack.header.ctrl.seq;
449 Packet::TControl ctrl_new = pack.header.ctrl;
450 Handler().Handle(udp_pack);
453 // if the packet holds more recent information
454 // check if remote failed to ack one of our packets
455 diff = int16_t(ctrl_new.ack) - int16_t(ctrl_in.ack);
456 // should always be true, but you never know…
458 for (int i = 0; i < diff; ++i) {
459 if (i > 32 || (i < 32 && (ctrl_in.hist & (1 << (31 - i))) == 0)) {
460 Handler().OnPacketLost(ctrl_in.ack - 32 + i);
464 // check for newly ack'd packets
465 for (uint16_t s = ctrl_new.AckBegin(); s != ctrl_new.AckEnd(); ++s) {
466 if (ctrl_new.Acks(s) && !ctrl_in.Acks(s)) {
467 Handler().OnPacketReceived(s);
474 bool Packet::TControl::Acks(uint16_t s) const noexcept {
475 int16_t diff = int16_t(ack) - int16_t(s);
476 if (diff == 0) return true;
477 if (diff < 0 || diff > 32) return false;
478 return (hist & (1 << (diff - 1))) != 0;
481 uint16_t Connection::SendPing(UDPpacket &udp_pack, UDPsocket sock) {
482 Packet::Make<Packet::Ping>(udp_pack);
483 return Send(udp_pack, sock);
487 ostream &operator <<(ostream &out, const IPaddress &addr) {
488 const unsigned char *host = reinterpret_cast<const unsigned char *>(&addr.host);
490 << '.' << int(host[1])
491 << '.' << int(host[2])
492 << '.' << int(host[3]);
494 out << ':' << SDLNet_Read16(&addr.port);
500 const char *Packet::Type2String(uint8_t t) noexcept {
510 case PlayerUpdate::TYPE:
511 return "PlayerUpdate";
512 case SpawnEntity::TYPE:
513 return "SpawnEntity";
514 case DespawnEntity::TYPE:
515 return "DespawnEntity";
516 case EntityUpdate::TYPE:
517 return "EntityUpdate";
518 case PlayerCorrection::TYPE:
519 return "PlayerCorrection";
526 void Packet::Payload::Write(const T &src, size_t off) noexcept {
527 if ((length - off) < sizeof(T)) {
528 // dismiss out of bounds write
531 *reinterpret_cast<T *>(&data[off]) = src;
535 void Packet::Payload::Read(T &dst, size_t off) const noexcept {
536 if ((length - off) < sizeof(T)) {
537 // dismiss out of bounds read
540 dst = *reinterpret_cast<T *>(&data[off]);
543 void Packet::Payload::WriteString(const string &src, size_t off, size_t maxlen) noexcept {
544 uint8_t *dst = &data[off];
545 size_t len = min(maxlen, length - off);
546 if (src.size() < len) {
547 memset(dst, '\0', len);
548 memcpy(dst, src.c_str(), src.size());
550 memcpy(dst, src.c_str(), len);
554 void Packet::Payload::ReadString(string &dst, size_t off, size_t maxlen) const noexcept {
555 size_t len = min(maxlen, length - off);
558 for (size_t i = 0; i < len && data[off + i] != '\0'; ++i) {
559 dst.push_back(data[off + i]);
564 void Packet::Login::WritePlayerName(const string &name) noexcept {
565 WriteString(name, 0, 32);
568 void Packet::Login::ReadPlayerName(string &name) const noexcept {
569 ReadString(name, 0, 32);
572 void Packet::Join::WritePlayer(const Entity &player) noexcept {
573 Write(player.ID(), 0);
574 Write(player.GetState(), 4);
577 void Packet::Join::ReadPlayerID(uint32_t &id) const noexcept {
581 void Packet::Join::ReadPlayerState(EntityState &state) const noexcept {
585 void Packet::Join::WriteWorldName(const string &name) noexcept {
586 WriteString(name, 68, 32);
589 void Packet::Join::ReadWorldName(string &name) const noexcept {
590 ReadString(name, 68, 32);
593 void Packet::PlayerUpdate::WritePlayer(const Entity &player) noexcept {
594 Write(player.GetState(), 0);
597 void Packet::PlayerUpdate::ReadPlayerState(EntityState &state) const noexcept {
601 void Packet::SpawnEntity::WriteEntity(const Entity &e) noexcept {
604 Write(e.GetModel().GetModel().ID(), 4);
606 Write(uint32_t(0), 4);
608 Write(e.GetState(), 8);
609 Write(e.Bounds(), 72);
611 if (e.WorldCollidable()) {
615 WriteString(e.Name(), 100, 32);
618 void Packet::SpawnEntity::ReadEntityID(uint32_t &id) const noexcept {
622 void Packet::SpawnEntity::ReadSkeletonID(uint32_t &id) const noexcept {
626 void Packet::SpawnEntity::ReadEntity(Entity &e) const noexcept {
635 ReadString(name, 100, 32);
639 e.WorldCollidable(flags & 1);
643 void Packet::DespawnEntity::WriteEntityID(uint32_t id) noexcept {
647 void Packet::DespawnEntity::ReadEntityID(uint32_t &id) const noexcept {
651 void Packet::EntityUpdate::WriteEntityCount(uint32_t count) noexcept {
655 void Packet::EntityUpdate::ReadEntityCount(uint32_t &count) const noexcept {
659 void Packet::EntityUpdate::WriteEntity(const Entity &entity, uint32_t num) noexcept {
660 uint32_t off = 4 + (num * 64);
662 Write(entity.ID(), off);
663 Write(entity.GetState(), off + 4);
666 void Packet::EntityUpdate::ReadEntityID(uint32_t &id, uint32_t num) const noexcept {
667 Read(id, 4 + (num * 64));
670 void Packet::EntityUpdate::ReadEntityState(EntityState &state, uint32_t num) const noexcept {
671 uint32_t off = 4 + (num * 64);
672 Read(state, off + 4);
675 void Packet::PlayerCorrection::WritePacketSeq(std::uint16_t s) noexcept {
679 void Packet::PlayerCorrection::ReadPacketSeq(std::uint16_t &s) const noexcept {
683 void Packet::PlayerCorrection::WritePlayer(const Entity &player) noexcept {
684 Write(player.GetState(), 2);
687 void Packet::PlayerCorrection::ReadPlayerState(EntityState &state) const noexcept {
692 void ConnectionHandler::Handle(const UDPpacket &udp_pack) {
693 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
694 switch (pack.Type()) {
695 case Packet::Ping::TYPE:
696 On(Packet::As<Packet::Ping>(udp_pack));
698 case Packet::Login::TYPE:
699 On(Packet::As<Packet::Login>(udp_pack));
701 case Packet::Join::TYPE:
702 On(Packet::As<Packet::Join>(udp_pack));
704 case Packet::Part::TYPE:
705 On(Packet::As<Packet::Part>(udp_pack));
707 case Packet::PlayerUpdate::TYPE:
708 On(Packet::As<Packet::PlayerUpdate>(udp_pack));
710 case Packet::SpawnEntity::TYPE:
711 On(Packet::As<Packet::SpawnEntity>(udp_pack));
713 case Packet::DespawnEntity::TYPE:
714 On(Packet::As<Packet::DespawnEntity>(udp_pack));
716 case Packet::EntityUpdate::TYPE:
717 On(Packet::As<Packet::EntityUpdate>(udp_pack));
719 case Packet::PlayerCorrection::TYPE:
720 On(Packet::As<Packet::PlayerCorrection>(udp_pack));
723 // drop unknown or unhandled packets
729 Server::Server(const Config &conf, World &world)
731 , serv_pack{ -1, nullptr, 0 }
734 serv_sock = SDLNet_UDP_Open(conf.port);
736 throw NetError("SDLNet_UDP_Open");
739 serv_pack.data = new Uint8[sizeof(Packet)];
740 serv_pack.maxlen = sizeof(Packet);
744 delete[] serv_pack.data;
745 SDLNet_UDP_Close(serv_sock);
749 void Server::Handle() {
750 int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
752 HandlePacket(serv_pack);
753 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
756 // a boo boo happened
757 throw NetError("SDLNet_UDP_Recv");
761 void Server::HandlePacket(const UDPpacket &udp_pack) {
762 if (udp_pack.len < int(sizeof(Packet::Header))) {
763 // packet too small, drop
766 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
767 if (pack.header.tag != Packet::TAG) {
768 // mistagged packet, drop
772 ClientConnection &client = GetClient(udp_pack.address);
773 client.GetConnection().Received(udp_pack);
776 ClientConnection &Server::GetClient(const IPaddress &addr) {
777 for (ClientConnection &client : clients) {
778 if (client.Matches(addr)) {
782 clients.emplace_back(*this, addr);
783 return clients.back();
786 void Server::Update(int dt) {
787 for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
789 if (client->Disconnected()) {
790 client = clients.erase(client);