Struct CarveRun 

pub struct CarveRun<'a, 'b, N, F>
where
    N: DimensionNoises,
    F: FnMut(BlockPos) -> u16,
{
    pub ctx: &'a mut CarvingContext<'b, N>,
    pub noises: &'a N,
    pub chunk: GenerationChunk<'a, CarversPhase>,
    pub chunk_min_x: i32,
    pub chunk_min_z: i32,
    pub biome_getter: &'a mut F,
    pub mask: &'a mut CarvingMask,
    pub ids: CarverBlockIds,
}

The references every carver method needs. Bundled so carve_ellipsoid, carve_block, create_tunnel, create_room, carve_cave, carve_canyon, and do_carve can all be &mut self methods instead of repeating the same 7–8 arguments.

Fields

ctx: &'a mut CarvingContext<'b, N>

Dimension-level context (aquifer, surface system, bounds, psl).

noises: &'a N

Noise generators for this dimension.

chunk: GenerationChunk<'a, CarversPhase>

Chunk being carved into.

chunk_min_x: i32

Chunk NW block X (cached; ctx.chunk_min_x mirrors this).

chunk_min_z: i32

Chunk NW block Z (cached; ctx.chunk_min_z mirrors this).

biome_getter: &'a mut F

Biome lookup (vanilla BiomeManager.getBiome-style, fuzzed).

mask: &'a mut CarvingMask

Carving mask for the chunk (lazily created on the proto chunk).

ids: CarverBlockIds

Block IDs cached once per carver session.

Implementations

impl<N, F> CarveRun<'_, '_, N, F>

where N: DimensionNoises, F: FnMut(BlockPos) -> u16,

pub fn carve_canyon( &mut self, config: &CanyonCarverConfiguration, source_pos: ChunkPos, random: &mut LegacyRandom, )

Runs a canyon carver pass rooted in source_pos. random must have been seeded by the caller via set_large_feature_seed(seed + carver_index, source.x, source.z) and the isStartChunk probability check must have already passed.

Mirrors vanilla’s CanyonWorldCarver.carve — one tunnel per chunk, no splits, no rooms.

fn do_carve_canyon( &mut self, params: &CarveParams<'_>, config: &CanyonCarverConfiguration, state: CanyonState, tunnel: CanyonTunnel, )

Vanilla CanyonWorldCarver.doCarve.

impl<N, F> CarveRun<'_, '_, N, F>

where N: DimensionNoises, F: FnMut(BlockPos) -> u16,

pub fn carve_cave( &mut self, config: &CaveCarverConfiguration, kind: CaveKind, source_pos: ChunkPos, random: &mut LegacyRandom, )

Runs one cave-carver pass rooted in source_pos. random must have been seeded by the caller via LegacyRandom::set_large_feature_seed(seed + carver_index, cx, cz) and the isStartChunk probability check must have already passed.

Mirrors vanilla’s CaveWorldCarver.carve / NetherWorldCarver.carve (which inherits the cave variant).

fn create_room<S: CarveSkipChecker>( &mut self, params: &CarveParams<'_>, x: f64, y: f64, z: f64, thickness: f32, y_scale: f64, skip_checker: S, )

Vanilla CaveWorldCarver.createRoom. Single ellipsoid at the tunnel origin, offset by +1 on X.

fn create_tunnel<S>( &mut self, params: &CarveParams<'_>, state: TunnelState, tunnel: TunnelParams, skip_checker: S, )

where S: CarveSkipChecker + Copy,

Vanilla CaveWorldCarver.createTunnel. Steps along a curve, carving an ellipsoid per step, with occasional mid-tunnel splits.

impl<N, F> CarveRun<'_, '_, N, F>

where N: DimensionNoises, F: FnMut(BlockPos) -> u16,

pub fn carve_ellipsoid<S: CarveSkipChecker>( &mut self, params: &CarveParams<'_>, x: f64, y: f64, z: f64, horizontal_radius: f64, vertical_radius: f64, skip_checker: S, ) -> bool

Carve every block inside the given ellipsoid that falls in this chunk. Mirrors vanilla’s WorldCarver.carveEllipsoid.

Returns true if at least one block was carved.

fn carve_block( &mut self, params: &CarveParams<'_>, world_x: i32, world_y: i32, world_z: i32, has_grass: &mut bool, ) -> bool

Per-block carve decision + placement. Mirrors vanilla’s WorldCarver.carveBlock (and the NetherWorldCarver override).

fn can_replace(params: &CarveParams<'_>, state: BlockStateId) -> bool

fn steep_material_condition(&self, world_x: i32, world_z: i32) -> bool

fn get_carve_state( &mut self, params: &CarveParams<'_>, x: i32, y: i32, z: i32, ) -> CarveState

Vanilla’s WorldCarver.getCarveState + the nether override dispatch.

impl<N, F> CarveRun<'_, '_, N, F>

where N: DimensionNoises, F: FnMut(BlockPos) -> u16,

fn run_all( &mut self, source_biomes: &[SourceChunk], seed_i64: i64, random: &mut LegacyRandom, )

Drive the 17×17 source-chunk carver loop. Each carver in each source biome is seeded via set_large_feature_seed, probability-checked, then dispatched to the appropriate carve_* method.