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);
669 const Config::Network &conf,
671 const World::Config &wc,
672 const WorldSave &save)
674 , serv_pack{ -1, nullptr, 0 }
675 , serv_set(SDLNet_AllocSocketSet(1))
678 , spawn_index(world.Chunks().MakeIndex(wc.spawn, 3))
680 , player_model(nullptr)
683 throw NetError("SDLNet_AllocSocketSet");
686 serv_sock = SDLNet_UDP_Open(conf.port);
688 SDLNet_FreeSocketSet(serv_set);
689 throw NetError("SDLNet_UDP_Open");
692 if (SDLNet_UDP_AddSocket(serv_set, serv_sock) == -1) {
693 SDLNet_UDP_Close(serv_sock);
694 SDLNet_FreeSocketSet(serv_set);
695 throw NetError("SDLNet_UDP_AddSocket");
698 serv_pack.data = new Uint8[sizeof(Packet)];
699 serv_pack.maxlen = sizeof(Packet);
703 for (ClientConnection &client : clients) {
704 client.Disconnected();
707 world.Chunks().UnregisterIndex(spawn_index);
708 delete[] serv_pack.data;
709 SDLNet_UDP_DelSocket(serv_set, serv_sock);
710 SDLNet_UDP_Close(serv_sock);
711 SDLNet_FreeSocketSet(serv_set);
715 void Server::Wait(int dt) noexcept {
716 SDLNet_CheckSockets(serv_set, dt);
719 bool Server::Ready() noexcept {
720 return SDLNet_CheckSockets(serv_set, 0) > 0;
723 void Server::Handle() {
724 int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
726 HandlePacket(serv_pack);
727 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
730 // a boo boo happened
731 throw NetError("SDLNet_UDP_Recv");
735 void Server::HandlePacket(const UDPpacket &udp_pack) {
736 if (udp_pack.len < int(sizeof(Packet::Header))) {
737 // packet too small, drop
740 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
741 if (pack.header.tag != Packet::TAG) {
742 // mistagged packet, drop
746 ClientConnection &client = GetClient(udp_pack.address);
747 client.GetConnection().Received(udp_pack);
750 ClientConnection &Server::GetClient(const IPaddress &addr) {
751 for (ClientConnection &client : clients) {
752 if (client.Matches(addr)) {
756 clients.emplace_back(*this, addr);
757 if (HasPlayerModel()) {
758 clients.back().SetPlayerModel(GetPlayerModel());
760 return clients.back();
763 void Server::Update(int dt) {
764 for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
766 if (client->Disconnected()) {
767 client = clients.erase(client);
774 void Server::SetPlayerModel(const Model &m) noexcept {
776 for (ClientConnection &client : clients) {
777 client.SetPlayerModel(m);
781 bool Server::HasPlayerModel() const noexcept {
785 const Model &Server::GetPlayerModel() const noexcept {
786 return *player_model;
789 Player *Server::JoinPlayer(const string &name) {
790 if (spawn_index.MissingChunks() > 0) {
793 Player *player = world.AddPlayer(name);
797 if (save.Exists(*player)) {
805 void Server::SetBlock(Chunk &chunk, int index, const Block &block) {
806 chunk.SetBlock(index, block);
807 // TODO: batch chunk changes
808 auto pack = Packet::Make<Packet::BlockUpdate>(GetPacket());
809 pack.WriteChunkCoords(chunk.Position());
810 pack.WriteBlockCount(uint32_t(1));
811 pack.WriteIndex(index, 0);
812 pack.WriteBlock(chunk.BlockAt(index), 0);
813 GetPacket().len = sizeof(Packet::Header) + Packet::BlockUpdate::GetSize(1);
814 for (ClientConnection &client : clients) {
815 if (client.ChunkInRange(chunk.Position())) {
821 void Server::DispatchMessage(CLIContext &ctx, const string &msg) {
825 if (msg[0] == '/' && msg.size() > 1 && msg[1] != '/') {
826 cli.Execute(ctx, msg.substr(1));
828 DistributeMessage(1, ctx.GetPlayer().GetEntity().ID(), msg);
832 void Server::DistributeMessage(uint8_t type, uint32_t ref, const string &msg) {
833 auto pack = Packet::Make<Packet::Message>(serv_pack);
834 pack.WriteType(type);
835 pack.WriteReferral(ref);
836 pack.WriteMessage(msg);
837 serv_pack.len = sizeof(Packet::Header) + Packet::Message::GetSize(msg);
841 void Server::SendAll() {
842 for (ClientConnection &client : clients) {
843 client.GetConnection().Send(serv_pack, serv_sock);