if (data_packets[i] == -1) {
++confirm_wait;
}
- data_packets[i] = conn.Send();
+ data_packets[i] = conn.Send(Packet::ChunkData::GetSize(len));
}
void ChunkTransmitter::Release() {
, old_actions(0)
, transmitter(*this)
, chunk_queue()
-, old_base() {
+, old_base()
+, chunk_blocks_skipped(0) {
conn.SetHandler(this);
}
return;
}
if (HasPlayer()) {
- // sync entities
- auto global_iter = server.GetWorld().Entities().begin();
- auto global_end = server.GetWorld().Entities().end();
- auto local_iter = spawns.begin();
- auto local_end = spawns.end();
-
- while (global_iter != global_end && local_iter != local_end) {
- if (global_iter->ID() == local_iter->entity->ID()) {
- // they're the same
- if (CanDespawn(*global_iter)) {
- SendDespawn(*local_iter);
- } else if (SendingUpdates()) {
- // update
- QueueUpdate(*local_iter);
- }
- ++global_iter;
- ++local_iter;
- } else if (global_iter->ID() < local_iter->entity->ID()) {
- // global entity was inserted
- if (CanSpawn(*global_iter)) {
- auto spawned = spawns.emplace(local_iter, *global_iter);
- SendSpawn(*spawned);
- }
- ++global_iter;
- } else {
- // global entity was removed
+ CheckPlayerFix();
+ CheckChunkQueue();
+ CheckEntities();
+ SendUpdates();
+ }
+ if (conn.ShouldPing()) {
+ conn.SendPing(server.GetPacket(), server.GetSocket());
+ }
+}
+
+void ClientConnection::CheckEntities() {
+ auto global_iter = server.GetWorld().Entities().begin();
+ auto global_end = server.GetWorld().Entities().end();
+ auto local_iter = spawns.begin();
+ auto local_end = spawns.end();
+
+ while (global_iter != global_end && local_iter != local_end) {
+ if (global_iter->ID() == local_iter->entity->ID()) {
+ // they're the same
+ if (CanDespawn(*global_iter)) {
SendDespawn(*local_iter);
- ++local_iter;
+ } else if (SendingUpdates()) {
+ // update
+ QueueUpdate(*local_iter);
}
- }
-
- // leftover spawns
- while (global_iter != global_end) {
+ ++global_iter;
+ ++local_iter;
+ } else if (global_iter->ID() < local_iter->entity->ID()) {
+ // global entity was inserted
if (CanSpawn(*global_iter)) {
- spawns.emplace_back(*global_iter);
- SendSpawn(spawns.back());
+ auto spawned = spawns.emplace(local_iter, *global_iter);
+ SendSpawn(*spawned);
}
++global_iter;
- }
-
- // leftover despawns
- while (local_iter != local_end) {
+ } else {
+ // global entity was removed
SendDespawn(*local_iter);
++local_iter;
}
- SendUpdates();
+ }
- CheckPlayerFix();
- CheckChunkQueue();
+ // leftover spawns
+ while (global_iter != global_end) {
+ if (CanSpawn(*global_iter)) {
+ spawns.emplace_back(*global_iter);
+ SendSpawn(spawns.back());
+ }
+ ++global_iter;
}
- if (conn.ShouldPing()) {
- conn.SendPing(server.GetPacket(), server.GetSocket());
+
+ // leftover despawns
+ while (local_iter != local_end) {
+ SendDespawn(*local_iter);
+ ++local_iter;
}
}
}
bool ClientConnection::SendingUpdates() const noexcept {
- return entity_updates_skipped >= NetStat().SuggestedPacketSkip();
+ return entity_updates_skipped >= NetStat().SuggestedPacketHold();
}
void ClientConnection::QueueUpdate(SpawnStatus &status) {
old_base = PlayerChunks().Base();
sort(chunk_queue.begin(), chunk_queue.end(), QueueCompare(old_base));
}
- // if we have packet skip enabled and just pushed an entity
- // update, don't also send chunk data
- if (NetStat().SuggestedPacketSkip() > 0 && entity_updates_skipped == 0) {
+ // don't push entity updates and chunk data in the same tick
+ if (chunk_blocks_skipped >= NetStat().SuggestedPacketHold() && !SendingUpdates()) {
+ ++chunk_blocks_skipped;
return;
}
if (transmitter.Transmitting()) {
transmitter.Transmit();
+ chunk_blocks_skipped = 0;
return;
}
if (transmitter.Idle()) {
Chunk *chunk = PlayerChunks().Get(pos);
if (chunk) {
transmitter.Send(*chunk);
+ chunk_blocks_skipped = 0;
return;
} else {
chunk_queue.push_back(pos);
const WorldSave &save)
: serv_sock(nullptr)
, serv_pack{ -1, nullptr, 0 }
+, serv_set(SDLNet_AllocSocketSet(1))
, clients()
, world(world)
, spawn_index(world.Chunks().MakeIndex(wc.spawn, 3))
, save(save)
, player_model(nullptr)
, cli(world) {
+ if (!serv_set) {
+ throw NetError("SDLNet_AllocSocketSet");
+ }
+
serv_sock = SDLNet_UDP_Open(conf.port);
if (!serv_sock) {
+ SDLNet_FreeSocketSet(serv_set);
throw NetError("SDLNet_UDP_Open");
}
+ if (SDLNet_UDP_AddSocket(serv_set, serv_sock) == -1) {
+ SDLNet_UDP_Close(serv_sock);
+ SDLNet_FreeSocketSet(serv_set);
+ throw NetError("SDLNet_UDP_AddSocket");
+ }
+
serv_pack.data = new Uint8[sizeof(Packet)];
serv_pack.maxlen = sizeof(Packet);
}
Server::~Server() {
+ for (ClientConnection &client : clients) {
+ client.Disconnected();
+ }
+ clients.clear();
world.Chunks().UnregisterIndex(spawn_index);
delete[] serv_pack.data;
+ SDLNet_UDP_DelSocket(serv_set, serv_sock);
SDLNet_UDP_Close(serv_sock);
+ SDLNet_FreeSocketSet(serv_set);
}
+void Server::Wait(int dt) noexcept {
+ SDLNet_CheckSockets(serv_set, dt);
+}
+
+bool Server::Ready() noexcept {
+ return SDLNet_CheckSockets(serv_set, 0) > 0;
+}
+
void Server::Handle() {
int result = SDLNet_UDP_Recv(serv_sock, &serv_pack);
while (result > 0) {