243 lines
9.6 KiB
C++
243 lines
9.6 KiB
C++
// CLIENT-GAP §3.2 — EntityStore TCP state queue: server-frame release gate,
|
|
// __CanProcessNetworkStatePacket gate, and the FUNC_* switch with its 1.0 / 50.0
|
|
// hard thresholds (no lerp, no jitter buffer). Drives the protocol-neutral
|
|
// mutation API directly (same path the classic backend uses).
|
|
#include "../src/net/entity_store.h"
|
|
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
|
|
using namespace mtnet;
|
|
|
|
static int g_fail = 0;
|
|
#define CHECK(c, msg) \
|
|
do { \
|
|
if (!(c)) { \
|
|
std::fprintf(stderr, "FAIL: %s\n", msg); \
|
|
++g_fail; \
|
|
} \
|
|
} while (0)
|
|
|
|
static void spawn(EntityStore &es, uint32_t vid, float x, float y) {
|
|
es.mut_spawn(vid, 101, 0, "Mob", x, y, 0.0f, 0.0f, 200 /*moving_speed*/, 0);
|
|
}
|
|
|
|
int main() {
|
|
// --- 1) server-frame release gate ---------------------------------------
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
spawn(es, 10, 0, 0);
|
|
es.set_server_frame_ms(1000);
|
|
// command timestamped in the future: stays queued, entity does not move.
|
|
es.mut_move(10, 0.0f, FUNC_MOVE, 500.0f, 0.0f, 0, 0, /*chk_time*/ 2000);
|
|
CHECK(es.get(10)->state_queue.size() == 1, "future cmd stays queued");
|
|
CHECK(!es.get(10)->moving, "future cmd: not moving yet");
|
|
es.process_states();
|
|
CHECK(es.get(10)->state_queue.size() == 1, "still queued below chk_time");
|
|
|
|
es.set_server_frame_ms(2000); // clock reaches the command time
|
|
es.process_states();
|
|
CHECK(es.get(10)->state_queue.empty(), "cmd released once frame clock catches up");
|
|
CHECK(es.get(10)->moving && es.get(10)->func == FUNC_MOVE, "released FUNC_MOVE walks");
|
|
|
|
// frame clock 0 == "not aligned yet" -> release immediately.
|
|
EntityStore es0;
|
|
es0.set_now(0);
|
|
spawn(es0, 11, 0, 0);
|
|
es0.mut_move(11, 0.0f, FUNC_MOVE, 500.0f, 0.0f, 0, 0, /*chk_time*/ 9999);
|
|
CHECK(es0.get(11)->state_queue.empty() && es0.get(11)->moving,
|
|
"frame clock 0 releases regardless of chk_time");
|
|
}
|
|
|
|
// --- 2) FUNC_WAIT: 1.0 threshold (snap-align vs. walk) ------------------
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
spawn(es, 20, 0, 0);
|
|
// within 1.0 -> snap align, no walk.
|
|
es.mut_move(20, 90.0f, FUNC_WAIT, 0.5f, 0.0f, 0, 0, 0);
|
|
CHECK(!es.get(20)->moving, "FUNC_WAIT dir_len<=1.0: no walk");
|
|
CHECK(std::abs(es.get(20)->x - 0.5f) < 1e-3f, "FUNC_WAIT dir_len<=1.0: snapped to Dst");
|
|
CHECK(es.get(20)->func == FUNC_WAIT && std::abs(es.get(20)->angle - 90.0f) < 1e-3f,
|
|
"FUNC_WAIT snap: func + heading applied");
|
|
// beyond 1.0 -> walk there, m_kMovAfterFunc == WAIT.
|
|
es.mut_move(20, 0.0f, FUNC_WAIT, 100.0f, 0.0f, 0, 0, 0);
|
|
CHECK(es.get(20)->moving && es.get(20)->func == FUNC_MOVE, "FUNC_WAIT dir_len>1.0: walks");
|
|
CHECK(es.get(20)->mov_after_func == FUNC_WAIT, "FUNC_WAIT walk: after-func WAIT");
|
|
CHECK(es.get(20)->skip_collision, "network-driven walk enables skip-collision");
|
|
es.set_now(100000);
|
|
es.tick();
|
|
CHECK(!es.get(20)->moving && es.get(20)->func == FUNC_WAIT, "FUNC_WAIT walk: settles to WAIT");
|
|
CHECK(!es.get(20)->skip_collision, "skip-collision cleared on arrival");
|
|
}
|
|
|
|
// --- 3) FUNC_COMBO: 50.0 threshold + after-arrival action --------------
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
spawn(es, 30, 0, 0);
|
|
// near (dir_len 20 < 50) -> snap + act now, arg is on the row's func.
|
|
es.mut_move(30, 45.0f, FUNC_COMBO, 20.0f, 0.0f, 0, /*arg*/ 7, 0);
|
|
CHECK(!es.get(30)->moving && es.get(30)->func == FUNC_COMBO,
|
|
"FUNC_COMBO dir_len<50: snap + act");
|
|
CHECK(std::abs(es.get(30)->x - 20.0f) < 1e-3f, "FUNC_COMBO near: snapped to Dst");
|
|
|
|
// far (dir_len 200 >= 50) -> walk first, combat + arg deferred to arrival.
|
|
es.mut_move(30, 0.0f, FUNC_COMBO, 220.0f, 0.0f, 0, /*arg*/ 9, 0);
|
|
CHECK(es.get(30)->moving && es.get(30)->func == FUNC_MOVE, "FUNC_COMBO dir_len>=50: walks");
|
|
CHECK(es.get(30)->mov_after_func == FUNC_COMBO && es.get(30)->mov_after_arg == 9,
|
|
"FUNC_COMBO far: combo + motion index latched for arrival");
|
|
es.set_now(100000);
|
|
es.tick();
|
|
CHECK(!es.get(30)->moving && es.get(30)->func == FUNC_COMBO,
|
|
"FUNC_COMBO far: combo runs on arrival");
|
|
CHECK(es.get(30)->mov_after_func == FUNC_WAIT, "after-func latch cleared post-arrival");
|
|
}
|
|
|
|
// --- 4) __CanProcessNetworkStatePacket gate (dead / knocked-down) ------
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
spawn(es, 40, 0, 0);
|
|
es.mut_knockdown(40, true);
|
|
es.mut_move(40, 0.0f, FUNC_MOVE, 300.0f, 0.0f, 0, 0, 0);
|
|
CHECK(es.get(40)->state_queue.size() == 1 && !es.get(40)->moving,
|
|
"knocked-down: state cmd held, not applied");
|
|
es.mut_knockdown(40, false);
|
|
es.process_states();
|
|
CHECK(es.get(40)->state_queue.empty() && es.get(40)->moving,
|
|
"recovered: held state cmd releases");
|
|
|
|
es.mut_dead(41); // unknown vid: no-op, must not crash
|
|
spawn(es, 42, 0, 0);
|
|
es.mut_dead(42);
|
|
es.mut_move(42, 0.0f, FUNC_MOVE, 300.0f, 0.0f, 0, 0, 0);
|
|
CHECK(!es.get(42)->moving && es.get(42)->state_queue.size() == 1,
|
|
"dead: state cmd held");
|
|
}
|
|
|
|
// --- 5) queue preserves order and drains multiple due commands --------
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
es.set_server_frame_ms(0);
|
|
spawn(es, 50, 0, 0);
|
|
es.mut_move(50, 0.0f, FUNC_WAIT, 0.2f, 0.0f, 0, 0, 0); // snap (near)
|
|
es.mut_move(50, 0.0f, FUNC_ATTACK, 10.0f, 0.0f, 0, 3, 0); // near attack -> snap + act
|
|
CHECK(es.get(50)->state_queue.empty(), "both due cmds drained in one pass");
|
|
CHECK(es.get(50)->func == FUNC_ATTACK && std::abs(es.get(50)->x - 10.0f) < 1e-3f,
|
|
"last cmd wins: ATTACK at (10,0)");
|
|
}
|
|
|
|
// --- 6) staleness valve: chk_time far ahead of the frame clock -----------
|
|
// Reference StateProcess has no cap; ours releases a command whose chk_time
|
|
// is > STATE_QUEUE_MAX_WAIT_MS ahead of the (unvalidated) server-frame clock
|
|
// so a wrong-timebase dwTime can never freeze the actor forever.
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
es.set_server_frame_ms(1000);
|
|
// exactly at the cap -> still gated.
|
|
spawn(es, 60, 0, 0);
|
|
es.mut_move(60, 0.0f, FUNC_MOVE, 500.0f, 0.0f, 0, 0,
|
|
/*chk_time*/ 1000 + STATE_QUEUE_MAX_WAIT_MS);
|
|
CHECK(es.get(60)->state_queue.size() == 1 && !es.get(60)->moving,
|
|
"chk_time == frame+cap: still gated");
|
|
// one ms past the cap -> treated as out-of-band, released now.
|
|
spawn(es, 61, 0, 0);
|
|
es.mut_move(61, 0.0f, FUNC_MOVE, 500.0f, 0.0f, 0, 0,
|
|
/*chk_time*/ 1000 + STATE_QUEUE_MAX_WAIT_MS + 1);
|
|
CHECK(es.get(61)->state_queue.empty() && es.get(61)->moving && es.get(61)->func == FUNC_MOVE,
|
|
"chk_time past cap: released immediately (staleness valve)");
|
|
}
|
|
|
|
// --- 7) motion-driven remote walk (reference MovementProcess) --------------
|
|
// Speed comes from the WALK/RUN root motion * movSpd/100, not dwDuration;
|
|
// heading follows Src->Dst while walking and takes bRot on arrival.
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
es.mut_spawn(70, 101, 2, "Wolf", 0, 0, 0, 0, 100 /*moving_speed*/, 0);
|
|
es.set_motion_speed(70, 87.5f, 425.0f);
|
|
es.tick();
|
|
// server says 100 ms (it prices NPC walks at RUN speed); ignored here.
|
|
es.mut_move(70, 45.0f, FUNC_WAIT, 1000.0f, 0.0f, 100, 0, 0);
|
|
CHECK(es.get(70)->moving && std::abs(es.get(70)->angle - 90.0f) < 1e-3f,
|
|
"motion walk: faces Src->Dst, not bRot");
|
|
uint32_t now = 0;
|
|
for (int i = 0; i < 10; ++i) {
|
|
now += 100;
|
|
es.set_now(now);
|
|
es.tick();
|
|
}
|
|
CHECK(es.get(70)->moving && std::abs(es.get(70)->x - 425.0f) < 1.0f,
|
|
"motion walk: run mode advances at RUN motion speed, ignores dwDuration");
|
|
es.mut_walk_mode(70, WALKMODE_WALK);
|
|
for (int i = 0; i < 10; ++i) {
|
|
now += 100;
|
|
es.set_now(now);
|
|
es.tick();
|
|
}
|
|
CHECK(std::abs(es.get(70)->x - 512.5f) < 1.0f, "motion walk: walk mode uses WALK motion speed");
|
|
es.mut_change_speed(70, 200); // movSpd 200 doubles the step
|
|
now += 1000;
|
|
es.set_now(now);
|
|
es.tick(); // capped at MOVE_MAX_TICK_MS
|
|
CHECK(std::abs(es.get(70)->x - (512.5f + 175.0f * 0.25f)) < 1.0f,
|
|
"motion walk: movSpd scales speed; tick step capped");
|
|
for (int i = 0; i < 100 && es.get(70)->moving; ++i) {
|
|
now += 100;
|
|
es.set_now(now);
|
|
es.tick();
|
|
}
|
|
CHECK(!es.get(70)->moving && es.get(70)->func == FUNC_WAIT, "motion walk: stops on arrival");
|
|
CHECK(es.get(70)->x == 1000.0f && es.get(70)->y == 0.0f, "motion walk: snaps to Dst");
|
|
CHECK(std::abs(es.get(70)->angle - 45.0f) < 1e-3f, "motion walk: bRot applied on arrival");
|
|
}
|
|
|
|
// --- 8) FUNC_MOVE walks past Dst, overshoot guard turns back and stops ------
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
es.mut_spawn(80, 0, 0, "Pc", 0, 0, 0, 0, 100, 0);
|
|
es.set_motion_speed(80, 0.0f, 1000.0f);
|
|
es.tick();
|
|
es.mut_move(80, 90.0f, FUNC_MOVE, 100.0f, 0.0f, 100, 0, 0);
|
|
uint32_t now = 0;
|
|
for (int i = 0; i < 3; ++i) {
|
|
now += 50;
|
|
es.set_now(now);
|
|
es.tick();
|
|
}
|
|
CHECK(es.get(80)->moving && es.get(80)->x > 100.0f, "FUNC_MOVE: keeps walking past Dst");
|
|
bool turned = false;
|
|
for (int i = 0; i < 40 && es.get(80)->moving; ++i) {
|
|
now += 50;
|
|
es.set_now(now);
|
|
es.tick();
|
|
turned = turned || std::abs(es.get(80)->angle - 270.0f) < 1e-3f;
|
|
}
|
|
CHECK(turned, "FUNC_MOVE overshoot: turns back toward Dst");
|
|
CHECK(!es.get(80)->moving && es.get(80)->x == 100.0f && es.get(80)->func == FUNC_WAIT,
|
|
"FUNC_MOVE overshoot: returns to Dst and stops");
|
|
}
|
|
|
|
// --- 9) unknown motion speed keeps the dwDuration lerp, heading Src->Dst -----
|
|
{
|
|
EntityStore es;
|
|
es.set_now(0);
|
|
spawn(es, 90, 0, 0);
|
|
es.mut_move(90, 0.0f, FUNC_WAIT, 0.0f, -500.0f, 1000, 0, 0);
|
|
CHECK(std::abs(es.get(90)->angle - 180.0f) < 1e-3f, "duration walk: faces Src->Dst");
|
|
es.set_now(500);
|
|
es.tick();
|
|
CHECK(std::abs(es.get(90)->y + 250.0f) < 1e-3f, "duration walk: lerps over dwDuration");
|
|
}
|
|
|
|
if (g_fail == 0) {
|
|
std::printf("PASS: net_state_queue_test (§3.2 TCP state queue / thresholds / gates)\n");
|
|
}
|
|
return g_fail == 0 ? 0 : 1;
|
|
}
|