libgm 0.5.1

A tool for modding, unpacking and decompiling GameMaker games
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use crate::prelude::*;
use crate::util::fmt::typename;
use crate::wad::elements::GMElement;
use crate::wad::serialize::builder::DataBuilder;

impl DataBuilder<'_> {
    /// Write the element count as a 32-bit integer.
    /// Then build all elements sequentially, with nothing in between.
    pub fn write_simple_list<T: GMElement>(&mut self, elements: &Vec<T>) -> Result<()> {
        let count: usize = elements.len();
        let ctx = || {
            format!(
                "building simple list of {} with {} elements",
                typename::<T>(),
                count,
            )
        };

        self.write_usize(count).with_context(ctx)?;
        for element in elements {
            element.serialize(self).with_context(ctx)?;
        }
        Ok(())
    }

    pub fn write_simple_list_short<T: GMElement>(&mut self, elements: &Vec<T>) -> Result<()> {
        let count: usize = elements.len();
        let ctx = || {
            format!(
                "building short simple list of {} with {} elements",
                typename::<T>(),
                count,
            )
        };

        let count: u16 = count
            .try_into()
            .map_err(|_| "Cannot fit element count into 16 bits")
            .with_context(ctx)?;

        self.write_u16(count);
        for element in elements {
            element.serialize(self).with_context(ctx)?;
        }

        Ok(())
    }

    pub fn write_pointer_list<T: GMElement>(&mut self, elements: &[T]) -> Result<()> {
        let count: usize = elements.len();
        let ctx = || {
            format!(
                "building pointer list of {} with {} elements",
                typename::<T>(),
                count,
            )
        };

        self.write_usize(count).with_context(ctx)?;
        let pointer_list_pos: u32 = self.len();
        for _ in 0..count {
            self.write_u32(0xDEAD_C0DE);
        }

        for (i, element) in elements.iter().enumerate() {
            element.serialize_pre_padding(self).with_context(ctx)?;
            self.overwrite_pointer_with_cur_pos(pointer_list_pos, i)
                .with_context(ctx)?;
            element.serialize(self).with_context(ctx)?;
            element
                .serialize_post_padding(self, i == count - 1)
                .with_context(ctx)?;
        }
        Ok(())
    }
}