512 lines
19 KiB
C++
512 lines
19 KiB
C++
#include "testHarness.h"
|
|
#include "vf/NetServer.h"
|
|
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace vf;
|
|
|
|
namespace {
|
|
|
|
struct Lcg {
|
|
uint64_t state;
|
|
explicit Lcg(uint64_t seed) : state(seed | 1ull) {}
|
|
uint32_t next() {
|
|
state = state * 6364136223846793005ull + 1442695040888963407ull;
|
|
return static_cast<uint32_t>(state >> 32);
|
|
}
|
|
int range(int n) { return static_cast<int>(next() % static_cast<uint32_t>(n)); }
|
|
};
|
|
|
|
void buildTerrain(World& world, int chunkMin, int chunkMax) {
|
|
Lcg rng(0x1a2b3c4d);
|
|
const Block palette[4] = {Block::Stone, Block::Dirt, Block::Grass, Block::Sand};
|
|
for (int cx = chunkMin; cx <= chunkMax; ++cx) {
|
|
for (int cz = chunkMin; cz <= chunkMax; ++cz) {
|
|
Chunk& chunk = world.ensureChunk(Vec3i{cx, 0, cz});
|
|
for (int x = 0; x < chunkSize; ++x)
|
|
for (int z = 0; z < chunkSize; ++z)
|
|
for (int y = 0; y < 6; ++y) chunk.set(x, y, z, palette[rng.range(4)]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// The far end of one slot: an independent transport and session on endpoint 1
|
|
// of that slot's link, which is exactly what a real remote player would be.
|
|
struct RemoteClient {
|
|
World world;
|
|
std::unique_ptr<Transport> transport;
|
|
std::unique_ptr<NetSession> session;
|
|
|
|
RemoteClient(NetServer& server, int slot, const TransportConfig& transportConfig,
|
|
const SessionConfig& sessionConfig, const std::string& name) {
|
|
transport.reset(new Transport(*server.linkFor(slot), 1, transportConfig));
|
|
session.reset(new NetSession(*transport, NetSession::Role::Client, sessionConfig));
|
|
session->attachWorld(world);
|
|
session->beginHandshake(name, 0x1000 + static_cast<uint64_t>(slot), 0x2000);
|
|
}
|
|
|
|
void step(uint64_t tick) {
|
|
session->receive(tick);
|
|
session->send(tick);
|
|
}
|
|
};
|
|
|
|
SessionConfig clientConfigFor(const ServerConfig& config) {
|
|
SessionConfig sessionConfig;
|
|
sessionConfig.protocolVersion = config.protocolVersion;
|
|
sessionConfig.viewRadius = config.viewRadius;
|
|
sessionConfig.keepAliveIntervalTicks = config.keepAliveIntervalTicks;
|
|
sessionConfig.keepAliveTimeoutTicks = config.keepAliveTimeoutTicks;
|
|
return sessionConfig;
|
|
}
|
|
|
|
ServerConfig quietServerConfig() {
|
|
ServerConfig config;
|
|
config.maxClients = 4;
|
|
config.viewRadius = 1;
|
|
config.chunksPerClientPerTick = 4;
|
|
config.keepAliveIntervalTicks = 10;
|
|
config.keepAliveTimeoutTicks = 1000000;
|
|
config.link.latencyTicks = 1;
|
|
return config;
|
|
}
|
|
|
|
// Seeds a slot's view before login; the first snapshot burst then goes out
|
|
// around this spot instead of around the origin.
|
|
void placeAt(NetServer& server, int slot, float x, float y, float z) {
|
|
server.sessionFor(slot)->view().position = Vec3{x, y, z};
|
|
}
|
|
|
|
} // namespace
|
|
|
|
VF_TEST(twoClientsStandingApartReceiveDisjointSetsOfChunks) {
|
|
ServerConfig config = quietServerConfig();
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -6, 6);
|
|
|
|
int slotNear = server.acceptClient();
|
|
int slotFar = server.acceptClient();
|
|
CHECK_EQ(slotNear, 0);
|
|
CHECK_EQ(slotFar, 1);
|
|
placeAt(server, slotNear, 8.0f, 8.0f, 8.0f);
|
|
placeAt(server, slotFar, 72.0f, 8.0f, 72.0f);
|
|
|
|
TransportConfig transportConfig = config.transport;
|
|
SessionConfig sessionConfig = clientConfigFor(config);
|
|
RemoteClient near(server, slotNear, transportConfig, sessionConfig, "near");
|
|
RemoteClient far(server, slotFar, transportConfig, sessionConfig, "far");
|
|
|
|
for (uint64_t tick = 0; tick < 60; ++tick) {
|
|
server.update(tick);
|
|
near.step(tick);
|
|
far.step(tick);
|
|
}
|
|
|
|
CHECK(near.session->phase() == SessionPhase::Play);
|
|
CHECK(far.session->phase() == SessionPhase::Play);
|
|
|
|
const ClientView& nearView = server.sessionFor(slotNear)->view();
|
|
const ClientView& farView = server.sessionFor(slotFar)->view();
|
|
CHECK_EQ(nearView.sent.size(), static_cast<std::size_t>(5));
|
|
CHECK_EQ(farView.sent.size(), static_cast<std::size_t>(5));
|
|
|
|
std::size_t shared = 0;
|
|
for (const Vec3i& coord : nearView.sent)
|
|
if (farView.sent.count(coord) != 0) ++shared;
|
|
CHECK_EQ(shared, static_cast<std::size_t>(0));
|
|
|
|
CHECK(nearView.hasChunk(Vec3i{0, 0, 0}));
|
|
CHECK(farView.hasChunk(Vec3i{4, 0, 4}));
|
|
CHECK(!nearView.hasChunk(Vec3i{4, 0, 4}));
|
|
CHECK(!farView.hasChunk(Vec3i{0, 0, 0}));
|
|
|
|
CHECK_EQ(near.world.chunkCount(), static_cast<std::size_t>(5));
|
|
CHECK_EQ(far.world.chunkCount(), static_cast<std::size_t>(5));
|
|
CHECK(near.world.chunkAt(Vec3i{4, 0, 4}) == nullptr);
|
|
CHECK(far.world.chunkAt(Vec3i{0, 0, 0}) == nullptr);
|
|
CHECK_EQ(server.stats().chunksSent, static_cast<uint64_t>(10));
|
|
}
|
|
|
|
VF_TEST(aBlockChangeInsideBothViewsReachesEachClientExactlyOnce) {
|
|
ServerConfig config = quietServerConfig();
|
|
config.viewRadius = 2;
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -4, 4);
|
|
|
|
int slotLeft = server.acceptClient();
|
|
int slotRight = server.acceptClient();
|
|
// Both stand two chunks apart, so chunk (1,0,0) is inside both spheres.
|
|
placeAt(server, slotLeft, 8.0f, 8.0f, 8.0f);
|
|
placeAt(server, slotRight, 40.0f, 8.0f, 8.0f);
|
|
|
|
TransportConfig transportConfig = config.transport;
|
|
SessionConfig sessionConfig = clientConfigFor(config);
|
|
sessionConfig.viewRadius = 2;
|
|
RemoteClient left(server, slotLeft, transportConfig, sessionConfig, "left");
|
|
RemoteClient right(server, slotRight, transportConfig, sessionConfig, "right");
|
|
|
|
for (uint64_t tick = 0; tick < 80; ++tick) {
|
|
server.update(tick);
|
|
left.step(tick);
|
|
right.step(tick);
|
|
}
|
|
CHECK(server.sessionFor(slotLeft)->view().hasChunk(Vec3i{1, 0, 0}));
|
|
CHECK(server.sessionFor(slotRight)->view().hasChunk(Vec3i{1, 0, 0}));
|
|
|
|
server.setBlock(20, 3, 5, Block::Glowstone);
|
|
for (uint64_t tick = 80; tick < 120; ++tick) {
|
|
server.update(tick);
|
|
left.step(tick);
|
|
right.step(tick);
|
|
}
|
|
|
|
CHECK(left.world.blockAt(20, 3, 5) == Block::Glowstone);
|
|
CHECK(right.world.blockAt(20, 3, 5) == Block::Glowstone);
|
|
CHECK_EQ(left.session->stats().blockChangesApplied, static_cast<uint64_t>(1));
|
|
CHECK_EQ(right.session->stats().blockChangesApplied, static_cast<uint64_t>(1));
|
|
CHECK_EQ(server.stats().blockUpdatesSent, static_cast<uint64_t>(2));
|
|
CHECK_EQ(server.stats().editsApplied, static_cast<uint64_t>(1));
|
|
}
|
|
|
|
VF_TEST(aBlockChangeIsNeverSentToAClientThatDoesNotHoldThatChunk) {
|
|
ServerConfig config = quietServerConfig();
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -6, 6);
|
|
|
|
int slotNear = server.acceptClient();
|
|
int slotFar = server.acceptClient();
|
|
placeAt(server, slotNear, 8.0f, 8.0f, 8.0f);
|
|
placeAt(server, slotFar, 72.0f, 8.0f, 72.0f);
|
|
|
|
TransportConfig transportConfig = config.transport;
|
|
SessionConfig sessionConfig = clientConfigFor(config);
|
|
RemoteClient near(server, slotNear, transportConfig, sessionConfig, "near");
|
|
RemoteClient far(server, slotFar, transportConfig, sessionConfig, "far");
|
|
for (uint64_t tick = 0; tick < 60; ++tick) {
|
|
server.update(tick);
|
|
near.step(tick);
|
|
far.step(tick);
|
|
}
|
|
|
|
for (int i = 0; i < 3; ++i) server.setBlock(i, 3, 0, Block::Obsidian);
|
|
for (uint64_t tick = 60; tick < 100; ++tick) {
|
|
server.update(tick);
|
|
near.step(tick);
|
|
far.step(tick);
|
|
}
|
|
|
|
for (int i = 0; i < 3; ++i) CHECK(near.world.blockAt(i, 3, 0) == Block::Obsidian);
|
|
CHECK_EQ(near.session->stats().blockChangesApplied, static_cast<uint64_t>(3));
|
|
CHECK_EQ(far.session->stats().blockChangesApplied, static_cast<uint64_t>(0));
|
|
CHECK_EQ(far.session->stats().multiBlockChangesApplied, static_cast<uint64_t>(0));
|
|
CHECK_EQ(far.world.chunkAt(Vec3i{0, 0, 0}), nullptr);
|
|
CHECK_EQ(server.stats().blockUpdatesSent, static_cast<uint64_t>(3));
|
|
}
|
|
|
|
VF_TEST(anEditFromOneClientIsBroadcastToTheOtherThroughTheAuthoritativeWorld) {
|
|
ServerConfig config = quietServerConfig();
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -2, 2);
|
|
|
|
int slotA = server.acceptClient();
|
|
int slotB = server.acceptClient();
|
|
placeAt(server, slotA, 8.0f, 8.0f, 8.0f);
|
|
placeAt(server, slotB, 8.0f, 8.0f, 8.0f);
|
|
|
|
TransportConfig transportConfig = config.transport;
|
|
SessionConfig sessionConfig = clientConfigFor(config);
|
|
RemoteClient builder(server, slotA, transportConfig, sessionConfig, "builder");
|
|
RemoteClient watcher(server, slotB, transportConfig, sessionConfig, "watcher");
|
|
for (uint64_t tick = 0; tick < 40; ++tick) {
|
|
server.update(tick);
|
|
builder.step(tick);
|
|
watcher.step(tick);
|
|
}
|
|
|
|
builder.session->requestBlockEdit(4, 9, 4, Block::Glowstone);
|
|
for (uint64_t tick = 40; tick < 80; ++tick) {
|
|
server.update(tick);
|
|
builder.step(tick);
|
|
watcher.step(tick);
|
|
}
|
|
|
|
CHECK(world.blockAt(4, 9, 4) == Block::Glowstone);
|
|
CHECK(builder.world.blockAt(4, 9, 4) == Block::Glowstone);
|
|
CHECK(watcher.world.blockAt(4, 9, 4) == Block::Glowstone);
|
|
CHECK_EQ(server.stats().editsApplied, static_cast<uint64_t>(1));
|
|
CHECK_EQ(watcher.session->stats().blockChangesApplied, static_cast<uint64_t>(1));
|
|
}
|
|
|
|
VF_TEST(theBandwidthBudgetDelaysPacketsAcrossTicksWithoutLosingAnyOfThem) {
|
|
ServerConfig config = quietServerConfig();
|
|
config.viewRadius = 1;
|
|
config.chunksPerClientPerTick = 4;
|
|
config.bytesPerClientPerTick = 220;
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -3, 3);
|
|
|
|
int slot = server.acceptClient();
|
|
placeAt(server, slot, 8.0f, 8.0f, 8.0f);
|
|
TransportConfig transportConfig = config.transport;
|
|
RemoteClient only(server, slot, transportConfig, clientConfigFor(config), "budgeted");
|
|
|
|
bool everQueued = false;
|
|
uint64_t peakQueuedBytes = 0;
|
|
for (uint64_t tick = 0; tick < 40; ++tick) {
|
|
server.update(tick);
|
|
only.step(tick);
|
|
if (server.stats().queuedPackets > 0) everQueued = true;
|
|
if (server.stats().queuedBytes > peakQueuedBytes)
|
|
peakQueuedBytes = server.stats().queuedBytes;
|
|
// A single oversized packet is allowed through on its own, but the
|
|
// budget must never be exceeded by a whole extra packet.
|
|
CHECK(server.stats().bytesSentThisTick <= 220u + 4096u);
|
|
}
|
|
CHECK(everQueued);
|
|
CHECK(peakQueuedBytes > 220u);
|
|
|
|
for (uint64_t tick = 40; tick < 400; ++tick) {
|
|
server.update(tick);
|
|
only.step(tick);
|
|
}
|
|
CHECK_EQ(server.stats().queuedPackets, static_cast<uint64_t>(0));
|
|
CHECK_EQ(only.world.chunkCount(), static_cast<std::size_t>(5));
|
|
CHECK_EQ(only.session->stats().chunksApplied, static_cast<uint64_t>(5));
|
|
|
|
// Nothing was dropped on the way: the client sees the same blocks.
|
|
for (int x = 0; x < chunkSize; ++x)
|
|
for (int z = 0; z < chunkSize; ++z)
|
|
CHECK(only.world.blockAt(x, 3, z) == world.blockAt(x, 3, z));
|
|
}
|
|
|
|
VF_TEST(anUnbudgetedServerSendsTheSameChunksInFarFewerTicks) {
|
|
ServerConfig budgeted = quietServerConfig();
|
|
budgeted.viewRadius = 1;
|
|
budgeted.chunksPerClientPerTick = 4;
|
|
budgeted.bytesPerClientPerTick = 220;
|
|
|
|
ServerConfig open = budgeted;
|
|
open.bytesPerClientPerTick = 0;
|
|
|
|
uint64_t ticksNeeded[2] = {0, 0};
|
|
for (int variant = 0; variant < 2; ++variant) {
|
|
const ServerConfig& config = variant == 0 ? budgeted : open;
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -3, 3);
|
|
int slot = server.acceptClient();
|
|
placeAt(server, slot, 8.0f, 8.0f, 8.0f);
|
|
TransportConfig transportConfig = config.transport;
|
|
RemoteClient only(server, slot, transportConfig, clientConfigFor(config), "probe");
|
|
|
|
uint64_t tick = 0;
|
|
for (; tick < 500; ++tick) {
|
|
server.update(tick);
|
|
only.step(tick);
|
|
if (only.world.chunkCount() == 5) break;
|
|
}
|
|
ticksNeeded[variant] = tick;
|
|
CHECK_EQ(only.world.chunkCount(), static_cast<std::size_t>(5));
|
|
}
|
|
CHECK(ticksNeeded[0] > ticksNeeded[1]);
|
|
CHECK(ticksNeeded[1] < 20u);
|
|
}
|
|
|
|
VF_TEST(theServerRefusesConnectionsOnceEverySlotIsTaken) {
|
|
ServerConfig config = quietServerConfig();
|
|
config.maxClients = 2;
|
|
World world;
|
|
NetServer server(world, config);
|
|
|
|
CHECK_EQ(server.slotCount(), static_cast<std::size_t>(2));
|
|
CHECK_EQ(server.acceptClient(), 0);
|
|
CHECK_EQ(server.acceptClient(), 1);
|
|
CHECK_EQ(server.acceptClient(), -1);
|
|
CHECK_EQ(server.acceptClient(), -1);
|
|
CHECK_EQ(server.stats().rejectedConnections, static_cast<uint64_t>(2));
|
|
CHECK_EQ(server.stats().acceptedConnections, static_cast<uint64_t>(2));
|
|
CHECK_EQ(server.activeClients(), 2u);
|
|
CHECK_EQ(server.linkFor(2), nullptr);
|
|
CHECK_EQ(server.sessionFor(-1), nullptr);
|
|
|
|
server.dropClient(0);
|
|
CHECK_EQ(server.activeClients(), 1u);
|
|
CHECK_EQ(server.acceptClient(), 0);
|
|
CHECK_EQ(server.activeClients(), 2u);
|
|
}
|
|
|
|
VF_TEST(aSilentClientTimesOutAndItsSlotComesBackForReuse) {
|
|
ServerConfig config = quietServerConfig();
|
|
config.maxClients = 1;
|
|
config.keepAliveIntervalTicks = 5;
|
|
config.keepAliveTimeoutTicks = 40;
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -2, 2);
|
|
|
|
int slot = server.acceptClient();
|
|
TransportConfig transportConfig = config.transport;
|
|
{
|
|
RemoteClient leaving(server, slot, transportConfig, clientConfigFor(config), "leaving");
|
|
for (uint64_t tick = 0; tick < 30; ++tick) {
|
|
server.update(tick);
|
|
leaving.step(tick);
|
|
}
|
|
CHECK(server.sessionFor(slot) != nullptr);
|
|
CHECK(server.sessionFor(slot)->phase() == SessionPhase::Play);
|
|
}
|
|
|
|
for (uint64_t tick = 30; tick < 200; ++tick) server.update(tick);
|
|
|
|
CHECK_EQ(server.activeClients(), 0u);
|
|
CHECK_EQ(server.stats().timeouts, static_cast<uint64_t>(1));
|
|
CHECK_EQ(server.stats().connectedClients, 0u);
|
|
CHECK_EQ(server.acceptClient(), 0);
|
|
CHECK_EQ(server.activeClients(), 1u);
|
|
}
|
|
|
|
VF_TEST(entityMovesGoOnlyToTheClientsWhoseViewHoldsTheEntity) {
|
|
ServerConfig config = quietServerConfig();
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -6, 6);
|
|
|
|
int slotNear = server.acceptClient();
|
|
int slotFar = server.acceptClient();
|
|
placeAt(server, slotNear, 8.0f, 8.0f, 8.0f);
|
|
placeAt(server, slotFar, 72.0f, 8.0f, 72.0f);
|
|
TransportConfig transportConfig = config.transport;
|
|
SessionConfig sessionConfig = clientConfigFor(config);
|
|
RemoteClient near(server, slotNear, transportConfig, sessionConfig, "near");
|
|
RemoteClient far(server, slotFar, transportConfig, sessionConfig, "far");
|
|
|
|
for (uint64_t tick = 0; tick < 40; ++tick) {
|
|
server.update(tick);
|
|
near.step(tick);
|
|
far.step(tick);
|
|
}
|
|
|
|
for (uint64_t tick = 40; tick < 70; ++tick) {
|
|
server.moveEntity(31, Vec3{9.0f, 5.0f, 9.0f}, 1.0f, 0.0f, true);
|
|
server.update(tick);
|
|
near.step(tick);
|
|
far.step(tick);
|
|
}
|
|
|
|
EntityMove seen;
|
|
CHECK(near.session->entityMove(31, seen));
|
|
CHECK_NEAR(seen.x, 9.0f, 0.001f);
|
|
CHECK_EQ(far.session->trackedEntityCount(), static_cast<std::size_t>(0));
|
|
CHECK(far.session->stats().entityMovesApplied == 0u);
|
|
}
|
|
|
|
VF_TEST(serverStatsAccountForClientsBytesChunksAndTheOutgoingQueue) {
|
|
ServerConfig config = quietServerConfig();
|
|
config.viewRadius = 1;
|
|
config.chunksPerClientPerTick = 1;
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -2, 2);
|
|
|
|
CHECK_EQ(server.stats().connectedClients, 0u);
|
|
int slot = server.acceptClient();
|
|
placeAt(server, slot, 8.0f, 8.0f, 8.0f);
|
|
TransportConfig transportConfig = config.transport;
|
|
RemoteClient only(server, slot, transportConfig, clientConfigFor(config), "counted");
|
|
|
|
uint64_t bytesSeenInAnyTick = 0;
|
|
for (uint64_t tick = 0; tick < 40; ++tick) {
|
|
server.update(tick);
|
|
only.step(tick);
|
|
bytesSeenInAnyTick += server.stats().bytesSentThisTick;
|
|
}
|
|
|
|
CHECK_EQ(server.stats().connectedClients, 1u);
|
|
CHECK_EQ(server.stats().chunksSent, static_cast<uint64_t>(5));
|
|
CHECK_EQ(server.stats().totalBytesSent, bytesSeenInAnyTick);
|
|
CHECK(server.stats().totalBytesSent > 500u);
|
|
CHECK_EQ(server.stats().queuedPackets, static_cast<uint64_t>(0));
|
|
|
|
server.setBlock(1, 2, 3, Block::Ice);
|
|
server.setBlock(2, 2, 3, Block::Ice);
|
|
for (uint64_t tick = 40; tick < 60; ++tick) {
|
|
server.update(tick);
|
|
only.step(tick);
|
|
}
|
|
CHECK_EQ(server.stats().blockUpdatesSent, static_cast<uint64_t>(2));
|
|
CHECK_EQ(server.stats().editsApplied, static_cast<uint64_t>(2));
|
|
CHECK(only.world.blockAt(1, 2, 3) == Block::Ice);
|
|
}
|
|
|
|
VF_TEST(fourClientsSpreadAcrossTheWorldStayConsistentOverAnUnreliableLink) {
|
|
ServerConfig config = quietServerConfig();
|
|
config.maxClients = 4;
|
|
config.viewRadius = 1;
|
|
config.chunksPerClientPerTick = 2;
|
|
config.link.lossPercent = 25;
|
|
config.link.duplicatePercent = 10;
|
|
config.link.reorderPercent = 20;
|
|
config.link.latencyTicks = 2;
|
|
config.link.seed = 0xc0ffee1234ull;
|
|
config.transport.retransmitTimeoutTicks = 8;
|
|
World world;
|
|
NetServer server(world, config);
|
|
buildTerrain(world, -8, 8);
|
|
|
|
const float spots[4][2] = {{8.0f, 8.0f}, {72.0f, 8.0f}, {8.0f, 72.0f}, {72.0f, 72.0f}};
|
|
std::vector<std::unique_ptr<RemoteClient>> clients;
|
|
TransportConfig transportConfig = config.transport;
|
|
SessionConfig sessionConfig = clientConfigFor(config);
|
|
for (int i = 0; i < 4; ++i) {
|
|
int slot = server.acceptClient();
|
|
CHECK_EQ(slot, i);
|
|
placeAt(server, slot, spots[i][0], 8.0f, spots[i][1]);
|
|
clients.push_back(std::unique_ptr<RemoteClient>(
|
|
new RemoteClient(server, slot, transportConfig, sessionConfig, "player")));
|
|
}
|
|
|
|
Lcg rng(0x9911aabb);
|
|
for (uint64_t tick = 0; tick < 500; ++tick) {
|
|
if (tick > 100 && tick % 5 == 0) {
|
|
int corner = rng.range(4);
|
|
int baseX = static_cast<int>(spots[corner][0]);
|
|
int baseZ = static_cast<int>(spots[corner][1]);
|
|
server.setBlock(baseX + rng.range(8) - 4, rng.range(6), baseZ + rng.range(8) - 4,
|
|
Block::Glowstone);
|
|
}
|
|
server.update(tick);
|
|
for (auto& client : clients) client->step(tick);
|
|
}
|
|
for (uint64_t tick = 500; tick < 800; ++tick) {
|
|
server.update(tick);
|
|
for (auto& client : clients) client->step(tick);
|
|
}
|
|
|
|
CHECK_EQ(server.activeClients(), 4u);
|
|
for (int i = 0; i < 4; ++i) {
|
|
NetSession* session = server.sessionFor(i);
|
|
CHECK(session->phase() == SessionPhase::Play);
|
|
const ClientView& view = session->view();
|
|
CHECK_EQ(view.sent.size(), static_cast<std::size_t>(5));
|
|
for (const Vec3i& coord : view.sent) {
|
|
const Chunk* authoritative = world.chunkAt(coord);
|
|
const Chunk* mirror = clients[static_cast<std::size_t>(i)]->world.chunkAt(coord);
|
|
CHECK(mirror != nullptr);
|
|
if (mirror == nullptr) continue;
|
|
CHECK(authoritative->raw() == mirror->raw());
|
|
}
|
|
// Each client only ever holds the chunks it was told about.
|
|
CHECK_EQ(clients[static_cast<std::size_t>(i)]->world.chunkCount(),
|
|
static_cast<std::size_t>(5));
|
|
}
|
|
CHECK(server.stats().editsApplied > 50u);
|
|
}
|