Struct GDLevel 

pub struct GDLevel {
    pub identity: GDLevelIdentity,
    pub content: GDLevelContents,
    pub ratings: GDLevelRatings,
    pub coins: GDLevelCoins,
    pub player_stats: GDLevelPlayerStats,
    pub flags: GDLevelFlags,
    pub editor_state: GDLevelEditorState,
    pub meta: GDLevelMeta,
    pub integrity: GDLevelIntegrity,
    pub unknowns: GDLevelUnknowns,
}

The descriptor struct for GD levels which contains all known properties.

Reference: https://wyliemaster.github.io/gddocs/#/resources/client/level

Fields

identity: GDLevelIdentity

Identity info: ID, name, descriptior, creator, version, level type, password

content: GDLevelContents

The level’s data: object data, song list, used song ID, length, is platformer/2-player

ratings: GDLevelRatings

Rating info: downloads, likes, stars, requested stars, epic rate, difficulty, type of demon, is auto

coins: GDLevelCoins

Coin info: required coins, obtainment status of coins

player_stats: GDLevelPlayerStats

Player-obtained stats: attempts, jump, percentage, best attempt time, completions, leaderboard standing, verification time, level progresses

flags: GDLevelFlags

Boolean flags: is editable, is verified, is uploaded, is unlisted, etc.

editor_state: GDLevelEditorState

State of level in editor: camera position and zoom, build tab pages, last selected layer

meta: GDLevelMeta

Internal data: kCEK, folder, seconds spent editing, level size, batch node info, capacity string

integrity: GDLevelIntegrity

Integrity/verification info: level seed, was anticheat triggered, replay data, vFDCHk

unknowns: GDLevelUnknowns

Unaccounted for/unknown keys: k91, k92, k101, k106 and all other keys that didn’t fit in any other fields in this struct.

Implementations

impl GDLevel

pub fn from_gmd<T: Into<PathBuf>>(path: T) -> Result<Self, GDError>

Parses a .gmd file to a Self object

Examples found in repository

examples/minimal.rs (line 8)

fn main() -> Result<(), GDError> {
    // Load level from .gmd file
    let mut level = GDLevel::from_gmd("test_gmds/level.gmd")?;

    // Get level data, which is None only if it hasn't been initialized.
    if let Some(data) = level.get_decrypted_data_ref() {
        // Add group 42 to all objects
        for obj in data.objects.iter_mut() {
            obj.config.add_group(Group::Regular(42));
        }
    }

    // Export level
    level.export_to_gmd("test_gmds/generated_group_42.gmd")?;
    Ok(())
}

examples/seed_crack.rs (line 14)

fn main() {
    let level = GDLevel::from_gmd("test_gmds/Chompstep.gmd").unwrap();
    let mut objects = level.get_decrypted_data().unwrap().objects;

    // filter out all objects that are not advanced random triggers
    objects.retain(|o| o.id == TRIGGER_ADVANCED_RANDOM && o.config.pos.0 > 0.0);
    objects.sort_by(|a, b| a.config.pos.0.total_cmp(&b.config.pos.0));

    // the group we want spawned for each trigger
    // -1: any group is fine
    let expected = vec![
        2, -1, 2, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, 2, 2, 2, 2, 2,
        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    ];
    let mut seed = 0;

    // then try all of the seeds
    // cap it out at 25 seeds because searching all of them is impractically slow on a CPU
    while !crack_seed(seed, &expected[..25], &objects) {
        seed += 1;
        if seed % 1000000 == 0 {
            println!("checked seeds until {seed}");
        }
    }

    // the seed you get is guaranteed to get you to 79% on Chompstep
    println!("got seed: {seed}");
}

pub fn export_to_gmd<T: Into<PathBuf>>(&self, path: T) -> Result<(), GDError>

Exports the level to a .gmd file

Examples found in repository

examples/minimal.rs (line 19)

