Struct Decrypter 

pub struct Decrypter<'a> { /* private fields */ }

A struct responsible for decrypting and extracting files from encrypted game archives.

Implementations

impl<'a> Decrypter<'a>

pub fn new() -> Self

Creates a new Decrypter with empty buffer.

pub fn decrypt( &mut self, archive_data: &'a [u8], ) -> Result<Vec<ArchiveEntry>, ExtractError>

Returns Vec of decrypted ArchiveEntry entries.

Parameters

• archive_data: The content of the archive file.

Returns

• Vec<ArchiveEntry> if files were successfully decrypted.
• ExtractError otherwise.

Errors

• ExtractError::InvalidHeader for invalid header.
• ExtractError::InvalidEngine for invalid header engine type byte.

Example

use rpgmad_lib::Decrypter;
use std::{path::PathBuf, fs::{read, write, create_dir_all}};

let data = read("C:/Game/Game.rgss3a").unwrap();
let decrypted_entries = Decrypter::new().decrypt(&data).unwrap();

for entry in decrypted_entries {
    let path = String::from_utf8_lossy(&entry.path);
    let output_path = PathBuf::from("C:/Game").join(path.as_ref());

    if let Some(parent) = output_path.parent() {
        create_dir_all(parent).unwrap();
    }

    write(output_path, entry.data).unwrap();
}

pub fn encrypt( &mut self, archive_entries: &[ArchiveEntry], engine: Engine, ) -> Vec<u8>

Returns encrypted archive data as Vec<u8>.

Parameters

• entries: Archive entries to encrypt.
• engine: Target archive engine.

Returns

• Vec<u8> representing encrypted archive data.

Example

use rpgmad_lib::{Decrypter, Engine, ArchiveEntry};
use std::{fs::{read, write}, borrow::Cow};

let archive_entries = [ArchiveEntry {
    path: Cow::Borrowed(b"Graphics/Tilesets/Tileset1.png"),
    data: read("Graphics/Tilesets/Tileset1.png").unwrap()
}];
let archive_data = Decrypter::new().encrypt(&archive_entries, Engine::VXAce);
write("./Game.rgss3a", archive_data).unwrap();

Trait Implementations

impl Default for Decrypter<'_>

fn default() -> Self

Returns a new Decrypter with default parameters.

Equivalent to calling Decrypter::new.