Method flatten

minecommit/src/handler/entities_region.rs:148–238

(self, save: &impl OdbReader, storage: &mut impl OdbWriter)

    }

    fn flatten(self, save: &impl OdbReader, storage: &mut impl OdbWriter) -> Result<Vec<String>> {
        let mut processed = Vec::new();
        for pattern in FLATTEN_PATTERNS {
            for key in save.glob(pattern)? {
                log::info!("Process entities region file {key}");
                let data = save.get(&key)?;
                let filename = key.split('/').next_back().unwrap_or("");
                let (region_x, region_z) = parse_xz(filename)
                    .with_context(|| format!("failed to parse region coordinates from {key}"))?;
                let Some((timestamp_header, chunks)) =
                    read_region(Cursor::new(data), region_x, region_z)
                        .with_context(|| format!("failed to read region from {key}"))?
                else {
                    processed.push(key);
                    continue;
                };
                storage.put(&format!("{key}/timestamp-header"), &timestamp_header)?;

                // Parse and sort all chunk NBTs
                let mut result: Vec<(i32, i32, NbtCompound)> = chunks
                    .into_iter()
                    .map(|(chunk_x, chunk_z, raw_bytes)| {
                        let mut nbt = load_nbt(Cursor::new(&raw_bytes))
                            .context("failed to load chunk nbt")?
                            .as_compound();
                        promote_entity_fields(&mut nbt)?;
                        sort_entity_attributes_by_id(&mut nbt);
                        Ok((chunk_x, chunk_z, nbt))
                    })
                    .collect::<Result<Vec<_>>>()?;

                // Sort by (cz, cx) for deterministic ordering
                result
                    .sort_unstable_by(|(cx1, cz1, ..), (cx2, cz2, ..)| (cz1, cx1).cmp(&(cz2, cx2)));

                // Build and write entities.nbt with Chunks + Flatten compounds
                {
                    let mut chunks_compound = NbtCompound::new();
                    let mut all_motions = Vec::new();
                    let mut all_positions = Vec::new();
                    let mut all_rotations = Vec::new();
                    for (chunk_x, chunk_z, nbt) in &mut result {
                        let key_str = format!("c.{}.{}", chunk_x, chunk_z);
                        // Extract flattened arrays from chunk and aggregate into Flatten
                        if let Some(m) = nbt
                            .remove("Motions")
                            .and_then(|t| t.into_list())
                            .and_then(|l| l.into_doubles())
                        {
                            all_motions.extend(m);
                        }
                        if let Some(p) = nbt
                            .remove("Pos")
                            .and_then(|t| t.into_list())
                            .and_then(|l| l.into_doubles())
                        {
                            all_positions.extend(p);
                        }