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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

mod audio;
mod bool;
mod broadcast;
pub mod color;
mod graphic;
mod instance;
mod moment;
mod particle;
mod sequence;
mod sprite_frames;
mod string;
mod text;

pub use audio::Audio;
pub use bool::Bool;
pub use broadcast::BroadcastMessage;
pub use color::Color;
pub use graphic::Graphic;
pub use instance::Instance;
pub use moment::Moment;
pub use particle::Particle;
pub use sequence::Sequence;
pub use sprite_frames::SpriteFrames;
pub use string::String;
pub use text::Text;

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

#[derive(Debug, Clone, PartialEq)]
pub enum Keyframes {
    Audio(Data<Audio>),
    Instance(Data<Instance>),
    Graphic(Data<Graphic>),
    Sequence(Data<Sequence>),
    SpriteFrames(Data<SpriteFrames>),
    Bool(Data<Bool>),
    // Asset(Data<Asset>),
    String(Data<String>),
    // Int(Data<Int>),
    Color(color::KeyframesData),
    Real(color::KeyframesData),
    Text(Data<Text>),
    Particle(Data<Particle>),
    BroadcastMessage(Data<BroadcastMessage>),
}

#[derive(Debug, Clone, PartialEq)]
pub struct Data<T: GMElement> {
    pub keyframes: Vec<Keyframe<T>>,
}

impl<T: GMElement> GMElement for Data<T> {
    fn deserialize(reader: &mut DataReader) -> Result<Self> {
        reader.align(4)?;
        let keyframes: Vec<Keyframe<T>> = reader
            .read_simple_list()
            .with_context(|| format!("deserializing {} keyframes", typename::<T>()))?;
        Ok(Self { keyframes })
    }

    fn serialize(&self, builder: &mut DataBuilder) -> Result<()> {
        builder.align(4);
        builder
            .write_simple_list(&self.keyframes)
            .with_context(|| format!("serializing {} keyframes", typename::<T>()))?;
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct Keyframe<T: GMElement> {
    pub key: f32,
    pub length: f32,
    pub stretch: bool,
    pub disabled: bool,
    pub channels: Vec<Channel<T>>,
}
impl<T: GMElement> GMElement for Keyframe<T> {
    fn deserialize(reader: &mut DataReader) -> Result<Self> {
        let key = reader.read_f32()?;
        let length = reader.read_f32()?;
        let stretch = reader.read_bool32()?;
        let disabled = reader.read_bool32()?;
        let channels: Vec<Channel<T>> = reader.read_simple_list()?;
        Ok(Self { key, length, stretch, disabled, channels })
    }

    fn serialize(&self, builder: &mut DataBuilder) -> Result<()> {
        builder.write_f32(self.key);
        builder.write_f32(self.length);
        builder.write_bool32(self.stretch);
        builder.write_bool32(self.disabled);
        builder.write_simple_list(&self.channels)?;
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct Channel<T: GMElement> {
    pub id: i32,
    pub value: T,
}

impl<T: GMElement> GMElement for Channel<T> {
    fn deserialize(reader: &mut DataReader) -> Result<Self> {
        let id = reader.read_i32()?;
        let value = T::deserialize(reader)
            .with_context(|| format!("deserializing {} channel", typename::<T>()))?;
        Ok(Self { id, value })
    }

    fn serialize(&self, builder: &mut DataBuilder) -> Result<()> {
        builder.write_i32(self.id);
        self.value
            .serialize(builder)
            .with_context(|| format!("serializing {} channel", typename::<T>()))?;
        Ok(())
    }
}