Struct ChunkSender 

pub struct ChunkSender {
    pub pending_chunks: FxHashSet<ChunkPos>,
    sent_chunks: FxHashSet<ChunkPos>,
    pacing: ChunkBatchPacing,
}

This struct is responsible for sending chunks to the client.

Fields

pending_chunks: FxHashSet<ChunkPos>

A list of chunks that are waiting to be sent to the client.

sent_chunks: FxHashSet<ChunkPos>

Chunks whose initial chunk packet has been queued for this client.

pacing: ChunkBatchPacing

Implementations

impl ChunkSender

pub(crate) fn clear_world_chunks(&mut self)

Clears chunk membership from the previous world while preserving connection pacing.

pub fn mark_chunk_pending_to_send(&mut self, pos: ChunkPos)

Marks a chunk as pending to be sent to the client.

pub fn drop_chunk(&mut self, connection: &PlayerConnection, pos: ChunkPos)

Drops a chunk from the client’s view.

fn send_packet<P: ClientPacket>(connection: &PlayerConnection, packet: P)

pub fn prepare_batch( &mut self, world: &Arc<World>, player_chunk_pos: ChunkPos, chunk_send_epoch: &SyncMutex<u32>, ) -> Option<PreparedBatch>

Phase 1: Lock briefly to drain pending chunks and snapshot state.

Returns None if there is nothing to send this tick. The caller must complete or discard the returned batch before preparing another one for this sender; the server’s sending pass enforces this.

pub fn encode_batch( batch: &PreparedBatch, cache: &mut FxHashMap<ChunkPos, EncodedChunk>, compression: Option<CompressionInfo>, encoding_pool: &ThreadPool, ) -> Vec<EncodedChunk>

Phase 2: Encode chunks without holding any lock. Called between prepare and commit.

Uses the dedicated encoding pool to encode chunks in parallel. A per-tick local cache prevents multiple players sharing the same chunks from re-encoding them within the same sending tick.

Panics

Panics if a chunk packet fails to encode.

pub fn commit_batch( &mut self, batch: &PreparedBatch, encoded_chunks: Vec<EncodedChunk>, connection: &PlayerConnection, chunk_send_epoch: &SyncMutex<u32>, ) -> Vec<ChunkPos>

Phase 3: Lock briefly to verify generation counter and send the batch.

If the player teleported between prepare and commit (generation counter changed), the batch is discarded.

fn resolve_valid_chunks( prepared: &[PreparedChunk], encoded_chunks: Vec<EncodedChunk>, pending: &FxHashSet<ChunkPos>, ) -> Vec<EncodedChunk>

Keeps the encoded chunks that are still pending and still match their prepared source.

encoded_chunks is a subsequence of prepared in the same relative order: Self::encode_batch maps over prepared with an order-preserving parallel iterator and only drops entries. A single forward cursor over prepared therefore resolves every encoded chunk in one pass, instead of restarting the scan per chunk.

fn collect_candidates( &mut self, world: &Arc<World>, player_chunk_pos: ChunkPos, max_batch_size: usize, ) -> Vec<PreparedChunk>

fn chunk_distance_squared(pos: ChunkPos, player_chunk_pos: ChunkPos) -> u64

pub fn on_chunk_batch_received_by_client( &mut self, desired_chunks_per_tick: f32, ) -> bool

Queues accepted client rate feedback for the next prepare boundary.

pub fn is_chunk_sent(&self, pos: ChunkPos) -> bool

Returns whether the client has been queued the initial chunk packet.

pub fn sent_chunks_snapshot(&self) -> FxHashSet<ChunkPos>

Returns a snapshot of all sent chunks for this player.

Trait Implementations

impl Debug for ChunkSender

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ChunkSender

fn default() -> ChunkSender

Returns the “default value” for a type.