Struct ChunkSender 

pub struct ChunkSender {
    pub pending_chunks: FxHashSet<ChunkPos>,
    sent_chunks: FxHashSet<ChunkPos>,
    pub unacknowledged_batches: u16,
    pub desired_chunks_per_tick: f32,
    pub batch_quota: f32,
    pub max_unacknowledged_batches: u16,
}

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.

unacknowledged_batches: u16

The number of batches that have been sent to the client but have not been acknowledged yet.

desired_chunks_per_tick: f32

The number of chunks that should be sent to the client per tick. This is dynamically adjusted based on client feedback.

batch_quota: f32

The number of chunks that can be sent to the client in the current batch.

max_unacknowledged_batches: u16

The maximum number of unacknowledged batches allowed. Starts at 1 and increases to MAX_UNACKNOWLEDGED_BATCHES after first ack.

Implementations

impl ChunkSender

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)

Encodes and sends a packet through the connection.

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.

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 collect_candidates( &mut self, world: &Arc<World>, player_chunk_pos: ChunkPos, ) -> Vec<PreparedChunk>

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

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

Handles the acknowledgement of a chunk batch from the client.

The client sends back its desired chunks per tick based on how fast it can process chunks. We clamp this value and use it to adjust our sending rate.

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() -> Self

Returns the “default value” for a type.