fix: 修复玩家不从主机请求新区块的bug

Author: NOVIIC

README.md

@@ -87,4 +87,4 @@ docs/
 3. **文档冲突**：以本 README 决策表为准；其余冲突时 `docs/architecture.md` > `docs/modules/*` > `docs/features/*` > 其它
 4. **代码注释**：必须加上详细的中文注释以供没有图形学基础的人学习，但架构说明只放文档不写进注释
 5. **API 变化**：WGPU 等库新版 API 可能有变化，注意查阅最新文档
-6. **代码检查**：完成代码编辑后必须要通过 fmt 和 clippy 检查
+6. **代码检查**：完成代码编辑后必须要通过 fmt 和 clippy --all-targets 检查

crates/client/src/app.rs

@@ -288,6 +288,9 @@ pub struct Game {
     /// Phase 6：房间主机的 entity_id（Local-Only / Host 模式 = 自己；Remote 模式由 Welcome 填）。
     /// 0 表示尚未知晓（Remote 端 Welcome 到达前的瞬态）。
     pub host_entity_id: EntityId,
+    /// Host 允许 Remote 使用的最大视距。Remote 在 Welcome/HostSettings 后填入；
+    /// Local/Host 模式等于自己的设置。
+    pub host_render_distance: u32,
     /// Phase 6：聊天历史（含本地合成的系统消息）。
     pub chat: ChatHistory,
     /// Phase 4：RTT（毫秒）。`None` 表示未测过 / 上次 Ping 还没回。Local 模式永远 None。
@@ -332,6 +335,7 @@ impl Game {
         let server = Rc::new(RefCell::new(Server::new(seed)));
         let eid = {
             let mut s = server.borrow_mut();
+            s.set_host_render_distance(settings.render_distance);
             let id = s.add_player(display_name.to_string());
             let _ = s.drain_outbox();
             id
@@ -349,6 +353,7 @@ impl Game {
         game.entity_id = eid;
         // Local-Only：自己即 Host，立即填 host_entity_id 让 UI 不显示"未知主机"瞬态。
         game.host_entity_id = eid;
+        game.host_render_distance = game.settings.render_distance;
         game
     }
 
@@ -364,6 +369,7 @@ impl Game {
         let server = Rc::new(RefCell::new(Server::new(seed)));
         let eid = {
             let mut s = server.borrow_mut();
+            s.set_host_render_distance(settings.render_distance);
             let id = s.add_player(display_name.to_string());
             let _ = s.drain_outbox();
             id
@@ -382,6 +388,7 @@ impl Game {
         game.entity_id = eid;
         // Host：自己即 Host，host_entity_id 直接填。
         game.host_entity_id = eid;
+        game.host_render_distance = game.settings.render_distance;
         Ok(game)
     }
 
@@ -398,15 +405,23 @@ impl Game {
         // server_inbox 在 Remote 模式不参与驱动；为保持 Game 字段不可空，造一对空 mpsc
         let (_net_local, dummy_inbox) = NetEndpoint::new_local_pair();
         let net = NetEndpoint::new_remote(signaling_url, room_id, display_name)?;
-        Ok(Self::assemble(
+        let mut game = Self::assemble(
             GameMode::Remote,
             server,
             dummy_inbox,
             net,
             settings,
             display_name.to_string(),
             room_id.to_string(),
-        ))
+        );
+        let spawn_center = crate::chunk_loader::chunk_pos_of(voxweb_server::DEFAULT_SPAWN);
+        let bootstrap_radius = game
+            .chunk_loader
+            .render_distance
+            .min(voxweb_server::INITIAL_SNAPSHOT_RADIUS);
+        game.chunk_loader
+            .mark_requested_square(spawn_center, bootstrap_radius);
+        Ok(game)
     }
 
     fn assemble(
@@ -445,6 +460,7 @@ impl Game {
             entity_id: 0, // 由 add_player（Local/Host）或 Welcome（Remote）填
             display_name,
             host_entity_id: 0, // Local/Host 模式在 new_* 里立即填；Remote 等 Welcome 回填
+            host_render_distance: 0,
             chat: ChatHistory::default(),
             rtt_ms: None,
             last_ping_sent_ms: 0.0,
@@ -474,11 +490,28 @@ impl Game {
         self.interp
             .set_delay_ms(self.settings.interp_delay_ms as f64);
         self.chunk_loader
-            .set_render_distance(self.settings.render_distance);
-        self.server
-            .borrow_mut()
-            .world
-            .set_chunk_cache_capacity(self.settings.chunk_cache_capacity);
+            .set_render_distance(self.effective_render_distance());
+        {
+            let mut server = self.server.borrow_mut();
+            server
+                .world
+                .set_chunk_cache_capacity(self.settings.chunk_cache_capacity);
+            if matches!(self.mode, GameMode::Local | GameMode::Host) {
+                server.set_host_render_distance(self.settings.render_distance);
+                self.host_render_distance = self.settings.render_distance;
+            }
+        }
+    }
+
+    /// 当前实际使用的区块视距。
+    ///
+    /// Remote 端不能超过 Host 视距；Local/Host 端直接使用自己的设置。
+    pub fn effective_render_distance(&self) -> u32 {
+        if self.mode == GameMode::Remote && self.host_render_distance > 0 {
+            self.settings.render_distance.min(self.host_render_distance)
+        } else {
+            self.settings.render_distance
+        }
     }
 }
 

crates/client/src/chunk_assembler.rs

@@ -1,6 +1,6 @@
 //! ChunkSnapshot 分片组装器。
 //!
-//! Host 用 `send_initial_snapshot` 把每个 chunk 的 bincode 编码结果切片发送；
+//! Host 用 bootstrap 快照或 `ChunkRequest` 响应把每个 chunk 的 bincode 编码结果切片发送；
 //! Remote 端接收时通过本模块按 ChunkPos 汇集，齐了返回 concatenated bytes。
 //!
 //! Phase 5：不关心具体编码格式；解码（Vec<BlockID> → Chunk）在上层 `apply_server_message` 做。

crates/client/src/chunk_loader.rs

@@ -18,6 +18,7 @@ pub struct ChunkLoader {
     pub render_distance: i32,
     pub unload_buffer: i32,
     pub loaded: HashSet<ChunkPos>,
+    requested: HashSet<ChunkPos>,
     last_center: Option<ChunkPos>,
 }
 
@@ -27,6 +28,7 @@ impl ChunkLoader {
             render_distance: render_distance as i32,
             unload_buffer: 3,
             loaded: HashSet::new(),
+            requested: HashSet::new(),
             last_center: None,
         }
     }
@@ -102,6 +104,91 @@ impl ChunkLoader {
 
         true
     }
+
+    /// Remote 模式的区块滚动加载。
+    ///
+    /// Remote 没有权威地形生成权，只维护本地缓存集合：缺失 chunk 通过
+    /// `ClientMessage::ChunkRequest` 向 Host 请求；Host 回传 `ChunkSnapshot` 后，
+    /// 调用 [`ChunkLoader::mark_loaded`] 把它从 in-flight 集合移到 loaded 集合。
+    pub fn update_remote(
+        &mut self,
+        camera_pos: Vec3,
+        server: &mut Server,
+        mesh_jobs: &mut MeshJobQueue,
+        renderer: &mut Renderer,
+    ) -> Vec<ChunkPos> {
+        let center = chunk_pos_of(camera_pos);
+        let center_changed = Some(center) != self.last_center;
+        if center_changed {
+            self.last_center = Some(center);
+        }
+
+        let mut requests = Vec::new();
+        if center_changed {
+            let r = self.render_distance;
+            let desired: HashSet<ChunkPos> = (-r..=r)
+                .flat_map(|dx| (-r..=r).map(move |dz| ChunkPos::new(center.x + dx, center.z + dz)))
+                .collect();
+
+            for pos in desired.difference(&self.loaded).copied() {
+                if self.requested.insert(pos) {
+                    requests.push(pos);
+                }
+            }
+        }
+
+        // Remote 也要卸载远离视距的本地 world/mesh，否则长途移动会无限增长。
+        let unload_r = self.render_distance + self.unload_buffer;
+        let to_unload: Vec<ChunkPos> = self
+            .loaded
+            .iter()
+            .copied()
+            .filter(|p| chebyshev_distance(*p, center) > unload_r)
+            .collect();
+        for pos in to_unload {
+            server.world.unload_chunk(pos);
+            mesh_jobs.cancel(pos);
+            renderer.drop_chunk_mesh(pos);
+            self.loaded.remove(&pos);
+        }
+
+        // 已经飞出缓冲范围但尚未返回的请求直接忘掉；若快照稍后到达，
+        // 下一次 update_remote 会按当前位置把它清理出缓存。
+        let stale_requests: Vec<ChunkPos> = self
+            .requested
+            .iter()
+            .copied()
+            .filter(|p| chebyshev_distance(*p, center) > unload_r)
+            .collect();
+        for pos in stale_requests {
+            self.requested.remove(&pos);
+        }
+
+        requests
+    }
+
+    /// 标记一个 Remote chunk 已收到完整快照。
+    pub fn mark_loaded(&mut self, pos: ChunkPos) {
+        self.loaded.insert(pos);
+        self.requested.remove(&pos);
+    }
+
+    /// 标记一个正方形范围的 chunk 已经有快照在路上。
+    ///
+    /// Host 当前仍会在玩家加入时主动推送出生点附近的 bootstrap 快照。
+    /// Remote 端把这批 chunk 记为 in-flight，后续按视距请求时只补缺口，
+    /// 避免初始阶段重复传同一批地图数据。
+    pub fn mark_requested_square(&mut self, center: ChunkPos, radius: i32) {
+        let r = radius.max(0);
+        for dx in -r..=r {
+            for dz in -r..=r {
+                let pos = ChunkPos::new(center.x + dx, center.z + dz);
+                if !self.loaded.contains(&pos) {
+                    self.requested.insert(pos);
+                }
+            }
+        }
+    }
 }
 
 /// 世界坐标 → 所在 chunk 的 ChunkPos。

crates/client/src/lib.rs

@@ -39,7 +39,7 @@ use crate::app::{
     AppState, BASE_SENSITIVITY_RAD_PER_PIXEL, Game, GameMode, PreloadState, RemotePlayerState,
 };
 use crate::camera::CameraMode;
-use crate::chunk_loader::affected_chunks;
+use crate::chunk_loader::{affected_chunks, chunk_pos_of};
 use crate::input::InputState;
 use crate::mesh_jobs::{MeshPriority, MeshRunStats};
 use crate::prediction::{
@@ -1355,6 +1355,23 @@ fn render_connecting_frame(app: &Rc<RefCell<App>>, cw: u32, ch: u32) -> Result<(
                     renderer,
                 );
                 drop(server_mut);
+            } else if game.entity_id != 0 {
+                let mut server_mut = game.server.borrow_mut();
+                let requests = game.chunk_loader.update_remote(
+                    voxweb_server::DEFAULT_SPAWN,
+                    &mut server_mut,
+                    &mut game.mesh_jobs,
+                    renderer,
+                );
+                drop(server_mut);
+                if !requests.is_empty() {
+                    log::debug!("[remote] request {} spawn preload chunks", requests.len());
+                    game.net.send_client_message(ClientMessage::ChunkRequest {
+                        center: chunk_pos_of(voxweb_server::DEFAULT_SPAWN),
+                        render_distance: game.chunk_loader.render_distance.max(0) as u32,
+                        chunks: requests,
+                    });
+                }
             }
 
             // 运行网格化（预载期间用 16ms 预算，比正常 4ms 更大）
@@ -1365,6 +1382,7 @@ fn render_connecting_frame(app: &Rc<RefCell<App>>, cw: u32, ch: u32) -> Result<(
             // 统计已接收和已网格化的区块数
             let spawn_center = crate::chunk_loader::chunk_pos_of(voxweb_server::DEFAULT_SPAWN);
             let r = game.chunk_loader.render_distance;
+            preload.total = ((2 * r + 1) * (2 * r + 1)) as usize;
             let mut received = 0usize;
             let mut meshed = 0usize;
             for dx in -r..=r {
@@ -1744,7 +1762,7 @@ fn apply_room_event(app: &Rc<RefCell<App>>, ev: RoomEvent) {
             // 网络连接完成，启动区块预载（不再直接进 InGame）
             if a.state == AppState::Connecting {
                 if let Some(ref game) = a.game {
-                    let rd = game.settings.render_distance as i32;
+                    let rd = game.chunk_loader.render_distance;
                     let total = ((2 * rd + 1) * (2 * rd + 1)) as usize;
                     a.preload_state = Some(PreloadState {
                         total,
@@ -2032,8 +2050,9 @@ fn render_game_frame(
         )
     };
 
-    // —— 5. ChunkLoader 滚动（仅 Local / Host；Remote 由 ChunkSnapshot / BlockUpdate 驱动） ——
-    if mode != GameMode::Remote {
+    // —— 5. ChunkLoader 滚动 ——
+    // Local/Host 直接生成；Remote 只请求缺失 chunk，由 Host 回 ChunkSnapshot。
+    {
         let mut a = app.borrow_mut();
         let App {
             ref mut renderer,
@@ -2044,8 +2063,28 @@ fn render_game_frame(
             return Ok(());
         };
         let mut server_mut = game.server.borrow_mut();
-        game.chunk_loader
-            .update(camera_pos, &mut server_mut, &mut game.mesh_jobs, renderer);
+        if mode == GameMode::Remote {
+            if game.entity_id != 0 {
+                let requests = game.chunk_loader.update_remote(
+                    camera_pos,
+                    &mut server_mut,
+                    &mut game.mesh_jobs,
+                    renderer,
+                );
+                drop(server_mut);
+                if !requests.is_empty() {
+                    log::debug!("[remote] request {} chunks near camera", requests.len());
+                    game.net.send_client_message(ClientMessage::ChunkRequest {
+                        center: chunk_pos_of(camera_pos),
+                        render_distance: game.chunk_loader.render_distance.max(0) as u32,
+                        chunks: requests,
+                    });
+                }
+            }
+        } else {
+            game.chunk_loader
+                .update(camera_pos, &mut server_mut, &mut game.mesh_jobs, renderer);
+        }
     }
 
     // —— 6. mesh_jobs run_until_budget ——
@@ -2659,19 +2698,37 @@ fn ingest_server_clock_sample(game: &mut Game, estimated_offset_ms: f64, alpha:
     game.server_clock_offset_ms = game.server_clock_offset_ms * (1.0 - a) + estimated_offset_ms * a;
 }
 
+fn apply_host_render_distance(game: &mut Game, host_render_distance: u32) {
+    let capped = host_render_distance.max(1);
+    let before = game.chunk_loader.render_distance;
+    game.host_render_distance = capped;
+    game.apply_settings();
+    let after = game.chunk_loader.render_distance;
+    if game.mode == GameMode::Remote && before != after {
+        log::info!(
+            "[remote] effective render distance capped by host: requested={} host={} effective={}",
+            game.settings.render_distance,
+            capped,
+            after
+        );
+    }
+}
+
 fn apply_server_message(game: &mut Game, msg: ServerMessage) {
     match msg {
         ServerMessage::Welcome {
             entity_id,
             world_seed,
             host_entity_id,
+            host_render_distance,
             players,
             ..
         } => {
             game.entity_id = entity_id;
             game.host_entity_id = host_entity_id;
+            apply_host_render_distance(game, host_render_distance);
             log::info!(
-                "Welcome v2: entity_id={entity_id}, seed={world_seed}, host={host_entity_id}, roster_size={}",
+                "Welcome v3: entity_id={entity_id}, seed={world_seed}, host={host_entity_id}, host_rd={host_render_distance}, roster_size={}",
                 players.len()
             );
             // 写入 roster：除自己以外的玩家进入 remote_players
@@ -2693,6 +2750,9 @@ fn apply_server_message(game: &mut Game, msg: ServerMessage) {
                 game.server.borrow_mut().world.chunks.clear();
             }
         }
+        ServerMessage::HostSettings { render_distance } => {
+            apply_host_render_distance(game, render_distance);
+        }
         ServerMessage::ChunkSnapshot {
             pos,
             frag_index,
@@ -2707,6 +2767,7 @@ fn apply_server_message(game: &mut Game, msg: ServerMessage) {
                     Ok(blocks) => {
                         let chunk = voxweb_core::chunk::Chunk { blocks };
                         game.server.borrow_mut().world.chunks.insert(pos, chunk);
+                        game.chunk_loader.mark_loaded(pos);
                         // 自己 + 相邻 8 个 chunk 都重 mesh
                         for dz in -1..=1i32 {
                             for dx in -1..=1i32 {