1 #include "ClientConnection.hpp"
2 #include "ChunkTransmitter.hpp"
5 #include "../app/init.hpp"
6 #include "../geometry/distance.hpp"
7 #include "../io/WorldSave.hpp"
8 #include "../model/Model.hpp"
9 #include "../world/ChunkIndex.hpp"
10 #include "../world/Entity.hpp"
11 #include "../world/World.hpp"
16 #include <glm/gtx/io.hpp>
24 ChunkTransmitter::ChunkTransmitter(ClientConnection &conn)
27 , buffer_size(Chunk::BlockSize() + 10)
28 , buffer(new uint8_t[buffer_size])
30 , packet_len(Packet::ChunkData::MAX_DATA_LEN)
41 ChunkTransmitter::~ChunkTransmitter() {
45 bool ChunkTransmitter::Idle() const noexcept {
46 return !Transmitting() && !Waiting();
49 bool ChunkTransmitter::Transmitting() const noexcept {
50 return cursor < num_packets;
53 void ChunkTransmitter::Transmit() {
54 if (cursor < num_packets) {
60 bool ChunkTransmitter::Waiting() const noexcept {
61 return confirm_wait > 0;
64 void ChunkTransmitter::Ack(uint16_t seq) {
68 if (seq == begin_packet) {
76 for (int i = 0, end = data_packets.size(); i < end; ++i) {
77 if (seq == data_packets[i]) {
88 void ChunkTransmitter::Nack(uint16_t seq) {
92 if (seq == begin_packet) {
96 for (size_t i = 0, end = data_packets.size(); i < end; ++i) {
97 if (seq == data_packets[i]) {
104 void ChunkTransmitter::Abort() {
105 if (!current) return;
110 data_packets.clear();
114 void ChunkTransmitter::Send(Chunk &chunk) {
115 // abort current chunk, if any
121 // load new chunk data
123 buffer_len = buffer_size;
124 if (compress(buffer.get(), &buffer_len, reinterpret_cast<const Bytef *>(chunk.BlockData()), Chunk::BlockSize()) != Z_OK) {
125 // compression failed, send it uncompressed
126 buffer_len = Chunk::BlockSize();
127 memcpy(buffer.get(), chunk.BlockData(), buffer_len);
131 num_packets = (buffer_len / packet_len) + (buffer_len % packet_len != 0);
132 data_packets.resize(num_packets, -1);
138 void ChunkTransmitter::SendBegin() {
139 uint32_t flags = compressed;
140 auto pack = conn.Prepare<Packet::ChunkBegin>();
141 pack.WriteTransmissionId(trans_id);
142 pack.WriteFlags(flags);
143 pack.WriteChunkCoords(current->Position());
144 pack.WriteDataSize(buffer_len);
145 if (begin_packet == -1) {
148 begin_packet = conn.Send();
151 void ChunkTransmitter::SendData(size_t i) {
152 int pos = i * packet_len;
153 int len = min(packet_len, buffer_len - pos);
154 const uint8_t *data = &buffer[pos];
156 auto pack = conn.Prepare<Packet::ChunkData>();
157 pack.WriteTransmissionId(trans_id);
158 pack.WriteDataOffset(pos);
159 pack.WriteDataSize(len);
160 pack.WriteData(data, len);
162 if (data_packets[i] == -1) {
165 data_packets[i] = conn.Send(Packet::ChunkData::GetSize(len));
168 void ChunkTransmitter::Release() {
176 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
180 , player_model(nullptr)
184 , entity_updates_skipped(0)
185 , player_update_state()
186 , player_update_pack(0)
187 , player_update_timer(1500)
192 , chunk_blocks_skipped(0) {
193 conn.SetHandler(this);
196 ClientConnection::~ClientConnection() {
200 void ClientConnection::Update(int dt) {
202 if (Disconnected()) {
211 if (conn.ShouldPing()) {
212 conn.SendPing(server.GetPacket(), server.GetSocket());
216 void ClientConnection::CheckEntities() {
217 auto global_iter = server.GetWorld().Entities().begin();
218 auto global_end = server.GetWorld().Entities().end();
219 auto local_iter = spawns.begin();
220 auto local_end = spawns.end();
222 while (global_iter != global_end && local_iter != local_end) {
223 if (global_iter->ID() == local_iter->entity->ID()) {
225 if (CanDespawn(*global_iter)) {
226 SendDespawn(*local_iter);
227 } else if (SendingUpdates()) {
229 QueueUpdate(*local_iter);
233 } else if (global_iter->ID() < local_iter->entity->ID()) {
234 // global entity was inserted
235 if (CanSpawn(*global_iter)) {
236 auto spawned = spawns.emplace(local_iter, *global_iter);
241 // global entity was removed
242 SendDespawn(*local_iter);
248 while (global_iter != global_end) {
249 if (CanSpawn(*global_iter)) {
250 spawns.emplace_back(*global_iter);
251 SendSpawn(spawns.back());
257 while (local_iter != local_end) {
258 SendDespawn(*local_iter);
263 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
270 ClientConnection::SpawnStatus::~SpawnStatus() {
274 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
276 &e != &PlayerEntity() &&
278 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) < 7;
281 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
284 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) > 7;
287 uint16_t ClientConnection::Send() {
288 return conn.Send(server.GetPacket(), server.GetSocket());
291 uint16_t ClientConnection::Send(size_t len) {
292 server.GetPacket().len = sizeof(Packet::Header) + len;
296 void ClientConnection::SendSpawn(SpawnStatus &status) {
297 // don't double spawn
298 if (status.spawn_pack != -1) return;
300 auto pack = Prepare<Packet::SpawnEntity>();
301 pack.WriteEntity(*status.entity);
302 status.spawn_pack = Send();
306 void ClientConnection::SendDespawn(SpawnStatus &status) {
307 // don't double despawn
308 if (status.despawn_pack != -1) return;
310 auto pack = Prepare<Packet::DespawnEntity>();
311 pack.WriteEntityID(status.entity->ID());
312 status.despawn_pack = Send();
316 bool ClientConnection::SendingUpdates() const noexcept {
317 return entity_updates_skipped >= NetStat().SuggestedPacketHold();
320 void ClientConnection::QueueUpdate(SpawnStatus &status) {
321 // don't send updates while spawn not ack'd or despawn sent
322 if (status.spawn_pack == -1 && status.despawn_pack == -1) {
323 entity_updates.push_back(&status);
327 void ClientConnection::SendUpdates() {
328 if (!SendingUpdates()) {
329 entity_updates.clear();
330 ++entity_updates_skipped;
333 auto base = PlayerChunks().Base();
334 auto pack = Prepare<Packet::EntityUpdate>();
335 pack.WriteChunkBase(base);
337 for (SpawnStatus *status : entity_updates) {
338 pack.WriteEntity(*status->entity, base, entity_pos);
340 if (entity_pos == Packet::EntityUpdate::MAX_ENTITIES) {
341 pack.WriteEntityCount(entity_pos);
342 Send(Packet::EntityUpdate::GetSize(entity_pos));
343 pack = Prepare<Packet::EntityUpdate>();
347 if (entity_pos > 0) {
348 pack.WriteEntityCount(entity_pos);
349 Send(Packet::EntityUpdate::GetSize(entity_pos));
351 entity_updates.clear();
352 entity_updates_skipped = 0;
355 void ClientConnection::CheckPlayerFix() {
356 // player_update_state's position holds the client's most recent prediction
357 glm::vec3 diff = player_update_state.Diff(PlayerEntity().GetState());
358 float dist_squared = glm::length2(diff);
360 // if client's prediction is off by more than 1cm, send
361 // our (authoritative) state back so it can fix it
362 constexpr float fix_thresh = 0.0001f;
364 if (dist_squared > fix_thresh) {
365 auto pack = Prepare<Packet::PlayerCorrection>();
366 pack.WritePacketSeq(player_update_pack);
367 pack.WritePlayer(PlayerEntity());
374 struct QueueCompare {
375 explicit QueueCompare(const glm::ivec3 &base)
377 bool operator ()(const glm::ivec3 &left, const glm::ivec3 &right) const noexcept {
378 const glm::ivec3 ld(left - base);
379 const glm::ivec3 rd(right - base);
381 ld.x * ld.x + ld.y * ld.y + ld.z * ld.z <
382 rd.x * rd.x + rd.y * rd.y + rd.z * rd.z;
384 const glm::ivec3 &base;
389 void ClientConnection::CheckChunkQueue() {
390 if (PlayerChunks().Base() != old_base) {
391 ExactLocation::Coarse begin = PlayerChunks().CoordsBegin();
392 ExactLocation::Coarse end = PlayerChunks().CoordsEnd();
393 for (ExactLocation::Coarse pos = begin; pos.z < end.z; ++pos.z) {
394 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
395 for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
396 if (manhattan_radius(pos - old_base) > PlayerChunks().Extent()) {
397 chunk_queue.push_back(pos);
402 old_base = PlayerChunks().Base();
403 sort(chunk_queue.begin(), chunk_queue.end(), QueueCompare(old_base));
404 chunk_queue.erase(unique(chunk_queue.begin(), chunk_queue.end()), chunk_queue.end());
406 // don't push entity updates and chunk data in the same tick
407 if (chunk_blocks_skipped >= NetStat().SuggestedPacketHold() && !SendingUpdates()) {
408 ++chunk_blocks_skipped;
411 if (transmitter.Transmitting()) {
412 transmitter.Transmit();
413 chunk_blocks_skipped = 0;
416 if (transmitter.Idle()) {
418 constexpr int max = 64;
419 while (count < max && !chunk_queue.empty()) {
420 ExactLocation::Coarse pos = chunk_queue.front();
421 chunk_queue.pop_front();
422 if (PlayerChunks().InRange(pos)) {
423 Chunk *chunk = PlayerChunks().Get(pos);
425 transmitter.Send(*chunk);
426 chunk_blocks_skipped = 0;
429 chunk_queue.push_back(pos);
437 void ClientConnection::AttachPlayer(Player &player) {
439 input.reset(new DirectInput(server.GetWorld(), player, server));
440 PlayerEntity().Ref();
442 cli_ctx.reset(new NetworkCLIFeedback(player, *this));
444 old_base = PlayerChunks().Base();
445 ExactLocation::Coarse begin = PlayerChunks().CoordsBegin();
446 ExactLocation::Coarse end = PlayerChunks().CoordsEnd();
447 for (ExactLocation::Coarse pos = begin; pos.z < end.z; ++pos.z) {
448 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
449 for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
450 chunk_queue.push_back(pos);
454 sort(chunk_queue.begin(), chunk_queue.end(), QueueCompare(old_base));
455 // TODO: should the server do this?
456 if (HasPlayerModel()) {
457 GetPlayerModel().Instantiate(PlayerEntity().GetModel());
460 string msg = "player \"" + player.Name() + "\" joined";
462 server.DistributeMessage(0, 0, msg);
465 void ClientConnection::DetachPlayer() {
466 if (!HasPlayer()) return;
467 string msg = "player \"" + input->GetPlayer().Name() + "\" left";
469 server.DistributeMessage(0, 0, msg);
471 server.GetWorldSave().Write(input->GetPlayer());
472 PlayerEntity().Kill();
473 PlayerEntity().UnRef();
481 void ClientConnection::SetPlayerModel(const Model &m) noexcept {
484 m.Instantiate(PlayerEntity().GetModel());
488 bool ClientConnection::HasPlayerModel() const noexcept {
492 const Model &ClientConnection::GetPlayerModel() const noexcept {
493 return *player_model;
496 void ClientConnection::OnPacketReceived(uint16_t seq) {
497 if (transmitter.Waiting()) {
498 transmitter.Ack(seq);
500 if (!confirm_wait) return;
501 for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
502 if (seq == iter->spawn_pack) {
503 iter->spawn_pack = -1;
507 if (seq == iter->despawn_pack) {
515 void ClientConnection::OnPacketLost(uint16_t seq) {
516 if (transmitter.Waiting()) {
517 transmitter.Nack(seq);
519 if (!confirm_wait) return;
520 for (SpawnStatus &status : spawns) {
521 if (seq == status.spawn_pack) {
522 status.spawn_pack = -1;
527 if (seq == status.despawn_pack) {
528 status.despawn_pack = -1;
536 void ClientConnection::On(const Packet::Login &pack) {
538 pack.ReadPlayerName(name);
540 Player *new_player = server.JoinPlayer(name);
544 AttachPlayer(*new_player);
545 cout << "accepted login from player \"" << name << '"' << endl;
546 auto response = Prepare<Packet::Join>();
547 response.WritePlayer(new_player->GetEntity());
548 response.WriteWorldName(server.GetWorld().Name());
550 // set up update tracking
551 player_update_state = new_player->GetEntity().GetState();
552 player_update_pack = pack.Seq();
553 player_update_timer.Reset();
554 player_update_timer.Start();
557 cout << "rejected login from player \"" << name << '"' << endl;
558 Prepare<Packet::Part>();
564 void ClientConnection::On(const Packet::Part &) {
568 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
569 if (!HasPlayer()) return;
570 int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
571 bool overdue = player_update_timer.HitOnce();
572 player_update_timer.Reset();
573 if (pack_diff <= 0 && !overdue) {
574 // drop old packets if we have a fairly recent state
577 glm::vec3 movement(0.0f);
581 player_update_pack = pack.Seq();
582 pack.ReadPredictedState(player_update_state);
583 pack.ReadMovement(movement);
584 pack.ReadActions(new_actions);
587 // accept client's orientation as is
588 input->GetPlayer().GetEntity().Orientation(player_update_state.orient);
590 input->SetMovement(movement);
591 // rotate head to match client's "prediction"
592 input->TurnHead(player_update_state.pitch - input->GetPitch(), player_update_state.yaw - input->GetYaw());
593 // select the given inventory slot
594 input->SelectInventory(slot);
596 // check if any actions have been started or stopped
597 if ((new_actions & 0x01) && !(old_actions & 0x01)) {
598 input->StartPrimaryAction();
599 } else if (!(new_actions & 0x01) && (old_actions & 0x01)) {
600 input->StopPrimaryAction();
602 if ((new_actions & 0x02) && !(old_actions & 0x02)) {
603 input->StartSecondaryAction();
604 } else if (!(new_actions & 0x02) && (old_actions & 0x02)) {
605 input->StopSecondaryAction();
607 if ((new_actions & 0x04) && !(old_actions & 0x04)) {
608 input->StartTertiaryAction();
609 } else if (!(new_actions & 0x04) && (old_actions & 0x04)) {
610 input->StopTertiaryAction();
612 old_actions = new_actions;
615 bool ClientConnection::ChunkInRange(const glm::ivec3 &pos) const noexcept {
616 return HasPlayer() && PlayerChunks().InRange(pos);
619 void ClientConnection::On(const Packet::ChunkBegin &pack) {
621 pack.ReadChunkCoords(pos);
622 if (ChunkInRange(pos)) {
623 chunk_queue.push_front(pos);
627 void ClientConnection::On(const Packet::Message &pack) {
632 pack.ReadReferral(ref);
633 pack.ReadMessage(msg);
635 if (type == 1 && cli_ctx) {
636 server.DispatchMessage(*cli_ctx, msg);
640 uint16_t ClientConnection::SendMessage(uint8_t type, uint32_t from, const string &msg) {
641 auto pack = Prepare<Packet::Message>();
642 pack.WriteType(type);
643 pack.WriteReferral(from);
644 pack.WriteMessage(msg);
645 return Send(Packet::Message::GetSize(msg));
649 NetworkCLIFeedback::NetworkCLIFeedback(Player &p, ClientConnection &c)
655 void NetworkCLIFeedback::Error(const string &msg) {
656 conn.SendMessage(0, 0, msg);
659 void NetworkCLIFeedback::Message(const string &msg) {
660 conn.SendMessage(0, 0, msg);
663 void NetworkCLIFeedback::Broadcast(const string &msg) {
664 conn.GetServer().DistributeMessage(0, GetPlayer().GetEntity().ID(), msg);
668 // relying on {} zero intitialization for UDPpacket, because
669 // the type and number of fields is not well defined
670 #pragma GCC diagnostic push
671 #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
673 const Config::Network &conf,
675 const World::Config &wc,
676 const WorldSave &save)
678 , serv_pack{ -1, nullptr, 0 }
679 , serv_set(SDLNet_AllocSocketSet(1))
682 , spawn_index(world.Chunks().MakeIndex(wc.spawn, 3))
684 , player_model(nullptr)
686 #pragma GCC diagnostic pop
688 throw NetError("SDLNet_AllocSocketSet");
691 serv_sock = SDLNet_UDP_Open(conf.port);
693 SDLNet_FreeSocketSet(serv_set);
694 throw NetError("SDLNet_UDP_Open");
697 if (SDLNet_UDP_AddSocket(serv_set, serv_sock) == -1) {
698 SDLNet_UDP_Close(serv_sock);
699 SDLNet_FreeSocketSet(serv_set);
700 throw NetError("SDLNet_UDP_AddSocket");
703 serv_pack.data = new Uint8[sizeof(Packet)];
704 serv_pack.maxlen = sizeof(Packet);
708 for (ClientConnection &client : clients) {
709 client.Disconnected();
712 world.Chunks().UnregisterIndex(spawn_index);
713 delete[] serv_pack.data;
714 SDLNet_UDP_DelSocket(serv_set, serv_sock);
715 SDLNet_UDP_Close(serv_sock);
716 SDLNet_FreeSocketSet(serv_set);
720 void Server::Wait(int dt) noexcept {
721 SDLNet_CheckSockets(serv_set, dt);
724 bool Server::Ready() noexcept {
725 return SDLNet_CheckSockets(serv_set, 0) > 0;
728 void Server::Handle() {
729 int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
731 HandlePacket(serv_pack);
732 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
735 // a boo boo happened
736 throw NetError("SDLNet_UDP_Recv");
740 void Server::HandlePacket(const UDPpacket &udp_pack) {
741 if (udp_pack.len < int(sizeof(Packet::Header))) {
742 // packet too small, drop
745 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
746 if (pack.header.tag != Packet::TAG) {
747 // mistagged packet, drop
751 ClientConnection &client = GetClient(udp_pack.address);
752 client.GetConnection().Received(udp_pack);
755 ClientConnection &Server::GetClient(const IPaddress &addr) {
756 for (ClientConnection &client : clients) {
757 if (client.Matches(addr)) {
761 clients.emplace_back(*this, addr);
762 if (HasPlayerModel()) {
763 clients.back().SetPlayerModel(GetPlayerModel());
765 return clients.back();
768 void Server::Update(int dt) {
769 for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
771 if (client->Disconnected()) {
772 client = clients.erase(client);
779 void Server::SetPlayerModel(const Model &m) noexcept {
781 for (ClientConnection &client : clients) {
782 client.SetPlayerModel(m);
786 bool Server::HasPlayerModel() const noexcept {
790 const Model &Server::GetPlayerModel() const noexcept {
791 return *player_model;
794 Player *Server::JoinPlayer(const string &name) {
795 if (spawn_index.MissingChunks() > 0) {
798 Player *player = world.AddPlayer(name);
802 if (save.Exists(*player)) {
810 void Server::SetBlock(Chunk &chunk, int index, const Block &block) {
811 chunk.SetBlock(index, block);
812 // TODO: batch chunk changes
813 auto pack = Packet::Make<Packet::BlockUpdate>(GetPacket());
814 pack.WriteChunkCoords(chunk.Position());
815 pack.WriteBlockCount(uint32_t(1));
816 pack.WriteIndex(index, 0);
817 pack.WriteBlock(chunk.BlockAt(index), 0);
818 GetPacket().len = sizeof(Packet::Header) + Packet::BlockUpdate::GetSize(1);
819 for (ClientConnection &client : clients) {
820 if (client.ChunkInRange(chunk.Position())) {
826 void Server::DispatchMessage(CLIContext &ctx, const string &msg) {
830 if (msg[0] == '/' && msg.size() > 1 && msg[1] != '/') {
831 cli.Execute(ctx, msg.substr(1));
833 DistributeMessage(1, ctx.GetPlayer().GetEntity().ID(), msg);
837 void Server::DistributeMessage(uint8_t type, uint32_t ref, const string &msg) {
838 auto pack = Packet::Make<Packet::Message>(serv_pack);
839 pack.WriteType(type);
840 pack.WriteReferral(ref);
841 pack.WriteMessage(msg);
842 serv_pack.len = sizeof(Packet::Header) + Packet::Message::GetSize(msg);
846 void Server::SendAll() {
847 for (ClientConnection &client : clients) {
848 client.GetConnection().Send(serv_pack, serv_sock);