]> git.localhorst.tv Git - blank.git/blob - src/server/net.cpp
d16088991f22f2a840869dc1c9da89c040764cbe
[blank.git] / src / server / net.cpp
1 #include "ClientConnection.hpp"
2 #include "ChunkTransmitter.hpp"
3 #include "Server.hpp"
4
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"
12
13 #include <algorithm>
14 #include <iostream>
15 #include <zlib.h>
16 #include <glm/gtx/io.hpp>
17
18 using namespace std;
19
20
21 namespace blank {
22 namespace server {
23
24 ChunkTransmitter::ChunkTransmitter(ClientConnection &conn)
25 : conn(conn)
26 , current(nullptr)
27 , buffer_size(Chunk::BlockSize() + 10)
28 , buffer(new uint8_t[buffer_size])
29 , buffer_len(0)
30 , packet_len(Packet::ChunkData::MAX_DATA_LEN)
31 , cursor(0)
32 , num_packets(0)
33 , begin_packet(-1)
34 , data_packets()
35 , confirm_wait(0)
36 , trans_id(0)
37 , compressed(false) {
38
39 }
40
41 ChunkTransmitter::~ChunkTransmitter() {
42         Abort();
43 }
44
45 bool ChunkTransmitter::Idle() const noexcept {
46         return !Transmitting() && !Waiting();
47 }
48
49 bool ChunkTransmitter::Transmitting() const noexcept {
50         return cursor < num_packets;
51 }
52
53 void ChunkTransmitter::Transmit() {
54         if (cursor < num_packets) {
55                 SendData(cursor);
56                 ++cursor;
57         }
58 }
59
60 bool ChunkTransmitter::Waiting() const noexcept {
61         return confirm_wait > 0;
62 }
63
64 void ChunkTransmitter::Ack(uint16_t seq) {
65         if (!Waiting()) {
66                 return;
67         }
68         if (seq == begin_packet) {
69                 begin_packet = -1;
70                 --confirm_wait;
71                 if (Idle()) {
72                         Release();
73                 }
74                 return;
75         }
76         for (int i = 0, end = data_packets.size(); i < end; ++i) {
77                 if (seq == data_packets[i]) {
78                         data_packets[i] = -1;
79                         --confirm_wait;
80                         if (Idle()) {
81                                 Release();
82                         }
83                         return;
84                 }
85         }
86 }
87
88 void ChunkTransmitter::Nack(uint16_t seq) {
89         if (!Waiting()) {
90                 return;
91         }
92         if (seq == begin_packet) {
93                 SendBegin();
94                 return;
95         }
96         for (size_t i = 0, end = data_packets.size(); i < end; ++i) {
97                 if (seq == data_packets[i]) {
98                         SendData(i);
99                         return;
100                 }
101         }
102 }
103
104 void ChunkTransmitter::Abort() {
105         if (!current) return;
106
107         Release();
108
109         begin_packet = -1;
110         data_packets.clear();
111         confirm_wait = 0;
112 }
113
114 void ChunkTransmitter::Send(Chunk &chunk) {
115         // abort current chunk, if any
116         Abort();
117
118         current = &chunk;
119         current->Ref();
120
121         // load new chunk data
122         compressed = true;
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);
128                 compressed = false;
129         }
130         cursor = 0;
131         num_packets = (buffer_len / packet_len) + (buffer_len % packet_len != 0);
132         data_packets.resize(num_packets, -1);
133
134         ++trans_id;
135         SendBegin();
136 }
137
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) {
146                 ++confirm_wait;
147         }
148         begin_packet = conn.Send();
149 }
150
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];
155
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);
161
162         if (data_packets[i] == -1) {
163                 ++confirm_wait;
164         }
165         data_packets[i] = conn.Send(Packet::ChunkData::GetSize(len));
166 }
167
168 void ChunkTransmitter::Release() {
169         if (current) {
170                 current->UnRef();
171                 current = nullptr;
172         }
173 }
174
175
176 ClientConnection::ClientConnection(Server &server, const IPaddress &addr)
177 : server(server)
178 , conn(addr)
179 , input()
180 , player_model(nullptr)
181 , spawns()
182 , confirm_wait(0)
183 , entity_updates()
184 , entity_updates_skipped(0)
185 , player_update_state()
186 , player_update_pack(0)
187 , player_update_timer(1500)
188 , old_actions(0)
189 , transmitter(*this)
190 , chunk_queue()
191 , old_base()
192 , chunk_blocks_skipped(0) {
193         conn.SetHandler(this);
194 }
195
196 ClientConnection::~ClientConnection() {
197         DetachPlayer();
198 }
199
200 void ClientConnection::Update(int dt) {
201         conn.Update(dt);
202         if (Disconnected()) {
203                 return;
204         }
205         if (HasPlayer()) {
206                 CheckPlayerFix();
207                 CheckChunkQueue();
208                 CheckEntities();
209                 SendUpdates();
210         }
211         if (conn.ShouldPing()) {
212                 conn.SendPing(server.GetPacket(), server.GetSocket());
213         }
214 }
215
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();
221
222         while (global_iter != global_end && local_iter != local_end) {
223                 if (global_iter->ID() == local_iter->entity->ID()) {
224                         // they're the same
225                         if (CanDespawn(*global_iter)) {
226                                 SendDespawn(*local_iter);
227                         } else if (SendingUpdates()) {
228                                 // update
229                                 QueueUpdate(*local_iter);
230                         }
231                         ++global_iter;
232                         ++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);
237                                 SendSpawn(*spawned);
238                         }
239                         ++global_iter;
240                 } else {
241                         // global entity was removed
242                         SendDespawn(*local_iter);
243                         ++local_iter;
244                 }
245         }
246
247         // leftover spawns
248         while (global_iter != global_end) {
249                 if (CanSpawn(*global_iter)) {
250                         spawns.emplace_back(*global_iter);
251                         SendSpawn(spawns.back());
252                 }
253                 ++global_iter;
254         }
255
256         // leftover despawns
257         while (local_iter != local_end) {
258                 SendDespawn(*local_iter);
259                 ++local_iter;
260         }
261 }
262
263 ClientConnection::SpawnStatus::SpawnStatus(Entity &e)
264 : entity(&e)
265 , spawn_pack(-1)
266 , despawn_pack(-1) {
267         entity->Ref();
268 }
269
270 ClientConnection::SpawnStatus::~SpawnStatus() {
271         entity->UnRef();
272 }
273
274 bool ClientConnection::CanSpawn(const Entity &e) const noexcept {
275         return
276                 &e != &PlayerEntity() &&
277                 !e.Dead() &&
278                 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) < 7;
279 }
280
281 bool ClientConnection::CanDespawn(const Entity &e) const noexcept {
282         return
283                 e.Dead() ||
284                 manhattan_radius(e.ChunkCoords() - PlayerEntity().ChunkCoords()) > 7;
285 }
286
287 uint16_t ClientConnection::Send() {
288         return conn.Send(server.GetPacket(), server.GetSocket());
289 }
290
291 uint16_t ClientConnection::Send(size_t len) {
292         server.GetPacket().len = sizeof(Packet::Header) + len;
293         return Send();
294 }
295
296 void ClientConnection::SendSpawn(SpawnStatus &status) {
297         // don't double spawn
298         if (status.spawn_pack != -1) return;
299
300         auto pack = Prepare<Packet::SpawnEntity>();
301         pack.WriteEntity(*status.entity);
302         status.spawn_pack = Send();
303         ++confirm_wait;
304 }
305
306 void ClientConnection::SendDespawn(SpawnStatus &status) {
307         // don't double despawn
308         if (status.despawn_pack != -1) return;
309
310         auto pack = Prepare<Packet::DespawnEntity>();
311         pack.WriteEntityID(status.entity->ID());
312         status.despawn_pack = Send();
313         ++confirm_wait;
314 }
315
316 bool ClientConnection::SendingUpdates() const noexcept {
317         return entity_updates_skipped >= NetStat().SuggestedPacketHold();
318 }
319
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);
324         }
325 }
326
327 void ClientConnection::SendUpdates() {
328         if (!SendingUpdates()) {
329                 entity_updates.clear();
330                 ++entity_updates_skipped;
331                 return;
332         }
333         auto base = PlayerChunks().Base();
334         auto pack = Prepare<Packet::EntityUpdate>();
335         pack.WriteChunkBase(base);
336         int entity_pos = 0;
337         for (SpawnStatus *status : entity_updates) {
338                 pack.WriteEntity(*status->entity, base, entity_pos);
339                 ++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>();
344                         entity_pos = 0;
345                 }
346         }
347         if (entity_pos > 0) {
348                 pack.WriteEntityCount(entity_pos);
349                 Send(Packet::EntityUpdate::GetSize(entity_pos));
350         }
351         entity_updates.clear();
352         entity_updates_skipped = 0;
353 }
354
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 = dot(diff, diff);
359
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;
363
364         if (dist_squared > fix_thresh) {
365                 auto pack = Prepare<Packet::PlayerCorrection>();
366                 pack.WritePacketSeq(player_update_pack);
367                 pack.WritePlayer(PlayerEntity());
368                 Send();
369         }
370 }
371
372 namespace {
373
374 struct QueueCompare {
375         explicit QueueCompare(const glm::ivec3 &base)
376         : base(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);
380                 return
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;
383         }
384         const glm::ivec3 &base;
385 };
386
387 }
388
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);
398                                         }
399                                 }
400                         }
401                 }
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());
405         }
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;
409                 return;
410         }
411         if (transmitter.Transmitting()) {
412                 transmitter.Transmit();
413                 chunk_blocks_skipped = 0;
414                 return;
415         }
416         if (transmitter.Idle()) {
417                 int count = 0;
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);
424                                 if (chunk) {
425                                         transmitter.Send(*chunk);
426                                         chunk_blocks_skipped = 0;
427                                         return;
428                                 } else {
429                                         chunk_queue.push_back(pos);
430                                 }
431                                 ++count;
432                         }
433                 }
434         }
435 }
436
437 void ClientConnection::AttachPlayer(Player &player) {
438         DetachPlayer();
439         input.reset(new DirectInput(server.GetWorld(), player, server));
440         PlayerEntity().Ref();
441
442         old_base = PlayerChunks().Base();
443         ExactLocation::Coarse begin = PlayerChunks().CoordsBegin();
444         ExactLocation::Coarse end = PlayerChunks().CoordsEnd();
445         for (ExactLocation::Coarse pos = begin; pos.z < end.z; ++pos.z) {
446                 for (pos.y = begin.y; pos.y < end.y; ++pos.y) {
447                         for (pos.x = begin.x; pos.x < end.x; ++pos.x) {
448                                 chunk_queue.push_back(pos);
449                         }
450                 }
451         }
452         sort(chunk_queue.begin(), chunk_queue.end(), QueueCompare(old_base));
453         // TODO: should the server do this?
454         if (HasPlayerModel()) {
455                 GetPlayerModel().Instantiate(PlayerEntity().GetModel());
456         }
457
458         string msg = "player \"" + player.Name() + "\" joined";
459         cout << msg << endl;
460         server.DistributeMessage(0, 0, msg);
461 }
462
463 void ClientConnection::DetachPlayer() {
464         if (!HasPlayer()) return;
465         string msg = "player \"" + input->GetPlayer().Name() + "\" left";
466         cout << msg << endl;
467         server.DistributeMessage(0, 0, msg);
468
469         server.GetWorldSave().Write(input->GetPlayer());
470         PlayerEntity().Kill();
471         PlayerEntity().UnRef();
472         input.reset();
473         transmitter.Abort();
474         chunk_queue.clear();
475         old_actions = 0;
476 }
477
478 void ClientConnection::SetPlayerModel(const Model &m) noexcept {
479         player_model = &m;
480         if (HasPlayer()) {
481                 m.Instantiate(PlayerEntity().GetModel());
482         }
483 }
484
485 bool ClientConnection::HasPlayerModel() const noexcept {
486         return player_model;
487 }
488
489 const Model &ClientConnection::GetPlayerModel() const noexcept {
490         return *player_model;
491 }
492
493 void ClientConnection::OnPacketReceived(uint16_t seq) {
494         if (transmitter.Waiting()) {
495                 transmitter.Ack(seq);
496         }
497         if (!confirm_wait) return;
498         for (auto iter = spawns.begin(), end = spawns.end(); iter != end; ++iter) {
499                 if (seq == iter->spawn_pack) {
500                         iter->spawn_pack = -1;
501                         --confirm_wait;
502                         return;
503                 }
504                 if (seq == iter->despawn_pack) {
505                         spawns.erase(iter);
506                         --confirm_wait;
507                         return;
508                 }
509         }
510 }
511
512 void ClientConnection::OnPacketLost(uint16_t seq) {
513         if (transmitter.Waiting()) {
514                 transmitter.Nack(seq);
515         }
516         if (!confirm_wait) return;
517         for (SpawnStatus &status : spawns) {
518                 if (seq == status.spawn_pack) {
519                         status.spawn_pack = -1;
520                         --confirm_wait;
521                         SendSpawn(status);
522                         return;
523                 }
524                 if (seq == status.despawn_pack) {
525                         status.despawn_pack = -1;
526                         --confirm_wait;
527                         SendDespawn(status);
528                         return;
529                 }
530         }
531 }
532
533 void ClientConnection::On(const Packet::Login &pack) {
534         string name;
535         pack.ReadPlayerName(name);
536
537         Player *new_player = server.JoinPlayer(name);
538
539         if (new_player) {
540                 // success!
541                 AttachPlayer(*new_player);
542                 cout << "accepted login from player \"" << name << '"' << endl;
543                 auto response = Prepare<Packet::Join>();
544                 response.WritePlayer(new_player->GetEntity());
545                 response.WriteWorldName(server.GetWorld().Name());
546                 Send();
547                 // set up update tracking
548                 player_update_state = new_player->GetEntity().GetState();
549                 player_update_pack = pack.Seq();
550                 player_update_timer.Reset();
551                 player_update_timer.Start();
552         } else {
553                 // aw no :(
554                 cout << "rejected login from player \"" << name << '"' << endl;
555                 Prepare<Packet::Part>();
556                 Send();
557                 conn.Close();
558         }
559 }
560
561 void ClientConnection::On(const Packet::Part &) {
562         conn.Close();
563 }
564
565 void ClientConnection::On(const Packet::PlayerUpdate &pack) {
566         if (!HasPlayer()) return;
567         int pack_diff = int16_t(pack.Seq()) - int16_t(player_update_pack);
568         bool overdue = player_update_timer.HitOnce();
569         player_update_timer.Reset();
570         if (pack_diff <= 0 && !overdue) {
571                 // drop old packets if we have a fairly recent state
572                 return;
573         }
574         glm::vec3 movement(0.0f);
575         uint8_t new_actions;
576         uint8_t slot;
577
578         player_update_pack = pack.Seq();
579         pack.ReadPredictedState(player_update_state);
580         pack.ReadMovement(movement);
581         pack.ReadActions(new_actions);
582         pack.ReadSlot(slot);
583
584         // accept client's orientation as is
585         input->GetPlayer().GetEntity().Orientation(player_update_state.orient);
586         // simulate movement
587         input->SetMovement(movement);
588         // rotate head to match client's "prediction"
589         input->TurnHead(player_update_state.pitch - input->GetPitch(), player_update_state.yaw - input->GetYaw());
590         // select the given inventory slot
591         input->SelectInventory(slot);
592
593         // check if any actions have been started or stopped
594         if ((new_actions & 0x01) && !(old_actions & 0x01)) {
595                 input->StartPrimaryAction();
596         } else if (!(new_actions & 0x01) && (old_actions & 0x01)) {
597                 input->StopPrimaryAction();
598         }
599         if ((new_actions & 0x02) && !(old_actions & 0x02)) {
600                 input->StartSecondaryAction();
601         } else if (!(new_actions & 0x02) && (old_actions & 0x02)) {
602                 input->StopSecondaryAction();
603         }
604         if ((new_actions & 0x04) && !(old_actions & 0x04)) {
605                 input->StartTertiaryAction();
606         } else if (!(new_actions & 0x04) && (old_actions & 0x04)) {
607                 input->StopTertiaryAction();
608         }
609         old_actions = new_actions;
610 }
611
612 bool ClientConnection::ChunkInRange(const glm::ivec3 &pos) const noexcept {
613         return HasPlayer() && PlayerChunks().InRange(pos);
614 }
615
616 void ClientConnection::On(const Packet::ChunkBegin &pack) {
617         glm::ivec3 pos;
618         pack.ReadChunkCoords(pos);
619         if (ChunkInRange(pos)) {
620                 chunk_queue.push_front(pos);
621         }
622 }
623
624 void ClientConnection::On(const Packet::Message &pack) {
625         uint8_t type;
626         uint32_t ref;
627         string msg;
628         pack.ReadType(type);
629         pack.ReadReferral(ref);
630         pack.ReadMessage(msg);
631
632         if (type == 1 && HasPlayer()) {
633                 server.DispatchMessage(input->GetPlayer(), msg);
634         }
635 }
636
637
638 Server::Server(
639         const Config::Network &conf,
640         World &world,
641         const World::Config &wc,
642         const WorldSave &save)
643 : serv_sock(nullptr)
644 , serv_pack{ -1, nullptr, 0 }
645 , serv_set(SDLNet_AllocSocketSet(1))
646 , clients()
647 , world(world)
648 , spawn_index(world.Chunks().MakeIndex(wc.spawn, 3))
649 , save(save)
650 , player_model(nullptr)
651 , cli(world) {
652         if (!serv_set) {
653                 throw NetError("SDLNet_AllocSocketSet");
654         }
655
656         serv_sock = SDLNet_UDP_Open(conf.port);
657         if (!serv_sock) {
658                 SDLNet_FreeSocketSet(serv_set);
659                 throw NetError("SDLNet_UDP_Open");
660         }
661
662         if (SDLNet_UDP_AddSocket(serv_set, serv_sock) == -1) {
663                 SDLNet_UDP_Close(serv_sock);
664                 SDLNet_FreeSocketSet(serv_set);
665                 throw NetError("SDLNet_UDP_AddSocket");
666         }
667
668         serv_pack.data = new Uint8[sizeof(Packet)];
669         serv_pack.maxlen = sizeof(Packet);
670 }
671
672 Server::~Server() {
673         for (ClientConnection &client : clients) {
674                 client.Disconnected();
675         }
676         clients.clear();
677         world.Chunks().UnregisterIndex(spawn_index);
678         delete[] serv_pack.data;
679         SDLNet_UDP_DelSocket(serv_set, serv_sock);
680         SDLNet_UDP_Close(serv_sock);
681         SDLNet_FreeSocketSet(serv_set);
682 }
683
684
685 void Server::Wait(int dt) noexcept {
686         SDLNet_CheckSockets(serv_set, dt);
687 }
688
689 bool Server::Ready() noexcept {
690         return SDLNet_CheckSockets(serv_set, 0) > 0;
691 }
692
693 void Server::Handle() {
694         int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
695         while (result > 0) {
696                 HandlePacket(serv_pack);
697                 result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
698         }
699         if (result == -1) {
700                 // a boo boo happened
701                 throw NetError("SDLNet_UDP_Recv");
702         }
703 }
704
705 void Server::HandlePacket(const UDPpacket &udp_pack) {
706         if (udp_pack.len < int(sizeof(Packet::Header))) {
707                 // packet too small, drop
708                 return;
709         }
710         const Packet &pack = *reinterpret_cast<const Packet *>(udp_pack.data);
711         if (pack.header.tag != Packet::TAG) {
712                 // mistagged packet, drop
713                 return;
714         }
715
716         ClientConnection &client = GetClient(udp_pack.address);
717         client.GetConnection().Received(udp_pack);
718 }
719
720 ClientConnection &Server::GetClient(const IPaddress &addr) {
721         for (ClientConnection &client : clients) {
722                 if (client.Matches(addr)) {
723                         return client;
724                 }
725         }
726         clients.emplace_back(*this, addr);
727         if (HasPlayerModel()) {
728                 clients.back().SetPlayerModel(GetPlayerModel());
729         }
730         return clients.back();
731 }
732
733 void Server::Update(int dt) {
734         for (list<ClientConnection>::iterator client(clients.begin()), end(clients.end()); client != end;) {
735                 client->Update(dt);
736                 if (client->Disconnected()) {
737                         client = clients.erase(client);
738                 } else {
739                         ++client;
740                 }
741         }
742 }
743
744 void Server::SetPlayerModel(const Model &m) noexcept {
745         player_model = &m;
746         for (ClientConnection &client : clients) {
747                 client.SetPlayerModel(m);
748         }
749 }
750
751 bool Server::HasPlayerModel() const noexcept {
752         return player_model;
753 }
754
755 const Model &Server::GetPlayerModel() const noexcept {
756         return *player_model;
757 }
758
759 Player *Server::JoinPlayer(const string &name) {
760         if (spawn_index.MissingChunks() > 0) {
761                 return nullptr;
762         }
763         Player *player = world.AddPlayer(name);
764         if (!player) {
765                 return nullptr;
766         }
767         if (save.Exists(*player)) {
768                 save.Read(*player);
769         } else {
770                 // TODO: spawn
771         }
772         return player;
773 }
774
775 void Server::SetBlock(Chunk &chunk, int index, const Block &block) {
776         chunk.SetBlock(index, block);
777         // TODO: batch chunk changes
778         auto pack = Packet::Make<Packet::BlockUpdate>(GetPacket());
779         pack.WriteChunkCoords(chunk.Position());
780         pack.WriteBlockCount(uint32_t(1));
781         pack.WriteIndex(index, 0);
782         pack.WriteBlock(chunk.BlockAt(index), 0);
783         GetPacket().len = sizeof(Packet::Header) + Packet::BlockUpdate::GetSize(1);
784         for (ClientConnection &client : clients) {
785                 if (client.ChunkInRange(chunk.Position())) {
786                         client.Send();
787                 }
788         }
789 }
790
791 void Server::DispatchMessage(Player &player, const string &msg) {
792         if (msg.empty()) {
793                 return;
794         }
795         if (msg[0] == '/' && msg.size() > 1 && msg[1] != '/') {
796                 cli.Execute(player, msg.substr(1));
797         } else {
798                 DistributeMessage(1, player.GetEntity().ID(), msg);
799         }
800 }
801
802 void Server::DistributeMessage(uint8_t type, uint32_t ref, const string &msg) {
803         auto pack = Packet::Make<Packet::Message>(serv_pack);
804         pack.WriteType(type);
805         pack.WriteReferral(ref);
806         pack.WriteMessage(msg);
807         serv_pack.len = sizeof(Packet::Header) + Packet::Message::GetSize(msg);
808         SendAll();
809 }
810
811 void Server::SendAll() {
812         for (ClientConnection &client : clients) {
813                 client.GetConnection().Send(serv_pack, serv_sock);
814         }
815 }
816
817 }
818 }