fn main() -> Result<(), GDError> {
    // Load level from .gmd file
    let mut level = GDLevel::from_gmd("test_gmds/level.gmd")?;

    // Get level data, which is None only if it hasn't been initialized.
    if let Some(data) = level.get_decrypted_data_ref() {
        // Add group 42 to all objects
        for obj in data.objects.iter_mut() {
            obj.config.add_group(Group::Regular(42));
        }
    }

    // Export level
    level.export_to_gmd("test_gmds/generated_group_42.gmd")?;
    Ok(())
}

pub fn decrypt_level_data(&mut self) -> Result<(), GDError>

Returns the Level data as unencrypted. Level data is left unencrypted when parsing the Level as it is slow.

pub fn get_decrypted_data(&self) -> Option<GDLevelData>

Returns the decrypted level data as a GDLevelContents object if there is data.

Examples found in repository

examples/seed_crack.rs (line 15)

fn main() {
    let level = GDLevel::from_gmd("test_gmds/Chompstep.gmd").unwrap();
    let mut objects = level.get_decrypted_data().unwrap().objects;

    // filter out all objects that are not advanced random triggers
    objects.retain(|o| o.id == TRIGGER_ADVANCED_RANDOM && o.config.pos.0 > 0.0);
    objects.sort_by(|a, b| a.config.pos.0.total_cmp(&b.config.pos.0));

    // the group we want spawned for each trigger
    // -1: any group is fine
    let expected = vec![
        2, -1, 2, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, 2, 2, 2, 2, 2,
        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    ];
    let mut seed = 0;

    // then try all of the seeds
    // cap it out at 25 seeds because searching all of them is impractically slow on a CPU
    while !crack_seed(seed, &expected[..25], &objects) {
        seed += 1;
        if seed % 1000000 == 0 {
            println!("checked seeds until {seed}");
        }
    }

    // the seed you get is guaranteed to get you to 79% on Chompstep
    println!("got seed: {seed}");
}

pub fn get_decrypted_data_ref(&mut self) -> Option<&mut GDLevelData>

Returns a mutable reference to the decrypted level data as a GDLevelContents object if there is data. This method calls Self::decrypt_level_data before attempt to return the decrypted level data.

Examples found in repository

examples/minimal.rs (line 11)

fn main() -> Result<(), GDError> {
    // Load level from .gmd file
    let mut level = GDLevel::from_gmd("test_gmds/level.gmd")?;

    // Get level data, which is None only if it hasn't been initialized.
    if let Some(data) = level.get_decrypted_data_ref() {
        // Add group 42 to all objects
        for obj in data.objects.iter_mut() {
            obj.config.add_group(Group::Regular(42));
        }
    }

    // Export level
    level.export_to_gmd("test_gmds/generated_group_42.gmd")?;
    Ok(())
}

pub fn add_object(&mut self, object: GDObject)

Adds a GDObject to self.objects only if self.content.data is already decrypted, otherwise nothing happens. To decrypt the level data, see Self::decrypt_level_data or Self::get_decrypted_data_ref

pub fn add_objects<I: IntoIterator<Item = GDObject>>(&mut self, objects: I)

Adds an iterator of GDObjects to self.objects

pub fn get_objects_ref(&self) -> Option<&Vec<GDObject>>

Returns a reference to self.content.data.objects if this Level has level data and if the data is decrypted.

pub fn get_objects_mut(&mut self) -> Option<&mut Vec<GDObject>>

Returns a mutable reference to self.content.data.objects if this Level has level data and if the data is decrypted.

pub fn get_objects_clone(&self) -> Option<Vec<GDObject>>

Returns a copy of self.content.data.objects if this Level has level data and if the data is decrypted.

Trait Implementations

impl Clone for GDLevel

fn clone(&self) -> GDLevel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GDLevel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GDLevel

fn default() -> Self

Returns the “default value” for a type.

impl Display for GDLevel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.