1 #include "ClientConnection.hpp"
2 #include "ChunkTransmitter.hpp"
5 #include "../app/init.hpp"
6 #include "../io/WorldSave.hpp"
7 #include "../model/CompositeModel.hpp"
8 #include "../world/ChunkIndex.hpp"
9 #include "../world/Entity.hpp"
10 #include "../world/World.hpp"
14 #include <glm/gtx/io.hpp>
22 ChunkTransmitter::ChunkTransmitter(ClientConnection &conn)
25 , buffer_size(Chunk::BlockSize() + 10)
26 , buffer(new uint8_t[buffer_size])
28 , packet_len(Packet::ChunkData::MAX_DATA_LEN)
39 ChunkTransmitter::~ChunkTransmitter() {
43 bool ChunkTransmitter::Idle() const noexcept {
44 return !Transmitting() && !Waiting();
47 bool ChunkTransmitter::Transmitting() const noexcept {
48 return cursor < num_packets;
51 void ChunkTransmitter::Transmit() {
52 if (cursor < num_packets) {
58 bool ChunkTransmitter::Waiting() const noexcept {
59 return confirm_wait > 0;
62 void ChunkTransmitter::Ack(uint16_t seq) {
66 if (seq == begin_packet) {
74 for (int i = 0, end = data_packets.size(); i < end; ++i) {
75 if (seq == data_packets[i]) {
86 void ChunkTransmitter::Nack(uint16_t seq) {
90 if (seq == begin_packet) {
94 for (size_t i = 0, end = data_packets.size(); i < end; ++i) {
95 if (seq == data_packets[i]) {
102 void ChunkTransmitter::Abort() {
103 if (!current) return;
108 data_packets.clear();
112 void ChunkTransmitter::Send(Chunk &chunk) {
113 // abort current chunk, if any
119 // load new chunk data
121 buffer_len = buffer_size;
122 if (compress(buffer.get(), &buffer_len, reinterpret_cast<const Bytef *>(chunk.BlockData()), Chunk::BlockSize()) != Z_OK) {
123 // compression failed, send it uncompressed
124 buffer_len = Chunk::BlockSize();
125 memcpy(buffer.get(), chunk.BlockData(), buffer_len);
129 num_packets = (buffer_len / packet_len) + (buffer_len % packet_len != 0);
130 data_packets.resize(num_packets, -1);
136 void ChunkTransmitter::SendBegin() {
137 uint32_t flags = compressed;
138 auto pack = conn.Prepare<Packet::ChunkBegin>();
139 pack.WriteTransmissionId(trans_id);
140 pack.WriteFlags(flags);
141 pack.WriteChunkCoords(current->Position());
142 pack.WriteDataSize(buffer_len);
143 if (begin_packet == -1) {
146 begin_packet = conn.Send();
149 void ChunkTransmitter::SendData(size_t i) {
150 int pos = i * packet_len;
151 int len = min(packet_len, buffer_len - pos);
152 const uint8_t *data = &buffer[pos];
154 auto pack = conn.Prepare<Packet::ChunkData>();
155 pack.WriteTransmissionId(trans_id);
156 pack.WriteDataOffset(pos);
157 pack.WriteDataSize(len);
158 pack.WriteData(data, len);
160 if (data_packets[i] == -1) {
163 data_packets[i] = conn.Send();
166 void ChunkTransmitter::Release() {
174 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
178 , player_model(nullptr)
182 , player_update_state()
183 , player_update_pack(0)
184 , player_update_timer(1500)
189 conn.SetHandler(this);
192 ClientConnection::~ClientConnection() {
196 void ClientConnection::Update(int dt) {
198 if (Disconnected()) {
203 auto global_iter = server.GetWorld().Entities().begin();
204 auto global_end = server.GetWorld().Entities().end();
205 auto local_iter = spawns.begin();
206 auto local_end = spawns.end();
208 while (global_iter != global_end && local_iter != local_end) {
209 if (global_iter->ID() == local_iter->entity->ID()) {
211 if (CanDespawn(*global_iter)) {
212 SendDespawn(*local_iter);
215 QueueUpdate(*local_iter);
219 } else if (global_iter->ID() < local_iter->entity->ID()) {
220 // global entity was inserted
221 if (CanSpawn(*global_iter)) {
222 auto spawned = spawns.emplace(local_iter, *global_iter);
227 // global entity was removed
228 SendDespawn(*local_iter);
234 while (global_iter != global_end) {
235 if (CanSpawn(*global_iter)) {
236 spawns.emplace_back(*global_iter);
237 SendSpawn(spawns.back());
243 while (local_iter != local_end) {
244 SendDespawn(*local_iter);
253 if (conn.ShouldPing()) {
254 conn.SendPing(server.GetPacket(), server.GetSocket());
258 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
265 ClientConnection::SpawnStatus::~SpawnStatus() {
269 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
271 &e != &PlayerEntity() &&
273 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) < 7;
276 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
279 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) > 7;
282 uint16_t ClientConnection::Send() {
283 return conn.Send(server.GetPacket(), server.GetSocket());
286 uint16_t ClientConnection::Send(size_t len) {
287 server.GetPacket().len = sizeof(Packet::Header) + len;
291 void ClientConnection::SendSpawn(SpawnStatus &status) {
292 // don't double spawn
293 if (status.spawn_pack != -1) return;
295 auto pack = Prepare<Packet::SpawnEntity>();
296 pack.WriteEntity(*status.entity);
297 status.spawn_pack = Send();
301 void ClientConnection::SendDespawn(SpawnStatus &status) {
302 // don't double despawn
303 if (status.despawn_pack != -1) return;
305 auto pack = Prepare<Packet::DespawnEntity>();
306 pack.WriteEntityID(status.entity->ID());
307 status.despawn_pack = Send();
311 void ClientConnection::QueueUpdate(SpawnStatus &status) {
312 // don't send updates while spawn not ack'd or despawn sent
313 if (status.spawn_pack == -1 && status.despawn_pack == -1) {
314 entity_updates.push_back(&status);
318 void ClientConnection::SendUpdates() {
319 auto pack = Prepare<Packet::EntityUpdate>();
321 for (SpawnStatus *status : entity_updates) {
322 pack.WriteEntity(*status->entity, entity_pos);
324 if (entity_pos == Packet::EntityUpdate::MAX_ENTITIES) {
325 pack.WriteEntityCount(entity_pos);
326 Send(Packet::EntityUpdate::GetSize(entity_pos));
327 pack = Prepare<Packet::EntityUpdate>();
331 if (entity_pos > 0) {
332 pack.WriteEntityCount(entity_pos);
333 Send(Packet::EntityUpdate::GetSize(entity_pos));
335 entity_updates.clear();
338 void ClientConnection::CheckPlayerFix() {
339 // player_update_state's position holds the client's most recent prediction
340 glm::vec3 diff = player_update_state.Diff(PlayerEntity().GetState());
341 float dist_squared = dot(diff, diff);
343 // if client's prediction is off by more than 1cm, send
344 // our (authoritative) state back so it can fix it
345 constexpr float fix_thresh = 0.0001f;
347 if (dist_squared > fix_thresh) {
348 auto pack = Prepare<Packet::PlayerCorrection>();
349 pack.WritePacketSeq(player_update_pack);
350 pack.WritePlayer(PlayerEntity());
355 void ClientConnection::CheckChunkQueue() {
356 if (PlayerChunks().Base() != old_base) {
357 Chunk::Pos begin = PlayerChunks().CoordsBegin();
358 Chunk::Pos end = PlayerChunks().CoordsEnd();
359 for (Chunk::Pos pos = begin; pos.z < end.z; ++pos.z) {
360 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
361 for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
362 if (manhattan_radius(pos - old_base) > PlayerChunks().Extent()) {
363 chunk_queue.push_back(pos);
368 old_base = PlayerChunks().Base();
370 if (transmitter.Transmitting()) {
371 transmitter.Transmit();
374 if (transmitter.Idle()) {
376 constexpr int max = 64;
377 while (count < max && !chunk_queue.empty()) {
378 Chunk::Pos pos = chunk_queue.front();
379 chunk_queue.pop_front();
380 if (PlayerChunks().InRange(pos)) {
381 Chunk *chunk = PlayerChunks().Get(pos);
383 transmitter.Send(*chunk);
386 chunk_queue.push_back(pos);
394 void ClientConnection::AttachPlayer(Player &player) {
396 input.reset(new DirectInput(server.GetWorld(), player, server));
397 PlayerEntity().Ref();
398 if (server.GetWorldSave().Exists(player)) {
399 server.GetWorldSave().Read(player);
404 old_base = PlayerChunks().Base();
405 Chunk::Pos begin = PlayerChunks().CoordsBegin();
406 Chunk::Pos end = PlayerChunks().CoordsEnd();
407 for (Chunk::Pos pos = begin; pos.z < end.z; ++pos.z) {
408 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
409 for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
410 chunk_queue.push_back(pos);
414 if (HasPlayerModel()) {
415 GetPlayerModel().Instantiate(PlayerEntity().GetModel());
418 cout << "player \"" << player.Name() << "\" joined" << endl;
421 void ClientConnection::DetachPlayer() {
422 if (!HasPlayer()) return;
423 cout << "player \"" << input->GetPlayer().Name() << "\" left" << endl;
424 server.GetWorldSave().Write(input->GetPlayer());
425 PlayerEntity().Kill();
426 PlayerEntity().UnRef();
433 void ClientConnection::SetPlayerModel(const CompositeModel &m) noexcept {
436 m.Instantiate(PlayerEntity().GetModel());
440 bool ClientConnection::HasPlayerModel() const noexcept {
444 const CompositeModel &ClientConnection::GetPlayerModel() const noexcept {
445 return *player_model;
448 void ClientConnection::OnPacketReceived(uint16_t seq) {
449 if (transmitter.Waiting()) {
450 transmitter.Ack(seq);
452 if (!confirm_wait) return;
453 for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
454 if (seq == iter->spawn_pack) {
455 iter->spawn_pack = -1;
459 if (seq == iter->despawn_pack) {
467 void ClientConnection::OnPacketLost(uint16_t seq) {
468 if (transmitter.Waiting()) {
469 transmitter.Nack(seq);
471 if (!confirm_wait) return;
472 for (SpawnStatus &status : spawns) {
473 if (seq == status.spawn_pack) {
474 status.spawn_pack = -1;
479 if (seq == status.despawn_pack) {
480 status.despawn_pack = -1;
488 void ClientConnection::On(const Packet::Login &pack) {
490 pack.ReadPlayerName(name);
492 Player *new_player = server.GetWorld().AddPlayer(name);
496 AttachPlayer(*new_player);
497 cout << "accepted login from player \"" << name << '"' << endl;
498 auto response = Prepare<Packet::Join>();
499 response.WritePlayer(new_player->GetEntity());
500 response.WriteWorldName(server.GetWorld().Name());
502 // set up update tracking
503 player_update_state = new_player->GetEntity().GetState();
504 player_update_pack = pack.Seq();
505 player_update_timer.Reset();
506 player_update_timer.Start();
509 cout << "rejected login from player \"" << name << '"' << endl;
510 Prepare<Packet::Part>();
516 void ClientConnection::On(const Packet::Part &) {
520 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
521 if (!HasPlayer()) return;
522 int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
523 bool overdue = player_update_timer.HitOnce();
524 player_update_timer.Reset();
525 if (pack_diff <= 0 && !overdue) {
526 // drop old packets if we have a fairly recent state
529 glm::vec3 movement(0.0f);
535 player_update_pack = pack.Seq();
536 pack.ReadPredictedState(player_update_state);
537 pack.ReadMovement(movement);
538 pack.ReadPitch(pitch);
540 pack.ReadActions(new_actions);
543 input->SetMovement(movement);
544 input->TurnHead(pitch - input->GetPitch(), yaw - input->GetYaw());
545 input->SelectInventory(slot);
547 if ((new_actions & 0x01) && !(old_actions & 0x01)) {
548 input->StartPrimaryAction();
549 } else if (!(new_actions & 0x01) && (old_actions & 0x01)) {
550 input->StopPrimaryAction();
552 if ((new_actions & 0x02) && !(old_actions & 0x02)) {
553 input->StartSecondaryAction();
554 } else if (!(new_actions & 0x02) && (old_actions & 0x02)) {
555 input->StopSecondaryAction();
557 if ((new_actions & 0x04) && !(old_actions & 0x04)) {
558 input->StartTertiaryAction();
559 } else if (!(new_actions & 0x04) && (old_actions & 0x04)) {
560 input->StopTertiaryAction();
562 old_actions = new_actions;
565 bool ClientConnection::ChunkInRange(const glm::ivec3 &pos) const noexcept {
566 return HasPlayer() && PlayerChunks().InRange(pos);
570 Server::Server(const Config::Network &conf, World &world, const WorldSave &save)
572 , serv_pack{ -1, nullptr, 0 }
576 , player_model(nullptr) {
577 serv_sock = SDLNet_UDP_Open(conf.port);
579 throw NetError("SDLNet_UDP_Open");
582 serv_pack.data = new Uint8[sizeof(Packet)];
583 serv_pack.maxlen = sizeof(Packet);
587 delete[] serv_pack.data;
588 SDLNet_UDP_Close(serv_sock);
592 void Server::Handle() {
593 int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
595 HandlePacket(serv_pack);
596 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
599 // a boo boo happened
600 throw NetError("SDLNet_UDP_Recv");
604 void Server::HandlePacket(const UDPpacket &udp_pack) {
605 if (udp_pack.len < int(sizeof(Packet::Header))) {
606 // packet too small, drop
609 const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
610 if (pack.header.tag != Packet::TAG) {
611 // mistagged packet, drop
615 ClientConnection &client = GetClient(udp_pack.address);
616 client.GetConnection().Received(udp_pack);
619 ClientConnection &Server::GetClient(const IPaddress &addr) {
620 for (ClientConnection &client : clients) {
621 if (client.Matches(addr)) {
625 clients.emplace_back(*this, addr);
626 if (HasPlayerModel()) {
627 clients.back().SetPlayerModel(GetPlayerModel());
629 return clients.back();
632 void Server::Update(int dt) {
633 for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
635 if (client->Disconnected()) {
636 client = clients.erase(client);
643 void Server::SetPlayerModel(const CompositeModel &m) noexcept {
645 for (ClientConnection &client : clients) {
646 client.SetPlayerModel(m);
650 bool Server::HasPlayerModel() const noexcept {
654 const CompositeModel &Server::GetPlayerModel() const noexcept {
655 return *player_model;
658 void Server::SetBlock(Chunk &chunk, int index, const Block &block) {
659 chunk.SetBlock(index, block);
660 // TODO: batch chunk changes
661 auto pack = Packet::Make<Packet::BlockUpdate>(GetPacket());
662 pack.WriteChunkCoords(chunk.Position());
663 pack.WriteBlockCount(uint32_t(1));
664 pack.WriteIndex(index, 0);
665 pack.WriteBlock(chunk.BlockAt(index), 0);
666 GetPacket().len = sizeof(Packet::Header) + Packet::BlockUpdate::GetSize(1);
667 for (ClientConnection &client : clients) {
668 if (client.ChunkInRange(chunk.Position())) {