Struct ModuleFile

pub struct ModuleFile {
    pub header: ModuleHeader,
    pub files: Vec<ModuleFileEntry>,
    pub resource_indices: Vec<u32>,
    blocks: Vec<ModuleBlockEntry>,
    file_data_offset: u64,
    module_file: Option<BufReader<File>>,
    hd1_file: Option<BufReader<File>>,
    pub use_hd1: bool,
}

Module structure which contains the layout of the entire module file.

Fields

header: ModuleHeader

Information relating to how the other fields should be read.

files: Vec<ModuleFileEntry>

Metadata regarding compression and layout of files (tags).

resource_indices: Vec<u32>

Indices of resource files present in the module.

blocks: Vec<ModuleBlockEntry>

Uncompressed/compressed blocks making up a file.

file_data_offset: u64

Offset in BufReader where file data starts.

module_file: Option<BufReader<File>>

Reference to the module file buffer.

hd1_file: Option<BufReader<File>>

Reference to HD1 buffer if it exists.

use_hd1: bool

Whether to use the HD1 module or not.

Implementations

impl ModuleFile

pub fn new() -> Self

Instantiates a default ModuleFile object.

pub fn from_path<T: AsRef<Path>>(file_path: T) -> Result<Self>

Examples found in repository

examples/load_all_modules.rs (line 18)

fn load_modules(deploy_path: String) -> infinite_rs::Result<Vec<ModuleFile>> {
    let mut modules = Vec::new();
    for entry in walkdir::WalkDir::new(deploy_path)
        .into_iter()
        .filter_map(|e| e.ok())
    {
        if entry.file_type().is_file() {
            let file_path = entry.path().to_str().unwrap();
            if file_path.ends_with(".module") {
                let module = ModuleFile::from_path(file_path);
                match module {
                    Ok(_) => {
                        modules.push(module?);
                        println!("Read module: {}", file_path);
                    }
                    Err(err) => {
                        println!("Failed on file: {}", file_path);
                        return Err(err);
                    }
                };
            }
        }
    }
    Ok(modules)
}

examples/load_scripts.rs (line 24)

fn main() -> Result<()> {
    let mut module = ModuleFile::from_path(DEPLOY_PATH)?;
    for idx in 0..module.files.len() {
        if module.files[idx].tag_group == SCRIPT_GROUP {
            module.read_tag(idx as u32)?;
            let mut source = HsSourceFileTag::default();
            module.files[idx].read_metadata(&mut source)?;

            let size = module.files[idx].uncompressed_header_size + 0x2D8;
            let tag_id = module.files[idx].tag_id;
            let mut server_buf = vec![0; source.server.size as usize];
            let mut client_buf = vec![0; source.client.size as usize];

            if let Some(stream) = module.files[idx].data_stream.as_mut() {
                stream.seek(SeekFrom::Start(size as u64))?;
                stream.read_exact(&mut server_buf)?;
                stream.read_exact(&mut client_buf)?;
            }

            let server_file = File::create(format!("{SAVE_PATH}/{}_server.luac", tag_id))?;
            let mut bw = BufWriter::new(server_file);
            bw.write_all(&server_buf)?;

            let client_file = File::create(format!("{SAVE_PATH}/{}_client.luac", tag_id))?;
            let mut bw = BufWriter::new(client_file);
            bw.write_all(&client_buf)?;
        }
    }
    Ok(())
}

pub fn read<T: AsRef<Path>>(&mut self, file_path: T) -> Result<()>

Reads the module file from the given file path. This function reads the entire structure of the module file. It also calculates and stores important offsets within the file.

Arguments

• file_path - A reference to a type that implements Path that holds the path to the module file.

Returns

Returns Ok(()) if the read operation is successful, or an Error containing the I/O error if any reading operation fails.

fn open_hd1<T: AsRef<Path>>(&mut self, file_path: T) -> Result<()>

fn get_tag_path(&self, index: usize, depth: usize) -> Result<String>

pub fn read_tag(&mut self, index: u32) -> Result<Option<i32>>

Reads a specific tag from the module file.

This function reads a specific tag from the module file based on the provided index. It also utilizes the HD1 stream if the file entry has the flag set for it and the stream is loaded, and returns None if the tag offset is invalid.

Arguments

• index - The index of the file entry to read the tag from. This index corresponds to the position of the file entry in the files vector.

Returns

Returns Some(i32)) containing the tag_id of the file if the read operation is successful, or an Error, a None if the file was not read (if tag offset is specified as invalid) or the containing the I/O error if any reading operation fails.

Examples found in repository

examples/load_all_modules.rs (line 167)

fn main() -> infinite_rs::Result<()> {
    let mut pc_modules =
        load_modules(String::from("C:/XboxGames/Halo Infinite/Content/deploy/pc"))?;

    let mut any_modules = load_modules(String::from(
        "C:/XboxGames/Halo Infinite/Content/deploy/any",
    ))?;

    let mut modules = pc_modules.iter_mut().chain(any_modules.iter_mut());

    for module in &mut modules {
        for index in 0..module.files.len() {
            module.read_tag(index as u32)?;
            let tag = &mut module.files[index];
            if tag.tag_group == "mat " {
                let mut mat = MaterialTag::default();
                tag.read_metadata(&mut mat)?;
            }
            // explicitly drop buffer to free up memory
            // normally, can take 50+ GBs of RAM
            module.files[index].data_stream = None
        }
    }
    Ok(())
}

examples/load_scripts.rs (line 27)

fn main() -> Result<()> {
    let mut module = ModuleFile::from_path(DEPLOY_PATH)?;
    for idx in 0..module.files.len() {
        if module.files[idx].tag_group == SCRIPT_GROUP {
            module.read_tag(idx as u32)?;
            let mut source = HsSourceFileTag::default();
            module.files[idx].read_metadata(&mut source)?;

            let size = module.files[idx].uncompressed_header_size + 0x2D8;
            let tag_id = module.files[idx].tag_id;
            let mut server_buf = vec![0; source.server.size as usize];
            let mut client_buf = vec![0; source.client.size as usize];

            if let Some(stream) = module.files[idx].data_stream.as_mut() {
                stream.seek(SeekFrom::Start(size as u64))?;
                stream.read_exact(&mut server_buf)?;
                stream.read_exact(&mut client_buf)?;
            }

            let server_file = File::create(format!("{SAVE_PATH}/{}_server.luac", tag_id))?;
            let mut bw = BufWriter::new(server_file);
            bw.write_all(&server_buf)?;

            let client_file = File::create(format!("{SAVE_PATH}/{}_client.luac", tag_id))?;
            let mut bw = BufWriter::new(client_file);
            bw.write_all(&client_buf)?;
        }
    }
    Ok(())
}

pub fn read_tag_from_id(&mut self, global_id: i32) -> Result<Option<usize>>

Searches for the index of the tag given the global_id.

This function searches for the index of a tag in the files vector using the provided global_id. If the tag is found, it reads the tag using the read_tag function and stores it in the index.

Arguments

• global_id - The global tag ID of the file to find. This ID is used to identify the specific tag within the module file.

Returns

Returns the index of the file if successful, wrapped in Some(usize). If the tag is not found or couldn’t be read, it returns None. Any I/O error encountered during the operation is also returned if it occurs.

Trait Implementations

impl Debug for ModuleFile

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

Formats the value using the given formatter.

impl Default for ModuleFile

fn default() -> ModuleFile

Returns the “default value” for a type.