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
124
125
126
127
128
129
130
131
132
133

use crate::gml::GMCode;
use crate::prelude::*;
use crate::wad::elements::validate_identifier;

impl GMNamedElement for GMCode {
    fn name(&self) -> &String {
        &self.name
    }

    fn name_mut(&mut self) -> &mut String {
        &mut self.name
    }

    fn validate_name(&self) -> Result<()> {
        let name: &str = &self.name;
        validate(name).with_context(|| format!("strictly validating code entry name {name:?}"))
    }
}

fn validate(mut name: &str) -> Result<()> {
    name = name
        .strip_prefix("gml_")
        .ok_or("Code entry name does not start with \"gml_\"")?;

    let split = name
        .split_once('_')
        .ok_or("Code entry name does not have a kind`:")?;
    let kind: &str = split.0;
    name = split.1;

    match kind {
        "Script" => {}
        "GlobalScript" => {
            // Some weird autogenerated(?) init scripts.
            if name.chars().all(|c| c.is_ascii_digit()) {
                return Ok(());
            }
        }
        "Room" => {
            let event_kind: &str;
            (name, event_kind) = name
                .rsplit_once('_')
                .ok_or("Missing event kind in Room code entry name")?;
            validate_room_event_kind(event_kind)?;
        }
        "RoomCC" => {
            let e = "RoomCC code entry name has too few parts (not enough underscores to be valid)";
            let (instance_id, event_kind) = last_three_parts(&mut name).ok_or(e)?;
            validate_room_event_kind(event_kind)?;
            instance_id
                .parse::<u16>()
                .context_src("parsing Instance ID in RoomCC code entry")?;
        }
        "Object" => {
            // Collision event has an object name as its subtype.
            // This is impossible to demangle, so just do a simple identifier validation and
            // return.
            if name.contains("_Collision_") {
                return validate_identifier(name);
            }

            let e = "Object code entry name has too few parts (not enough underscores to be valid)";
            let (event_type, event_subtype) = last_three_parts(&mut name).ok_or(e)?;
            let event_subtype: u32 = event_subtype
                .parse::<u32>()
                .context_src("parsing Event subtype in Object code entry")?;
            validate_event(event_type, event_subtype)?;
        }
        _ => bail!("Invalid code entry kind {kind:?}"),
    }

    // Lastly, validate the actual core (script/object/room) name.
    validate_identifier(name)
}

fn last_three_parts<'a>(string: &mut &'a str) -> Option<(&'a str, &'a str)> {
    let mut iter = string.rsplitn(3, '_');
    // `rsplit*` methods yield in reverse order
    let part3: &str = iter.next()?;
    let part2: &str = iter.next()?;
    let part1: &str = iter.next()?;
    *string = part1;
    Some((part2, part3))
}

fn validate_room_event_kind(event_kind: &str) -> Result<()> {
    match event_kind {
        "Create" | "PreCreate" => Ok(()),
        _ => Err(err!("Invalid Room event kind {event_kind:?}")),
    }
}

fn validate_event(event_type: &str, subtype: u32) -> Result<()> {
    use crate::wad::elements::game_object::event::EventSubtype;
    use crate::wad::elements::game_object::event::subtype::Alarm;
    use crate::wad::elements::game_object::event::subtype::Draw;
    use crate::wad::elements::game_object::event::subtype::Gesture;
    use crate::wad::elements::game_object::event::subtype::Key;
    use crate::wad::elements::game_object::event::subtype::Mouse;
    use crate::wad::elements::game_object::event::subtype::Other;
    use crate::wad::elements::game_object::event::subtype::Step;

    let error: Option<Error> = match event_type {
        "Create" => assert_zero(subtype),
        "Destroy" => assert_zero(subtype),
        "Alarm" => Alarm::parse(subtype).err(),
        "Step" => Step::parse(subtype).err(),
        // "Collision" => {},  // handled separately
        "Keyboard" => Key::parse(subtype).err(),
        "Mouse" => Mouse::parse(subtype).err(),
        "Other" => Other::parse(subtype).err(),
        "Draw" => Draw::parse(subtype).err(),
        "KeyPress" => Key::parse(subtype).err(),
        "KeyRelease" => Key::parse(subtype).err(),
        "Trigger" => assert_zero(subtype),
        "CleanUp" => assert_zero(subtype),
        "Gesture" => Gesture::parse(subtype).err(),
        "PreCreate" => assert_zero(subtype),
        _ => bail!("Invalid event type {event_type:?}"),
    };

    error.map_or(Ok(()), Err)
}

fn assert_zero(subtype: u32) -> Option<Error> {
    if subtype == 0 {
        None
    } else {
        Some(err!(
            "Expected event subtype 0 for this event type, got {subtype}"
        ))
    }
}