Merge pull request #13 from NOVIIC/feat/highping

fix: 优化高延迟下游玩体验

Author: NOVIIC

crates/client/src/app.rs

@@ -305,11 +305,17 @@ pub struct Game {
     pub interp: PlayerInterp,
     /// Chunk 快照接收组装器（Remote 端用，Host/Local 闲置）。
     pub chunk_assembler: ChunkAssembler,
+    /// 本地生成的 PlayerInput 序号。Remote 模式也独立递增，不能借用本地 dummy server tick。
+    pub local_input_tick: u32,
     /// 本地位置预测的输入历史（60Hz 推入，PlayerTick reconcile 时修剪）。
     pub input_history: InputHistory,
-    /// Host 时钟与本地时钟的瞬态偏移（ms）：server_time_ms - local_now_ms。
-    /// PlayerTick 每帧覆盖；远端的 rendering target 用。
-    pub server_clock_offset_ms: i64,
+    /// 中等位置误差的剩余软修正量。每个渲染帧应用一小段，避免高 RTT 下画面回弹。
+    pub pending_position_correction: Vec3,
+    /// Host 时钟与本地时钟的平滑偏移（ms）：server_time_ms - local_now_ms。
+    /// Pong 按半 RTT 估算，PlayerTick 提供低权重补充样本；远端插值 target 使用它。
+    pub server_clock_offset_ms: f64,
+    /// 是否已经吃过至少一条 Host 时钟样本。第一条样本直接采用，后续再指数平滑。
+    pub server_clock_synced: bool,
     /// Phase 8：Local/Host 的 OPFS 存储句柄。Remote 不写存档。
     pub storage: Option<OpfsStorage>,
     pub known_persisted: HashSet<voxweb_core::ChunkPos>,
@@ -448,8 +454,11 @@ impl Game {
             remote_players: HashMap::new(),
             interp,
             chunk_assembler: ChunkAssembler::new(),
+            local_input_tick: 0,
             input_history: InputHistory::new(120),
-            server_clock_offset_ms: 0,
+            pending_position_correction: Vec3::ZERO,
+            server_clock_offset_ms: 0.0,
+            server_clock_synced: false,
             storage: None,
             known_persisted: HashSet::new(),
             last_persist_ms: 0.0,

crates/client/src/interp.rs

@@ -4,15 +4,20 @@
 //! 每渲染帧以 `server_time_ms - interp_delay` 作为渲染 target，
 //! 找出 bracket `[a.time, b.time]` 后 lerp position / yaw / pitch。
 //!
-//! Phase 5 不做外推（若 render_time 超出最新快照直接返回最新）；
-//! Phase 7 可加 50ms 外推窗口。
+//! Phase 8 起在缺少未来快照时允许最多 50ms 短外推，降低丢一两帧时的冻结感。
 
 use std::collections::HashMap;
 
 use glam::Vec3;
 
 use voxweb_core::protocol::EntityId;
 
+/// 没有未来快照时允许的短外推窗口。超过该窗口仍停在外推 50ms 的位置，
+/// 避免丢包时远端玩家立刻冻结，同时避免长时间猜测导致穿墙。
+const MAX_EXTRAPOLATE_MS: f64 = 50.0;
+/// 相邻快照距离超过该阈值视为传送或大纠偏，不做插值/外推。
+const TELEPORT_SNAP_DISTANCE_M: f32 = 10.0;
+
 /// 单条远端玩家快照。由 `apply_server_message::PlayerTick` 推入。
 #[derive(Copy, Clone, Debug)]
 struct Sample {
@@ -54,7 +59,7 @@ impl RemoteBuffer {
 
     /// 给定渲染 target（server 时间 ms），返回插值后的 (position, yaw, pitch)。
     /// - target 早于最早样本 → 返回最早
-    /// - target 晚于最新样本 → 返回最新（不外推）
+    /// - target 晚于最新样本 → 按最近速度短外推（最多 50ms）
     /// - 在 [a, b] 之间 → lerp
     fn get(&self, render_server_time_ms: f64) -> Option<(Vec3, f32, f32)> {
         if self.buf.is_empty() {
@@ -74,11 +79,13 @@ impl RemoteBuffer {
             let s = &self.buf[0];
             Some((s.position, s.yaw, s.pitch))
         } else if idx >= self.buf.len() {
-            let s = &self.buf[self.buf.len() - 1];
-            Some((s.position, s.yaw, s.pitch))
+            Some(self.latest_or_extrapolated(render_server_time_ms))
         } else {
             let a = &self.buf[idx - 1];
             let b = &self.buf[idx];
+            if a.position.distance(b.position) > TELEPORT_SNAP_DISTANCE_M {
+                return Some((b.position, b.yaw, b.pitch));
+            }
             let denom = (b.server_time_ms - a.server_time_ms) as f64;
             if denom <= 0.0 {
                 return Some((a.position, a.yaw, a.pitch));
@@ -92,6 +99,29 @@ impl RemoteBuffer {
             Some((position, yaw, pitch))
         }
     }
+
+    fn latest_or_extrapolated(&self, render_server_time_ms: f64) -> (Vec3, f32, f32) {
+        let latest = &self.buf[self.buf.len() - 1];
+        if self.buf.len() < 2 {
+            return (latest.position, latest.yaw, latest.pitch);
+        }
+        let prev = &self.buf[self.buf.len() - 2];
+        if prev.server_time_ms >= latest.server_time_ms
+            || prev.position.distance(latest.position) > TELEPORT_SNAP_DISTANCE_M
+        {
+            return (latest.position, latest.yaw, latest.pitch);
+        }
+
+        let sample_dt_s = (latest.server_time_ms - prev.server_time_ms) as f32 * 0.001;
+        if sample_dt_s <= f32::EPSILON {
+            return (latest.position, latest.yaw, latest.pitch);
+        }
+        let extrapolate_ms =
+            (render_server_time_ms - latest.server_time_ms as f64).clamp(0.0, MAX_EXTRAPOLATE_MS);
+        let velocity = (latest.position - prev.position) / sample_dt_s;
+        let position = latest.position + velocity * (extrapolate_ms as f32 * 0.001);
+        (position, latest.yaw, latest.pitch)
+    }
 }
 
 /// 整个房间的远端玩家插值状态。
@@ -238,14 +268,25 @@ mod tests {
     }
 
     #[test]
-    fn interp_clamps_to_latest_when_render_time_after_all() {
+    fn interp_short_extrapolates_when_render_time_after_latest() {
         let mut interp = PlayerInterp::new();
         interp.delay_ms = 0.0;
         interp.ingest_tick(1, 1000, Vec3::new(0.0, 64.0, 0.0), 0.5, 0.0);
         interp.ingest_tick(1, 2000, Vec3::new(10.0, 64.0, 10.0), 1.0, 0.0);
-        // render 3000 > 最新 2000 → 返回最新
+        // render 3000 > 最新 2000 → 只短外推 50ms，速度为 10m/s
         let (pos, yaw, _) = interp.advance(1, 3000.0).expect("should return latest");
-        assert!((pos - Vec3::new(10.0, 64.0, 10.0)).length() < 0.01);
+        assert!((pos - Vec3::new(10.5, 64.0, 10.5)).length() < 0.01);
         assert!((yaw - 1.0).abs() < 0.01);
     }
+
+    #[test]
+    fn interp_does_not_extrapolate_teleports() {
+        let mut interp = PlayerInterp::new();
+        interp.delay_ms = 0.0;
+        interp.ingest_tick(1, 1000, Vec3::ZERO, 0.0, 0.0);
+        interp.ingest_tick(1, 2000, Vec3::new(20.0, 64.0, 0.0), 0.0, 0.0);
+
+        let (pos, _, _) = interp.advance(1, 2050.0).expect("should return latest");
+        assert!((pos - Vec3::new(20.0, 64.0, 0.0)).length() < 0.01);
+    }
 }

crates/client/src/lib.rs

@@ -42,7 +42,9 @@ use crate::camera::CameraMode;
 use crate::chunk_loader::affected_chunks;
 use crate::input::InputState;
 use crate::mesh_jobs::{MeshPriority, MeshRunStats};
-use crate::prediction::{PendingAction, PendingKind, reconcile_self};
+use crate::prediction::{
+    PendingAction, PendingKind, ReconcileResult, apply_pending_position_correction, reconcile_self,
+};
 use crate::raycast::raycast;
 use crate::storage::{OpfsStorage, WorldStorage};
 use crate::ui::lobby::{
@@ -56,6 +58,11 @@ const MAX_REACH: f32 = 6.0;
 /// Ping 间隔（毫秒）。
 const PING_INTERVAL_MS: f64 = 5000.0;
 
+/// Pong 校时样本权重。Pong 带 RTT 信息，可信度高于裸 PlayerTick。
+const CLOCK_PONG_ALPHA: f64 = 0.2;
+/// PlayerTick 校时样本权重。它可能受单向排队延迟影响，只作为低权重补充。
+const CLOCK_TICK_ALPHA: f64 = 0.05;
+
 /// 信令服务 URL meta tag 名称。
 const SIGNALING_META_NAME: &str = "signaling-url";
 
@@ -1844,7 +1851,10 @@ fn render_game_frame(
             return Ok(());
         };
         let now = now_ms();
-        if game.entity_id != 0 && now - game.last_ping_sent_ms >= PING_INTERVAL_MS {
+        if game.mode != GameMode::Local
+            && game.entity_id != 0
+            && now - game.last_ping_sent_ms >= PING_INTERVAL_MS
+        {
             let client_time_ms = now as u64;
             game.pending_pings.insert(client_time_ms, now);
             // 上限 16 个待办，避免长期不通时无限增长
@@ -1934,30 +1944,34 @@ fn render_game_frame(
                 game.physics.step(&getter, &game.camera, &neutral, dt);
             }
         }
+        apply_pending_position_correction(
+            &mut game.physics,
+            &mut game.pending_position_correction,
+            dt,
+        );
         game.camera.position = game.physics.eye_position();
 
         // 60Hz 逻辑帧
         game.frame_clock.accumulate(dt);
         let mut steps_consumed: u32 = 0;
         let server_tick_allowed = matches!(game.mode, GameMode::Local | GameMode::Host);
+        let mut last_input_tick_to_send = None;
         while game.frame_clock.consume_logic_step() {
             if server_tick_allowed {
                 game.server.borrow_mut().tick();
             }
-            // 每个逻辑步推一条 input history（Host reconcile 用；Remote 也可靠它追踪本地步数）
+            // 每个逻辑步分配本地输入序号。Remote 不能借 dummy server tick，
+            // 否则 Host 回播时无法把权威位置和同一条预测记录对齐。
+            game.local_input_tick = game.local_input_tick.wrapping_add(1).max(1);
             game.input_history
-                .push(game.server.borrow().tick, game.physics.feet_position);
+                .push(game.local_input_tick, game.physics.feet_position);
+            last_input_tick_to_send = Some(game.local_input_tick);
             steps_consumed += 1;
         }
 
-        // 每个 logic step 上报一条 PlayerInput
+        // 若本帧消费了一个或多个逻辑步，只上报最新位置；tick 仍对应最后一个本地输入序号。
         if steps_consumed > 0 && game.entity_id != 0 {
-            let tick = if server_tick_allowed {
-                game.server.borrow().tick
-            } else {
-                // Remote：用自己的 input history 计数（从 physics 最后一次 reconcile 后的步数推导）
-                0 // Phase 5 简化：Remote 的 PlayerInput.tick 用 0；Host Server 不依赖 Remote 的 tick 做排序
-            };
+            let tick = last_input_tick_to_send.unwrap_or(game.local_input_tick);
             game.net.send_client_message(ClientMessage::PlayerInput {
                 tick,
                 position: game.physics.feet_position,
@@ -2108,7 +2122,7 @@ fn render_game_frame(
         let mut view_proj_for_np = glam::Mat4::IDENTITY;
         if let Some(g) = a.game.as_mut() {
             view_proj_for_np = g.camera.vp_matrix();
-            let render_target = now_local + g.server_clock_offset_ms as f64 - g.interp.delay_ms;
+            let render_target = now_local + g.server_clock_offset_ms - g.interp.delay_ms;
             let cam_pos = g.camera.position;
             let eids: Vec<EntityId> = g.interp.ids().collect();
             for eid in eids {
@@ -2316,8 +2330,7 @@ fn render_game_frame(
             let now = now_ms();
             let mut instances: Vec<voxweb_render::passes::player::PlayerInstance> = Vec::new();
             if let Some(ref mut game) = a.game {
-                let render_server_time =
-                    now + game.server_clock_offset_ms as f64 - game.interp.delay_ms;
+                let render_server_time = now + game.server_clock_offset_ms - game.interp.delay_ms;
                 let eids: Vec<voxweb_core::protocol::EntityId> = game.interp.ids().collect();
                 for eid in eids {
                     if let Some((pos, _yaw, _pitch)) = game.interp.advance(eid, render_server_time)
@@ -2503,9 +2516,16 @@ fn dispatch_actions(game: &mut Game, input: &InputState) {
             let server = game.server.borrow();
             server.world.get_block(pos)
         };
-        // Local 模式 client 和 server 共享同一份 world，乐观更新会干扰 server 校验
-        // （server 读回 AIR 误判 BlockNotEmpty 拒绝）。因此跳过乐观 set_block；
-        // BlockUpdate 返回后再重 mesh。Phase 5 Remote 端加独立 WorldView 时再加乐观路径。
+        let input_tick = game.local_input_tick;
+        let player_position = game.physics.feet_position;
+        // Remote 的 server.world 只是本地世界视图，可以安全乐观修改；
+        // Local/Host 与权威 server 共享同一份 world，仍等 BlockUpdate，避免提前改世界干扰校验。
+        if game.mode == GameMode::Remote {
+            game.server.borrow_mut().world.set_block(pos, BlockID::AIR);
+            for cp in affected_chunks(pos) {
+                game.mesh_jobs.enqueue(cp, MeshPriority::High);
+            }
+        }
         let request_id = game.pending.next_request_id();
         game.pending.insert(
             request_id,
@@ -2515,8 +2535,12 @@ fn dispatch_actions(game: &mut Game, input: &InputState) {
                 backup,
             },
         );
-        game.net
-            .send_client_message(ClientMessage::Break { pos, request_id });
+        game.net.send_client_message(ClientMessage::Break {
+            pos,
+            request_id,
+            input_tick,
+            player_position,
+        });
         game.last_break_at_ms = now;
     }
 
@@ -2545,6 +2569,8 @@ fn dispatch_actions(game: &mut Game, input: &InputState) {
             return;
         }
         let request_id = game.pending.next_request_id();
+        let input_tick = game.local_input_tick;
+        let player_position = game.physics.feet_position;
         game.pending.insert(
             request_id,
             PendingAction {
@@ -2553,10 +2579,18 @@ fn dispatch_actions(game: &mut Game, input: &InputState) {
                 backup,
             },
         );
+        if game.mode == GameMode::Remote {
+            game.server.borrow_mut().world.set_block(neighbor, block);
+            for cp in affected_chunks(neighbor) {
+                game.mesh_jobs.enqueue(cp, MeshPriority::High);
+            }
+        }
         game.net.send_client_message(ClientMessage::Place {
             pos: neighbor,
             block,
             request_id,
+            input_tick,
+            player_position,
         });
     }
 }
@@ -2575,6 +2609,21 @@ fn send_chat(game: &mut Game, content: String) {
         .send_client_message(ClientMessage::Chat { content });
 }
 
+/// 摄入一条 Host 时钟偏移样本。
+///
+/// 高延迟网络下，直接用最新 `server_time_ms - now` 覆盖偏移会让远端玩家插值 target
+/// 来回抖动。这里第一条样本直接采用，后续做指数平滑；Pong 样本权重较高，
+/// PlayerTick 样本只做低权重微调。
+fn ingest_server_clock_sample(game: &mut Game, estimated_offset_ms: f64, alpha: f64) {
+    if !game.server_clock_synced {
+        game.server_clock_offset_ms = estimated_offset_ms;
+        game.server_clock_synced = true;
+        return;
+    }
+    let a = alpha.clamp(0.0, 1.0);
+    game.server_clock_offset_ms = game.server_clock_offset_ms * (1.0 - a) + estimated_offset_ms * a;
+}
+
 fn apply_server_message(game: &mut Game, msg: ServerMessage) {
     match msg {
         ServerMessage::Welcome {
@@ -2672,18 +2721,31 @@ fn apply_server_message(game: &mut Game, msg: ServerMessage) {
             players,
             server_time_ms,
         } => {
-            let now = (now_ms()) as i64;
-            game.server_clock_offset_ms = server_time_ms as i64 - now;
+            let now = now_ms();
+            if game.mode != GameMode::Local {
+                let one_way_ms = game.rtt_ms.map(|rtt| rtt as f64 * 0.5).unwrap_or(0.0);
+                let estimated_offset = server_time_ms as f64 + one_way_ms - now;
+                ingest_server_clock_sample(game, estimated_offset, CLOCK_TICK_ALPHA);
+            }
 
             for snap in &players {
                 if snap.entity_id == game.entity_id {
                     // 自己的权威位置 → reconcile
-                    let _r = reconcile_self(
+                    let result = reconcile_self(
                         snap.position,
-                        server_tick,
+                        snap.last_input_tick,
                         &mut game.physics,
                         &mut game.input_history,
                     );
+                    match result {
+                        ReconcileResult::SoftCorrection(delta) => {
+                            game.pending_position_correction += delta;
+                        }
+                        ReconcileResult::HardCorrection(_) => {
+                            game.pending_position_correction = glam::Vec3::ZERO;
+                        }
+                        ReconcileResult::Ok | ReconcileResult::MissingHistory => {}
+                    }
                 } else {
                     // 远端玩家 → 喂入插值缓冲
                     game.interp.ingest_tick(
@@ -2735,11 +2797,17 @@ fn apply_server_message(game: &mut Game, msg: ServerMessage) {
         }
         ServerMessage::Pong {
             client_time_ms,
-            server_time_ms: _,
+            server_time_ms,
         } => {
             if let Some(sent_ms) = game.pending_pings.remove(&client_time_ms) {
-                let rtt = (now_ms() - sent_ms) as f32;
-                game.rtt_ms = Some(rtt);
+                let now = now_ms();
+                let rtt = (now - sent_ms) as f32;
+                game.rtt_ms = Some(match game.rtt_ms {
+                    Some(prev) => prev * 0.8 + rtt * 0.2,
+                    None => rtt,
+                });
+                let estimated_offset = server_time_ms as f64 + (rtt as f64 * 0.5) - now;
+                ingest_server_clock_sample(game, estimated_offset, CLOCK_PONG_ALPHA);
             }
         }
     }