Add M10.7a tick clock and remote-marker interpolation
Foundation / checks (deploy) (push) Successful in 6s
Foundation / checks (ecs) (push) Successful in 1m59s
Foundation / checks (client) (push) Successful in 12m44s
Foundation / checks (network) (push) Successful in 12m45s
Foundation / checks (tsan) (push) Successful in 8m5s
Foundation / checks (checks) (push) Successful in 32m4s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 21m38s

ADR-0095 (presentation only): a drift-corrected monotonic tick clock that
never runs more than one tick past the newest observation; remote probe
markers shown 2-6 ticks behind (adaptive to snapshot gaps), interpolated,
extrapolated for at most 2 ticks and then marked stale; appearance and
removal at their snapshot ticks; organisms never extrapolated; sub-tick
own-marker prediction.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dingo
2026-10-06 17:16:20 -04:00
co-authored by Claude Opus 5.5
parent 61d899de3c
commit 90cdb61e30
12 changed files with 539 additions and 5 deletions
+3 -2
View File
@@ -37,7 +37,8 @@ add_library(evo_network_protocol STATIC src/network/protocol/codec.cpp
target_link_libraries(evo_network_protocol PUBLIC evo_client_views evo_client_controls)
evo_owned_target(evo_network_protocol)
# M10.6 client prediction and reconciliation of the probe marker (ADR-0094).
add_library(evo_client_prediction STATIC src/client/prediction/motion_prediction.cpp)
add_library(evo_client_prediction STATIC src/client/prediction/motion_prediction.cpp
src/client/prediction/interpolation.cpp)
target_link_libraries(evo_client_prediction PUBLIC evo_network_protocol)
evo_owned_target(evo_client_prediction)
# Mbed TLS adapters: dev grants (HMAC-SHA256 via PSA) and the TLS 1.3 channel.
@@ -65,7 +66,7 @@ evo_owned_target(evo-dev-session)
if(BUILD_TESTING)
add_executable(evo-network-tests tests/network_protocol.cpp tests/network_tls.cpp
tests/network_session.cpp tests/network_control.cpp tests/network_replication.cpp
tests/network_motion.cpp tests/network_main.cpp)
tests/network_motion.cpp tests/network_interpolation.cpp tests/network_main.cpp)
# The TLS tests generate throwaway dev certificates with Mbed TLS directly.
target_link_libraries(evo-network-tests PRIVATE evo_network_session evo_identity
evo_client_prediction mbedtls)
+3 -1
View File
@@ -531,7 +531,9 @@ probe) with process evidence done; 10.5c engineering client switched to M10 sess
10.6 split (ADR-0094, EXPERIMENT probe marker, not an organism movement rule): 10.6a shared
probe-motion-v1 rule, server markers, session protocol v3 marker records and the client
predictor done; 10.6b wiring (sessions, evo-server, probe, GUI marker) done; 10.6c impaired
traces done (networking/M10_PREDICTION_TRACES.md). 10.7-10.9 planned.
traces done (networking/M10_PREDICTION_TRACES.md). 10.7 split (ADR-0095): 10.7a tick clock,
remote-marker interpolation and fractional prediction done; 10.7b client wiring, loss view
and two-client trace follow. 10.8-10.9 planned.
**Entry:** M9 client/session evidence and M7/M8 dev/stage durability. Read
NETWORK_ARCHITECTURE, PERSISTENCE_ARCHITECTURE and ADR-0017. The M9 transport is
+4 -2
View File
@@ -59,8 +59,10 @@ M10.6b wires it: evo-server gives every session a marker in the habitat area, th
prints it, and the engineering client predicts and draws it (WASD), following it with
camera and interest. M10.6c traces it through the impairment relay: exact without loss,
94-99 % exact at 60-200 ms RTT with 2-5 % loss, convergence after stopping and a restart
resync of about 2-3 s (networking/M10_PREDICTION_TRACES.md). M10.6 is complete. Next: M10.7
interpolation and session loss.
resync of about 2-3 s (networking/M10_PREDICTION_TRACES.md). M10.6 is complete. M10.7a (ADR-0095) adds a drift-corrected tick clock, adaptive
interpolation of remote markers (2-6 ticks behind, at most 2 ticks extrapolated, then
stale; organisms never) and sub-tick own-marker presentation. Next: 10.7b client wiring,
the stale loss view and a two-client trace.
## Previous gate - 2026-10-02
@@ -0,0 +1,57 @@
# ADR-0095: M10 tick clock, remote interpolation and session loss
## Status
Accepted for M10.7 (2026-10-06). Decisions confirmed with the maintainer on 2026-10-06:
- an adaptive interpolation delay of 2-6 ticks;
- remote markers extrapolate at most 2 ticks, and organisms never;
- on session loss the last view stays frozen, dimmed and labelled stale, and a reconnect
starts from a fresh baseline;
- a drift-corrected client tick clock, with sub-tick presentation.
Delivery: 10.7a the headless clock, interpolator and fractional prediction (this text);
10.7b engineering client wiring, the loss view and a two-client trace. Each segment amends
this ADR. Presentation only: none of it is authority, and no outcome is invented.
## Context
NETWORK_ARCHITECTURE requires remote entities to interpolate buffered snapshots with
bounded extrapolation, loss to request a fresh baseline, and death, mutation and
reproduction to remain server decisions. M10.6 (ADR-0094) predicts the own probe marker at
whole ticks. Other markers are drawn as last replicated, so they step at 20 Hz and jump
when a snapshot is lost. No controllable organism moves yet.
## Decision (10.7a)
- **Tick clock** (`include/evo/client/interpolation.hpp`). Each observed server tick
(watermark or snapshot) slews a local estimate by 10 % of the error. An error beyond 4
ticks snaps forward. The estimate is monotonic between resets and never more than one
tick beyond the newest observation, so a silent or paused server freezes it rather than
inventing time. Assumes 50 ms ticks; drift of ±4 % stays within 1.5 ticks in tests.
- **Remote markers** are presented at `clock - delay`, interpolated linearly between the
buffered snapshots around that tick (at most 16 snapshots).
- A marker appears at the tick of the snapshot that adds it.
- It is shown unmoved until the tick of the snapshot that removes it: never moved toward
a removal.
- Snapshots more than 8 ticks apart are not interpolated across.
- Reordered or duplicate snapshots are ignored.
- Beyond the newest snapshot the replicated held vector continues for at most 2 ticks;
then the marker freezes there and is marked stale.
- **Adaptive delay.** The target is the 90th-percentile gap between received snapshots
(last 40) plus one tick, within 2-6. The delay rises toward it at 2 ticks/s and falls at
0.5 ticks/s.
- **Organisms** are never extrapolated or interpolated: they are shown as replicated (newest
snapshot, ADR-0093). A dead or removed organism is therefore never shown moving or as
present after its removal.
- **Own marker between ticks.** `MotionPredictor::predict_between(tick, fraction)`
interpolates the prediction between two whole ticks for presentation. Error measurement
still records whole ticks.
## Alternatives considered
- A fixed 2- or 3-tick delay: simpler, but either stutters on lossy links or adds latency
on good ones.
- No extrapolation: visible stalls on every lost snapshot.
- Longer extrapolation (4 ticks): larger errors when a remote changes direction.
- Clock from the local timer only: drifts without bound against the server's pacing.
## Consequences
- Remote markers are shown 100-300 ms in the past, the own marker in the predicted
present. That is the usual split; interactions that need both are later work.
- Extrapolated or stale markers are flagged so the client can draw them differently.
+32
View File
@@ -4603,3 +4603,35 @@ The Postgres suite was not rerun: no server code changed since 10.6b.
Not done:
- traces over the dev route (a v3 server must be deployed first);
- many-client load (10.8).
## 2026-10-06 — M10.7a tick clock and remote interpolation (ADR-0095)
Implemented:
- `TickClock` (slew 10 %, forward snap beyond 4 ticks, monotonic, at most 1 tick beyond the
newest observation);
- `MarkerInterpolator`:
- interpolation, then at most 2 ticks of extrapolation, then stale;
- appearance and removal at their snapshot ticks;
- reordering ignored; no interpolation across gaps over 8 ticks;
- adaptive delay of 2-6 ticks from the 90th-percentile gap;
- `MotionPredictor::predict_between`.
Tests (`tests/network_interpolation.cpp`):
- clock basics: freeze while silent, no backward step, forward snap, reset;
- drift with jitter at 0 % and ±4 % (4,000 ticks): within 1.5 ticks, monotonic, no snaps;
- interpolation, removal, appearance, extrapolation and staleness, reordering, long gaps,
reset;
- adaptive delay up and down;
- fractional prediction.
Executed:
- **Linux GCC 14:**
- preset `quic`: 4/4;
- `client-network`: 15/15.
- **Linux Clang 19:** ASan/UBSan `evo-network-tests`, and clang-tidy 19 on the new sources
and tests (after fixing one optional-access finding).
- **Windows MSVC 19.44:**
- preset `quic`: 4/4 (rebuilt after the fix);
- `client-network`: 13/13.
Not done: client wiring, the loss view and the two-client trace (10.7b).
+110
View File
@@ -0,0 +1,110 @@
#pragma once
#include "evo/network/probe_motion.hpp"
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <deque>
#include <optional>
#include <span>
#include <vector>
// M10.7 client tick clock and remote-entity interpolation (ADR-0095). Headless,
// single-owner, presentation only: nothing here is authority or decides an outcome.
namespace evo::client {
// A drift-corrected, monotonic estimate of the server's simulated tick between snapshots.
// Each observation (a tick the client just learned the server had simulated) slews the
// estimate toward it by a fraction; a large disagreement snaps forward, never backward. The
// estimate never runs more than `max_ahead` ticks beyond the newest observation, so a
// paused or silent server freezes it instead of inventing time.
struct TickClockLimits {
double tick_ms{50};
double gain{0.1}; // Fraction of the error corrected per observation.
double snap_ticks{4}; // Errors beyond this snap (forward) instead of slewing.
double max_ahead{1.0}; // Ticks beyond the newest observation.
};
class TickClock {
public:
using Clock = std::chrono::steady_clock;
explicit TickClock(TickClockLimits limits = {}) : limits_{limits} {}
void reset() noexcept;
void observe(std::uint64_t tick, Clock::time_point now);
// The estimated server tick (fractional) at `now`; nothing before the first observation.
// Never decreases between resets.
[[nodiscard]] std::optional<double> at(Clock::time_point now);
[[nodiscard]] std::uint64_t snaps() const noexcept {
return snaps_;
}
private:
[[nodiscard]] double raw(double base, Clock::time_point now) const;
TickClockLimits limits_;
std::optional<double> base_tick_;
Clock::time_point base_time_{};
std::uint64_t newest_{};
double returned_{};
std::uint64_t snaps_{};
};
// Remote probe markers (other sessions'), shown `delay` ticks behind the clock and
// interpolated between the buffered snapshots around that render tick. Beyond the newest
// snapshot a marker continues its replicated held vector for at most `max_extrapolation`
// ticks, then freezes and is marked stale. A marker appears at the tick of the snapshot that
// added it and disappears at the tick of the one that removed it (never interpolated toward a
// removal). Snapshots further apart than `max_gap` are not interpolated across (the newer
// one is shown from its tick). The delay adapts to the observed gaps between received
// snapshots (lost or late ones), within [min_delay, max_delay].
struct InterpolationLimits {
double min_delay{2}, max_delay{6}; // Ticks (ADR-0095).
double max_extrapolation{2}; // Ticks beyond the newest snapshot.
std::uint64_t max_gap{8}; // Ticks between snapshots still interpolated.
std::size_t max_snapshots{16}; // Buffered snapshots.
std::size_t gap_window{40}; // Recent arrivals the delay adapts to.
double raise_per_second{2}, lower_per_second{0.5}; // Delay adaptation speed (ticks/s).
};
struct RemoteMarker {
std::uint64_t id{};
network::motion::State state;
};
struct PresentedMarker {
std::uint64_t id{};
double x{}, y{}; // Micrometres.
bool extrapolated{}, stale{};
};
struct InterpolationStats {
std::uint64_t snapshots{}, ignored{}, extrapolated_frames{}, stale_frames{}, gap_snaps{};
};
class MarkerInterpolator {
public:
explicit MarkerInterpolator(InterpolationLimits limits = {})
: limits_{limits}, delay_{limits.min_delay}, target_{limits.min_delay} {}
void reset();
// A complete snapshot's remote markers (all of them: absence means removal). Snapshots
// not newer than the newest buffered one are ignored (reordering).
void push(std::uint64_t tick, std::span<const RemoteMarker> markers);
// Moves the delay toward its target (call once per frame).
void advance(double elapsed_ms);
// Markers at render tick `clock - delay()`.
[[nodiscard]] std::vector<PresentedMarker> at(double render_tick);
[[nodiscard]] double delay() const noexcept {
return delay_;
}
[[nodiscard]] double target_delay() const noexcept {
return target_;
}
[[nodiscard]] const InterpolationStats& stats() const noexcept {
return stats_;
}
private:
struct Snapshot {
std::uint64_t tick{};
std::vector<RemoteMarker> markers; // Sorted by id.
};
InterpolationLimits limits_;
std::deque<Snapshot> snapshots_;
std::deque<std::uint64_t> gaps_;
double delay_, target_;
InterpolationStats stats_;
};
} // namespace evo::client
+6
View File
@@ -54,6 +54,12 @@ class MotionPredictor {
// The predicted state after `tick` (the presented tick: server tick plus input lead);
// nothing before the first authoritative state.
[[nodiscard]] std::optional<network::motion::State> predict(std::uint64_t tick);
// M10.7 (ADR-0095): the position `fraction` (0..1) of the way from tick to tick + 1, for
// presentation between ticks; records the prediction for `tick` like predict().
struct Point {
double x{}, y{}; // Micrometres.
};
[[nodiscard]] std::optional<Point> predict_between(std::uint64_t tick, double fraction);
// The jump rebasing made to the newest prediction (old minus new), since the last call.
struct Offset {
std::int64_t x{}, y{};
+147
View File
@@ -0,0 +1,147 @@
#include "evo/client/interpolation.hpp"
#include <algorithm>
#include <cmath>
namespace evo::client {
namespace {
double ms(TickClock::Clock::duration d) {
return std::chrono::duration<double, std::milli>(d).count();
}
// Held-vector motion in micrometres for a fractional number of ticks (presentation only).
double motion_um(std::int16_t component, double ticks) {
return static_cast<double>(component) *
static_cast<double>(network::motion::speed_um_per_tick) / 1000.0 * ticks;
}
} // namespace
void TickClock::reset() noexcept {
base_tick_.reset();
newest_ = 0;
returned_ = 0;
}
double TickClock::raw(double base, Clock::time_point now) const {
return base + (ms(now - base_time_) / limits_.tick_ms);
}
void TickClock::observe(std::uint64_t tick, Clock::time_point now) {
newest_ = std::max(newest_, tick);
const auto sample = static_cast<double>(tick);
if (!base_tick_) {
base_tick_ = sample;
base_time_ = now;
return;
}
const auto estimate = raw(*base_tick_, now);
const auto error = sample - estimate;
if (error > limits_.snap_ticks) {
base_tick_ = sample; // Far behind (a pause or a reconnect): catch up at once.
++snaps_;
} else {
base_tick_ = estimate + (error * limits_.gain); // Slew; at() keeps it monotonic.
}
base_time_ = now;
}
std::optional<double> TickClock::at(Clock::time_point now) {
if (!base_tick_)
return std::nullopt;
const auto bounded =
std::min(raw(*base_tick_, now), static_cast<double>(newest_) + limits_.max_ahead);
returned_ = std::max(returned_, bounded);
return returned_;
}
void MarkerInterpolator::reset() {
snapshots_.clear();
gaps_.clear();
delay_ = target_ = limits_.min_delay;
}
void MarkerInterpolator::push(std::uint64_t tick, std::span<const RemoteMarker> markers) {
if (!snapshots_.empty() && tick <= snapshots_.back().tick) {
++stats_.ignored;
return;
}
++stats_.snapshots;
if (!snapshots_.empty()) {
gaps_.push_back(tick - snapshots_.back().tick);
while (gaps_.size() > limits_.gap_window)
gaps_.pop_front();
// Cover the 90th-percentile gap between received snapshots, plus the clock's lead.
std::vector<std::uint64_t> sorted(gaps_.begin(), gaps_.end());
std::ranges::sort(sorted);
const auto p90 = sorted.at((sorted.size() - 1) * 9 / 10);
target_ = std::clamp(static_cast<double>(p90) + 1, limits_.min_delay, limits_.max_delay);
}
Snapshot s{tick, {markers.begin(), markers.end()}};
std::ranges::sort(s.markers, {}, &RemoteMarker::id);
snapshots_.push_back(std::move(s));
while (snapshots_.size() > limits_.max_snapshots)
snapshots_.pop_front();
}
void MarkerInterpolator::advance(double elapsed_ms) {
if (elapsed_ms <= 0)
return;
const auto seconds = elapsed_ms / 1000;
if (delay_ < target_)
delay_ = std::min(target_, delay_ + (limits_.raise_per_second * seconds));
else
delay_ = std::max(target_, delay_ - (limits_.lower_per_second * seconds));
}
std::vector<PresentedMarker> MarkerInterpolator::at(double render_tick) {
std::vector<PresentedMarker> out;
if (snapshots_.empty())
return out;
const auto& newest = snapshots_.back();
const auto show = [&](const Snapshot& s) {
for (const auto& m : s.markers)
out.push_back({m.id, static_cast<double>(m.state.x), static_cast<double>(m.state.y)});
};
if (render_tick >= static_cast<double>(newest.tick)) {
// Beyond the newest snapshot: continue the held vector briefly, then freeze (stale).
const auto beyond = render_tick - static_cast<double>(newest.tick);
const auto ticks = std::min(beyond, limits_.max_extrapolation);
const bool stale = beyond > limits_.max_extrapolation;
for (const auto& m : newest.markers)
out.push_back({m.id,
static_cast<double>(m.state.x) + motion_um(m.state.vector.x, ticks),
static_cast<double>(m.state.y) + motion_um(m.state.vector.y, ticks),
ticks > 0, stale});
stats_.extrapolated_frames += ticks > 0 ? 1 : 0;
stats_.stale_frames += stale ? 1 : 0;
return out;
}
if (render_tick <= static_cast<double>(snapshots_.front().tick)) {
show(snapshots_.front()); // Not enough history yet: the oldest as it was.
return out;
}
// a.tick <= render_tick < b.tick.
const auto b = std::ranges::find_if(
snapshots_, [&](const Snapshot& s) { return static_cast<double>(s.tick) > render_tick; });
const auto& a = *std::prev(b);
if (b->tick - a.tick > limits_.max_gap) {
++stats_.gap_snaps; // Too far apart to interpolate: hold the older until the newer.
show(a);
return out;
}
const auto t =
(render_tick - static_cast<double>(a.tick)) / static_cast<double>(b->tick - a.tick);
for (const auto& m : a.markers) {
const auto next = std::ranges::lower_bound(b->markers, m.id, {}, &RemoteMarker::id);
if (next == b->markers.end() || next->id != m.id) {
// Removed by b: shown where it was until b's tick, never moved toward a removal.
out.push_back({m.id, static_cast<double>(m.state.x), static_cast<double>(m.state.y)});
continue;
}
const auto lerp = [t](std::int64_t from, std::int64_t to) {
return static_cast<double>(from) +
((static_cast<double>(to) - static_cast<double>(from)) * t);
};
out.push_back({m.id, lerp(m.state.x, next->state.x), lerp(m.state.y, next->state.y)});
}
return out; // Markers new in b appear from b's tick.
}
} // namespace evo::client
@@ -81,6 +81,19 @@ std::optional<network::motion::State> MotionPredictor::predict(std::uint64_t tic
return state;
}
std::optional<MotionPredictor::Point> MotionPredictor::predict_between(std::uint64_t tick,
double fraction) {
const auto from = predict(tick);
if (!from)
return std::nullopt;
const auto to = replay(tick + 1);
if (!to)
return std::nullopt;
const auto f = std::clamp(fraction, 0.0, 1.0);
return Point{static_cast<double>(from->x) + (static_cast<double>(to->x - from->x) * f),
static_cast<double>(from->y) + (static_cast<double>(to->y - from->y) * f)};
}
std::optional<network::motion::State> MotionPredictor::replay(std::uint64_t tick) {
if (!authority_)
return std::nullopt;
+162
View File
@@ -0,0 +1,162 @@
// M10.7 tick clock and remote-marker interpolation (ADR-0095): monotonic drift-corrected
// clock with pauses and snaps; interpolation, bounded extrapolation and staleness; removal
// and appearance at their snapshot ticks; reordering; long gaps; adaptive delay; fractional
// own-marker prediction.
#include "evo/client/interpolation.hpp"
#include "evo/client/motion_prediction.hpp"
#include "network_test.hpp"
#include <algorithm>
#include <cmath>
#include <vector>
namespace evo::network_test {
namespace {
using evo::client::MarkerInterpolator;
using evo::client::RemoteMarker;
using evo::client::TickClock;
using Clock = TickClock::Clock;
using std::chrono::microseconds;
using std::chrono::milliseconds;
constexpr network::motion::Area area{-50'000'000, -50'000'000, 50'000'000, 50'000'000, 0};
bool near(double a, double b, double tolerance = 1e-6) {
return std::abs(a - b) <= tolerance;
}
void clock_basics() {
TickClock clock;
const auto t0 = Clock::now();
CHECK(!clock.at(t0));
clock.observe(10, t0);
CHECK(near(must(clock.at(t0)), 10));
CHECK(near(must(clock.at(t0 + milliseconds{25})), 10.5));
// Never more than one tick beyond the newest observation: a silent server freezes it.
CHECK(near(must(clock.at(t0 + milliseconds{400})), 11));
// An older observation (late datagram) never moves it backwards.
clock.observe(9, t0 + milliseconds{410});
CHECK(must(clock.at(t0 + milliseconds{410})) >= 11);
// A resume far ahead (pause, reconnect) snaps forward.
clock.observe(200, t0 + milliseconds{5000});
CHECK(clock.snaps() == 1 && near(must(clock.at(t0 + milliseconds{5000})), 200));
clock.reset();
CHECK(!clock.at(t0));
clock.observe(3, t0);
CHECK(near(must(clock.at(t0)), 3)); // After a reset (new epoch) it may start lower.
}
// The server simulates every `period_us`; the client observes each tick after a jittered
// delay and assumes 50 ms ticks. The estimate stays within `bound` ticks of the newest
// observation, never decreases and never snaps.
void clock_drift(std::int64_t period_us, double bound) {
TickClock clock;
const auto t0 = Clock::now();
double previous = 0, worst = 0;
std::uint64_t seed = 0x1234'5678'9ABC'DEF1ULL;
for (std::uint64_t tick = 1; tick <= 4000; ++tick) {
seed = (seed * 6364136223846793005ULL) + 1442695040888963407ULL;
const auto jitter = static_cast<std::int64_t>((seed >> 33) % 15'000); // 0-15 ms.
const auto arrival =
t0 + microseconds{(static_cast<std::int64_t>(tick) * period_us) + 20'000 + jitter};
clock.observe(tick, arrival);
for (const auto probe : {microseconds{0}, microseconds{period_us / 2}}) {
const auto v = must(clock.at(arrival + probe));
CHECK(v >= previous);
previous = v;
worst = std::max(worst, std::abs(v - static_cast<double>(tick)));
}
}
CHECK(worst < bound && clock.snaps() == 0);
}
RemoteMarker marker(std::uint64_t id, std::int64_t x, std::int16_t vx = 1000) {
return {id, {x, 0, {vx, 0}}};
}
void interpolation() {
MarkerInterpolator m;
CHECK(m.at(5).empty());
// Marker 1 moves +100 mm per tick; marker 2 is removed at tick 4; marker 3 appears at 4.
for (std::uint64_t t = 1; t <= 3; ++t) {
const std::vector<RemoteMarker> s{marker(1, static_cast<std::int64_t>(t) * 100'000),
marker(2, 7'000'000, 0)};
m.push(t, s);
}
const std::vector<RemoteMarker> four{marker(1, 400'000), marker(3, -1'000'000, 0)};
m.push(4, four);
CHECK(near(m.target_delay(), 2)); // Every snapshot arrived: the minimum.
auto at = m.at(1.5);
CHECK(at.size() == 2 && at[0].id == 1 && near(at[0].x, 150'000) && at[1].id == 2 &&
near(at[1].x, 7'000'000) && !at[0].extrapolated && !at[0].stale);
// Removal: shown where it was until the removing snapshot's tick, not moved toward it.
at = m.at(3.5);
CHECK(at.size() == 2 && near(at[0].x, 350'000) && at[1].id == 2 && near(at[1].x, 7'000'000));
// Appearance: marker 3 exists only from tick 4.
CHECK(std::ranges::none_of(m.at(3.9), [](const auto& p) { return p.id == 3; }));
at = m.at(4);
CHECK(at.size() == 2 && at[0].id == 1 && at[1].id == 3 && !at[0].extrapolated);
// Beyond the newest: the held vector continues for at most two ticks, then it is stale.
at = m.at(5);
CHECK(near(at[0].x, 500'000) && at[0].extrapolated && !at[0].stale &&
near(at[1].x, -1'000'000)); // A held zero vector does not move.
at = m.at(9);
CHECK(near(at[0].x, 600'000) && at[0].stale && m.stats().stale_frames == 1);
// Reordered (older or equal) snapshots are ignored.
m.push(3, four);
m.push(4, four);
CHECK(m.stats().ignored == 2 && m.stats().snapshots == 4);
// A long gap is not interpolated across: the older is held until the newer's tick.
const std::vector<RemoteMarker> later{marker(1, 9'000'000)};
m.push(20, later);
at = m.at(12);
CHECK(at.size() == 2 && near(at[0].x, 400'000) && m.stats().gap_snaps == 1);
CHECK(near(m.at(20)[0].x, 9'000'000));
m.reset();
CHECK(m.at(20).empty() && near(m.delay(), 2));
}
void adaptive_delay() {
MarkerInterpolator m;
std::uint64_t t = 0;
const std::vector<RemoteMarker> s{marker(1, 0)};
// Every other snapshot lost: gaps of 2 ticks, so the target is 3.
for (int i = 0; i < 20; ++i)
m.push(t += 2, s);
CHECK(near(m.target_delay(), 3) && near(m.delay(), 2));
m.advance(250); // Raised at 2 ticks per second.
CHECK(near(m.delay(), 2.5));
m.advance(1000);
CHECK(near(m.delay(), 3));
// Long gaps raise it to the maximum, never beyond.
for (int i = 0; i < 20; ++i)
m.push(t += 9, s);
m.advance(10'000);
CHECK(near(m.target_delay(), 6) && near(m.delay(), 6));
// A steady stream lowers it slowly (0.5 ticks per second).
for (int i = 0; i < 40; ++i)
m.push(t += 1, s);
CHECK(near(m.target_delay(), 2));
m.advance(1000);
CHECK(near(m.delay(), 5.5));
}
void fractional_prediction() {
client::MotionPredictor p;
CHECK(!p.predict_between(3, 0.5));
CHECK(p.input({1, 3, {1000, 0}}));
p.authoritative({2, 0, {0, 0, {}}, area});
const auto mid = must(p.predict_between(3, 0.5)); // Tick 3 at 100 mm, tick 4 at 200 mm.
CHECK(near(mid.x, 150'000) && near(mid.y, 0));
CHECK(near(must(p.predict_between(3, 2.0)).x, 200'000)); // Fraction clamped to 1.
}
} // namespace
void interpolation_tests() {
clock_basics();
clock_drift(50'000, 1.5);
clock_drift(52'000, 1.5); // Server 4 % slower than assumed.
clock_drift(48'000, 1.5); // Server 4 % faster.
interpolation();
adaptive_delay();
fractional_prediction();
}
} // namespace evo::network_test
+1
View File
@@ -9,6 +9,7 @@ int main() try {
evo::network_test::control_tests();
evo::network_test::replication_tests();
evo::network_test::motion_tests();
evo::network_test::interpolation_tests();
std::puts("network tests passed");
return 0;
} catch (const std::exception& e) {
+1
View File
@@ -29,5 +29,6 @@ void session_tests();
void control_tests();
void replication_tests();
void motion_tests();
void interpolation_tests();
} // namespace evo::network_test
#define CHECK(...) ::evo::network_test::check(static_cast<bool>(__VA_ARGS__))