From 9146c06bec5363c0ca3f81036f10c0b4f0655b6d Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Sun, 12 Feb 2023 22:54:43 +0100 Subject: [PATCH] treewide: rename "old" data structures to "v0" "v0" doesn't refer to a specific version of Minecraft; it is just the oldest data format supported by MinedMap. --- src/world/chunk.rs | 72 +++++++++++++++++++++----------------------- src/world/de.rs | 26 ++++++++-------- src/world/section.rs | 28 ++++++++--------- 3 files changed, 62 insertions(+), 64 deletions(-) diff --git a/src/world/chunk.rs b/src/world/chunk.rs index e6b2aa1..de0726b 100644 --- a/src/world/chunk.rs +++ b/src/world/chunk.rs @@ -7,7 +7,7 @@ use anyhow::{bail, Context, Result}; use super::{ de, - section::{OldSection, PaletteSection, PaletteSectionBiomes, Section}, + section::{BiomesV18, Section, SectionV0, SectionV1_13}, }; use crate::types::*; @@ -17,7 +17,7 @@ use crate::types::*; pub enum Chunk<'a> { /// Minecraft v1.18+ chunk with biome data moved into sections V1_18 { - section_map: BTreeMap, PaletteSectionBiomes<'a>)>, + section_map: BTreeMap, BiomesV18<'a>)>, }, /// Minecraft v1.13+ chunk /// @@ -26,15 +26,15 @@ pub enum Chunk<'a> { /// section), and a palette mapping these indices to namespaced /// block IDs V1_13 { - section_map: BTreeMap>, - biomes: &'a de::BiomesOld, + section_map: BTreeMap>, + biomes: &'a de::BiomesV0, }, /// Original pre-1.13 chunk /// /// The original chunk format with fixed 8-bit numeric block IDs - Old { - section_map: BTreeMap>, - biomes: &'a de::BiomesOld, + V0 { + section_map: BTreeMap>, + biomes: &'a de::BiomesV0, }, /// Unpopulated chunk without any block data Empty, @@ -45,15 +45,15 @@ pub enum Chunk<'a> { enum SectionIterInner<'a> { /// Iterator over sections of [Chunk::V1_18] V1_18 { - iter: btree_map::Iter<'a, SectionY, (PaletteSection<'a>, PaletteSectionBiomes<'a>)>, + iter: btree_map::Iter<'a, SectionY, (SectionV1_13<'a>, BiomesV18<'a>)>, }, /// Iterator over sections of [Chunk::V1_13] V1_13 { - iter: btree_map::Iter<'a, SectionY, PaletteSection<'a>>, + iter: btree_map::Iter<'a, SectionY, SectionV1_13<'a>>, }, - /// Iterator over sections of [Chunk::Old] - Old { - iter: btree_map::Iter<'a, SectionY, OldSection<'a>>, + /// Iterator over sections of [Chunk::V0] + V0 { + iter: btree_map::Iter<'a, SectionY, SectionV0<'a>>, }, /// Empty iterator over an unpopulated chunk ([Chunk::Empty]) Empty, @@ -72,7 +72,7 @@ impl<'a> Chunk<'a> { match &data.chunk { de::ChunkVariants::V1_18 { sections } => Self::new_v1_18(data_version, sections), - de::ChunkVariants::Old { level } => Self::new_old(data_version, level), + de::ChunkVariants::V0 { level } => Self::new_v0(data_version, level), } } @@ -84,17 +84,16 @@ impl<'a> Chunk<'a> { section_map.insert( SectionY(section.y), ( - PaletteSection::new( + SectionV1_13::new( data_version, section.block_states.data.as_ref(), §ion.block_states.palette, ) .with_context(|| format!("Failed to load section at Y={}", section.y))?, - PaletteSectionBiomes::new( - section.biomes.data.as_ref(), - §ion.biomes.palette, - ) - .with_context(|| format!("Failed to load section biomes at Y={}", section.y))?, + BiomesV18::new(section.biomes.data.as_ref(), §ion.biomes.palette) + .with_context(|| { + format!("Failed to load section biomes at Y={}", section.y) + })?, ), ); } @@ -103,33 +102,32 @@ impl<'a> Chunk<'a> { } /// [Chunk::new] implementation for all pre-1.18 chunk variants - fn new_old(data_version: u32, level: &'a de::LevelOld) -> Result { + fn new_v0(data_version: u32, level: &'a de::LevelV0) -> Result { let mut section_map_v1_13 = BTreeMap::new(); - let mut section_map_old = BTreeMap::new(); + let mut section_map_v0 = BTreeMap::new(); for section in &level.sections { match §ion.section { - de::SectionOldVariants::V1_13 { + de::SectionV0Variants::V1_13 { block_states, palette, } => { section_map_v1_13.insert( SectionY(section.y.into()), - PaletteSection::new(data_version, Some(block_states), palette) - .with_context(|| { - format!("Failed to load section at Y={}", section.y) - })?, + SectionV1_13::new(data_version, Some(block_states), palette).with_context( + || format!("Failed to load section at Y={}", section.y), + )?, ); } - de::SectionOldVariants::Old { blocks, data } => { - section_map_old.insert( + de::SectionV0Variants::V0 { blocks, data } => { + section_map_v0.insert( SectionY(section.y.into()), - OldSection::new(blocks, data).with_context(|| { + SectionV0::new(blocks, data).with_context(|| { format!("Failed to load section at Y={}", section.y) })?, ); } - de::SectionOldVariants::Empty {} => {} + de::SectionV0Variants::Empty {} => {} } } @@ -137,14 +135,14 @@ impl<'a> Chunk<'a> { let biomes = level.biomes.as_ref().context("Invalid biome data"); Ok( - match (section_map_v1_13.is_empty(), section_map_old.is_empty()) { + match (section_map_v1_13.is_empty(), section_map_v0.is_empty()) { (true, true) => Chunk::Empty, (false, true) => Chunk::V1_13 { section_map: section_map_v1_13, biomes: biomes?, }, - (true, false) => Chunk::Old { - section_map: section_map_old, + (true, false) => Chunk::V0 { + section_map: section_map_v0, biomes: biomes?, }, (false, false) => { @@ -165,7 +163,7 @@ impl<'a> Chunk<'a> { Chunk::V1_13 { section_map, .. } => V1_13 { iter: section_map.iter(), }, - Chunk::Old { section_map, .. } => Old { + Chunk::V0 { section_map, .. } => V0 { iter: section_map.iter(), }, Chunk::Empty => Empty, @@ -202,7 +200,7 @@ impl<'a> SectionIter<'a> { SectionIterInner::V1_13 { iter } => { f(&mut iter.map(|(y, section)| -> (SectionY, &'a dyn Section) { (*y, section) })) } - SectionIterInner::Old { iter } => { + SectionIterInner::V0 { iter } => { f(&mut iter.map(|(y, section)| -> (SectionY, &'a dyn Section) { (*y, section) })) } SectionIterInner::Empty => f(&mut iter::empty()), @@ -221,7 +219,7 @@ impl<'a> Iterator for SectionIter<'a> { match &self.inner { SectionIterInner::V1_18 { iter } => iter.size_hint(), SectionIterInner::V1_13 { iter } => iter.size_hint(), - SectionIterInner::Old { iter } => iter.size_hint(), + SectionIterInner::V0 { iter } => iter.size_hint(), SectionIterInner::Empty => (0, Some(0)), } } @@ -242,7 +240,7 @@ impl<'a> ExactSizeIterator for SectionIter<'a> { match &self.inner { SectionIterInner::V1_18 { iter } => iter.len(), SectionIterInner::V1_13 { iter } => iter.len(), - SectionIterInner::Old { iter } => iter.len(), + SectionIterInner::V0 { iter } => iter.len(), SectionIterInner::Empty => 0, } } diff --git a/src/world/de.rs b/src/world/de.rs index ead4687..844bd29 100644 --- a/src/world/de.rs +++ b/src/world/de.rs @@ -34,37 +34,37 @@ pub struct SectionV1_18 { pub block_light: Option, } -/// Version-specific part of a pre-1.18 [Section](SectionOld) +/// Version-specific part of a pre-1.18 [Section](SectionV0) #[derive(Debug, Deserialize)] #[serde(untagged)] -pub enum SectionOldVariants { +pub enum SectionV0Variants { #[serde(rename_all = "PascalCase")] V1_13 { block_states: fastnbt::LongArray, palette: Vec, }, #[serde(rename_all = "PascalCase")] - Old { + V0 { blocks: fastnbt::ByteArray, data: fastnbt::ByteArray, }, Empty {}, } -/// Pre-1.18 section element found in the [Level](LevelOld) compound +/// Pre-1.18 section element found in the [Level](LevelV0) compound #[derive(Debug, Deserialize)] #[serde(rename_all = "PascalCase")] -pub struct SectionOld { +pub struct SectionV0 { pub y: i8, pub block_light: Option, #[serde(flatten)] - pub section: SectionOldVariants, + pub section: SectionV0Variants, } -/// Pre-1.18 biome fields found in the [Level](LevelOld) compound +/// Pre-1.18 biome fields found in the [Level](LevelV0) compound #[derive(Debug, Deserialize)] #[serde(untagged)] -pub enum BiomesOld { +pub enum BiomesV0 { IntArray(fastnbt::IntArray), ByteArray(fastnbt::ByteArray), } @@ -72,10 +72,10 @@ pub enum BiomesOld { /// `Level` compound element found in pre-1.18 [chunks](Chunk) #[derive(Debug, Deserialize)] #[serde(rename_all = "PascalCase")] -pub struct LevelOld { +pub struct LevelV0 { #[serde(default)] - pub sections: Vec, - pub biomes: Option, + pub sections: Vec, + pub biomes: Option, } /// Version-specific part of a [Chunk] compound @@ -86,8 +86,8 @@ pub enum ChunkVariants { sections: Vec, }, #[serde(rename_all = "PascalCase")] - Old { - level: LevelOld, + V0 { + level: LevelV0, }, } diff --git a/src/world/section.rs b/src/world/section.rs index 78201a1..dbcf6ff 100644 --- a/src/world/section.rs +++ b/src/world/section.rs @@ -21,7 +21,7 @@ fn palette_bits(len: usize, min: u8, max: u8) -> Option { Some(bits) } -/// Trait for common functions of [PaletteSection] and [OldSection] +/// Trait for common functions of [SectionV1_13] and [SectionV0] pub trait Section { fn get_block_id(&self, coords: BlockCoords) -> Result<&str>; } @@ -32,14 +32,14 @@ pub trait Section { /// the biomes laid out as an array of indices into a palette, similar to the /// v1.13+ block data. #[derive(Debug)] -pub struct PaletteSectionBiomes<'a> { +pub struct BiomesV18<'a> { _biomes: Option<&'a fastnbt::LongArray>, _palette: &'a Vec, _bits: u8, } -impl<'a> PaletteSectionBiomes<'a> { - /// Constructs a new [PaletteSectionBiomes] from deserialized data structures +impl<'a> BiomesV18<'a> { + /// Constructs a new [BiomesV18] from deserialized data structures pub fn new(biomes: Option<&'a fastnbt::LongArray>, palette: &'a Vec) -> Result { let bits = palette_bits(palette.len(), 1, 6).context("Unsupported block palette size")?; @@ -51,7 +51,7 @@ impl<'a> PaletteSectionBiomes<'a> { } } - Ok(PaletteSectionBiomes { + Ok(BiomesV18 { _biomes: biomes, _palette: palette, _bits: bits, @@ -61,15 +61,15 @@ impl<'a> PaletteSectionBiomes<'a> { /// Minecraft v1.13+ section block data #[derive(Debug)] -pub struct PaletteSection<'a> { +pub struct SectionV1_13<'a> { block_states: Option<&'a fastnbt::LongArray>, palette: &'a Vec, bits: u8, aligned_blocks: bool, } -impl<'a> PaletteSection<'a> { - /// Constructs a new [PaletteSection] from deserialized data structures +impl<'a> SectionV1_13<'a> { + /// Constructs a new [SectionV1_13] from deserialized data structures pub fn new( data_version: u32, block_states: Option<&'a fastnbt::LongArray>, @@ -131,7 +131,7 @@ impl<'a> PaletteSection<'a> { } } -impl<'a> Section for PaletteSection<'a> { +impl<'a> Section for SectionV1_13<'a> { fn get_block_id(&self, coords: BlockCoords) -> Result<&str> { let index = self.get_palette_index(coords); let entry = self @@ -144,13 +144,13 @@ impl<'a> Section for PaletteSection<'a> { /// Pre-1.13 section block data #[derive(Debug)] -pub struct OldSection<'a> { +pub struct SectionV0<'a> { blocks: &'a fastnbt::ByteArray, data: &'a fastnbt::ByteArray, } -impl<'a> OldSection<'a> { - /// Constructs a new [OldSection] from deserialized data structures +impl<'a> SectionV0<'a> { + /// Constructs a new [SectionV0] from deserialized data structures pub fn new(blocks: &'a fastnbt::ByteArray, data: &'a fastnbt::ByteArray) -> Result { use BLOCKS_PER_CHUNK as N; @@ -161,11 +161,11 @@ impl<'a> OldSection<'a> { bail!("Invalid section extra data"); } - Ok(OldSection { blocks, data }) + Ok(SectionV0 { blocks, data }) } } -impl<'a> Section for OldSection<'a> { +impl<'a> Section for SectionV0<'a> { fn get_block_id(&self, coords: BlockCoords) -> Result<&str> { let offset = coords.offset(); let block = self.blocks[offset] as u8;