libgm 0.7.1

A tool for unpacking and modding 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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

// SPDX-License-Identifier: GPL-3.0-only
mod chapter1_old;
mod chapter3;
mod deltarune;
mod demo_lts_ch1;
mod demo_lts_ch2;
mod demo_prelts;
mod undertale;

use crate::gml::Code;
use crate::gml::instruction::InstanceType;
use crate::gml::instruction::Instruction;
use crate::prelude::*;
use crate::wad::elem::variable::Variable;

impl GMData {
    /// Tries to enable or disable debug mode, based on the argument.
    ///
    /// This function currently supports:
    /// * Undertale
    /// * NXTALE
    /// * Deltarune Chapter 1 (aka. `SURVEY_PROGRAM`)
    /// * Deltarune Chapter 1&2 Demo (Old)
    /// * Deltarune Chapter 1&2 LTS Demo (New)
    /// * Deltarune Chapters 1-4 (paid game)
    pub fn toggle_debug(&mut self, enable: bool) -> Result<()> {
        toggle_debug(self, enable).ctx(|| format!("toggling debug mode to {enable}"))
    }

    /// Enables debug mode.
    ///
    /// For more information, see [`Self::toggle_debug`].
    pub fn enable_debug(&mut self) -> Result<()> {
        toggle_debug(self, true).ctx("enabling debug mode")
    }

    /// Disables debug mode.
    ///
    /// For more information, see [`Self::toggle_debug`].
    pub fn disable_debug(&mut self) -> Result<()> {
        toggle_debug(self, false).ctx("disabling debug mode")
    }
}

fn toggle_debug(data: &mut GMData, enable: bool) -> Result<()> {
    let gen8 = &data.general_info;
    let display_name: &str = data.strings.by_ref(gen8.display_name)?;
    let internal_name: &str = data.strings.by_ref(gen8.game_name)?;

    if internal_name.contains("UNDERTALE") || internal_name == "NXTALE" {
        return undertale::toggle(data, enable);
    }

    match display_name {
        "SURVEY_PROGRAM" => return chapter1_old::toggle(data, enable),
        "DELTARUNE Chapter 1&2" => return demo_prelts::toggle(data, enable),
        "DELTARUNE Chapter 3" => return chapter3::toggle(data, enable),
        "DELTARUNE Chapter 4" => return deltarune::toggle(data, enable),
        _ => {}
    }

    if display_name == "DELTARUNE Chapter 1" {
        return if data
            .game_objects
            .by_name("obj_event_manager", &data.strings)
            .is_ok()
        {
            deltarune::toggle(data, enable)
        } else if gen8.version >= (2, 3) {
            demo_lts_ch1::toggle(data, enable)
        } else {
            chapter1_old::toggle(data, enable)
        };
    }

    if display_name == "DELTARUNE Chapter 2" {
        return if data
            .game_objects
            .by_name("obj_event_manager", &data.strings)
            .is_ok()
        {
            deltarune::toggle(data, enable)
        } else {
            demo_lts_ch2::toggle(data, enable)
        };
    }

    bail!("Could not detect Undertale or Deltarune from game {display_name:?}");
}

fn find_debug(
    data: &GMData,
    code_ref: GMRef<Code>,
    instance_type: InstanceType,
) -> Result<(usize, bool)> {
    let code = data.codes.by_ref(code_ref)?;

    for i in 0..code.instructions.len() - 1 {
        let potential_push: &Instruction = &code.instructions[i];
        let potential_pop: &Instruction = &code.instructions[i + 1];

        let Instruction::Pop { variable, .. } = &potential_pop else {
            continue;
        };
        if variable.instance_type != instance_type {
            continue;
        }
        let gm_variable: &Variable = data.variables.by_ref(variable.variable)?;
        let var_name = data.strings.by_ref(gm_variable.name)?;
        if var_name != "debug" {
            continue;
        }

        // Found a `pop` into `debug`.
        let Some(push_value) = potential_push.push_value() else {
            bail!("Expected Instruction before Pop to be a Push, found {potential_push:?}")
        };
        let Some(is_enabled) = push_value.as_bool() else {
            bail!(
                "Push Instruction value does not have a proper boolean representation: \
                 {push_value:?}"
            );
        };

        return Ok((i, is_enabled));
    }

    Err("Could not find any pop instruction for debug variable".into())
}

fn replace_debug(
    data: &mut GMData,
    code_ref: GMRef<Code>,
    enable: bool,
    instance_type: InstanceType,
) -> Result<()> {
    let (instruction_index, is_enabled) = find_debug(data, code_ref, instance_type)?;

    if enable == is_enabled {
        // Debug mode already in correct state
        return Ok(());
    }

    // Enable/disable debug mode.
    let code: &mut Code = data.codes.by_ref_mut(code_ref)?;
    let integer = i16::from(enable);
    code.instructions[instruction_index] = Instruction::PushImmediate { integer };
    Ok(())
}