Skip to main content

rm2k/rpg/
treemap.rs

1//! The `LMT` root, the only root that is not a chunk stream.
2
3use crate::{
4    cursor::{ChunkIter, Ctx, Cursor},
5    engine::Engine,
6    field::{LcfStruct, List},
7    rpg::{MapInfo, Start},
8    {sink::Sink, wire},
9};
10use alloc::vec::Vec;
11
12#[derive(Clone, Debug, PartialEq)]
13pub struct TreeMap<'a> {
14    pub maps: List<MapInfo<'a>>,
15    pub tree_order: Vec<i32>,
16    pub active_node: i32,
17    pub start: Start,
18}
19
20impl TreeMap<'_> {
21    #[must_use]
22    pub fn defaults(engine: Engine) -> Self {
23        Self {
24            maps: List(Vec::new()),
25            tree_order: Vec::new(),
26            active_node: 0,
27            start: Start::defaults(engine),
28        }
29    }
30}
31
32impl<'a> TreeMap<'a> {
33    #[must_use]
34    pub fn read_inline(cur: &mut Cursor<'a>, ctx: &mut Ctx<'_>) -> Self {
35        const NAME: &str = "TreeMap";
36
37        let maps = List::read_inline(cur, ctx, NAME, 0);
38
39        let count = cur.varint_lenient(ctx, NAME, 0);
40        // Each entry is at least one byte, which bounds a hostile count.
41        let count = (count.max(0) as usize).min(cur.remaining_len());
42        let mut tree_order = Vec::with_capacity(count);
43        for _ in 0..count {
44            tree_order.push(cur.varint_lenient(ctx, NAME, 0));
45        }
46
47        let active_node = cur.varint_lenient(ctx, NAME, 0);
48
49        let mut chunks = ChunkIter::from_cursor(cur.clone());
50        let start = Start::read_stream(&mut chunks, ctx);
51        *cur = chunks.into_cursor();
52
53        Self {
54            maps,
55            tree_order,
56            active_node,
57            start,
58        }
59    }
60
61    /// Writes the tree without the file magic. [`file::save_tree_map`](crate::file::save_tree_map) adds that.
62    ///
63    /// # Errors
64    ///
65    /// Propagates the sink's error.
66    pub fn write_inline<S: Sink>(&self, sink: &mut S, engine: Engine) -> Result<(), S::Error> {
67        crate::field::LcfField::write(&self.maps, sink, engine)?;
68
69        wire::write_varint(sink, self.tree_order.len() as u32)?;
70        for &id in &self.tree_order {
71            wire::write_varint(sink, id as u32)?;
72        }
73
74        wire::write_varint(sink, self.active_node as u32)?;
75
76        self.start.write_body(sink, engine)?;
77        sink.write(&[0])
78    }
79}