Struct Pack 

pub struct Pack { /* private fields */ }

Packs are a container-type file, used for “packing” all game assets into single files, to speed up disk reads.

Their format has passed through multiple iterations since empire, getting changes on almost all iterations, like timestamps, encryption, compression,…

Pack Structure

Bytes	Type	Data
20-384	PackHeader	Header of the Pack. Lenght depends on Pack version and flags enabled.
*	Pack Index	Index containing the list of Packs this Pack depends on.
*	File Index	Index containing the list of Files this Pack depends on
*	File Data	Data of the files contained in this Pack.
256	Appendix	Unknown data at the end of the Pack. Only seen in Arena’s encrypted Packs.

Pack Index

The Pack Index contains a list of Packs that will be force-loaded before this mod.

Bytes	Type	Data
*	Null-terminated StringU8	Pack file name.

File Index

The File Index contains the metadata of the Files this Pack contains, in the same order their data is, further in the Pack.

Bytes	Type	Data
4	u32	Size of the file’s data, in bytes.
8	u64	Timestamp of the file, if the header has the HAS_INDEX_WITH_TIMESTAMPS flag enabled. Only in PFH2 and PFH3.
4	u32	Truncated timestamp of the file, if the header has the HAS_INDEX_WITH_TIMESTAMPS flag enabled. Only since PFH4.
1	bool	If the file is compressed. Only since PFH5.
*	Null-terminated StringU8	File’s path within the Pack.

File Data

The raw data of the files contained by this Pack, in the same order as their indexes. Not much to explain here.

Implementations

impl Pack

pub fn disk_file_path(&self) -> &String

The path of the Pack on disk, if exists. If not, then this should be empty.

pub fn disk_file_offset(&self) -> &u64

The offset on the disk file the data of this Pack starts. Usually 0.

pub fn local_timestamp(&self) -> &u64

Timestamp from the moment this Pack was open. To check if the file was edited on disk while we had it open.

pub fn header(&self) -> &PackHeader

Header data of this Pack.

pub fn dependencies(&self) -> &Vec<(bool, String)>

List of Packs this Pack depends on. If the boolean is true, the packs are also required to be loaded before himself when starting the game.

In other places, we may refer to this as the Dependency List.

pub fn files(&self) -> &HashMap<String, RFile>

List of files this Pack contains.

pub fn paths(&self) -> &HashMap<String, Vec<String>>

List of file paths lowercased, with their casing counterparts. To quickly find files.

pub fn notes(&self) -> &PackNotes

Notes added to the Pack. Exclusive of this lib.

pub fn settings(&self) -> &PackSettings

Settings stored in the Pack itself, to be able to share them between installations.

impl Pack

pub fn disk_file_path_mut(&mut self) -> &mut String

The path of the Pack on disk, if exists. If not, then this should be empty.

pub fn disk_file_offset_mut(&mut self) -> &mut u64

The offset on the disk file the data of this Pack starts. Usually 0.

pub fn local_timestamp_mut(&mut self) -> &mut u64

Timestamp from the moment this Pack was open. To check if the file was edited on disk while we had it open.

pub fn header_mut(&mut self) -> &mut PackHeader

Header data of this Pack.

pub fn dependencies_mut(&mut self) -> &mut Vec<(bool, String)>

List of Packs this Pack depends on. If the boolean is true, the packs are also required to be loaded before himself when starting the game.

In other places, we may refer to this as the Dependency List.

pub fn files_mut(&mut self) -> &mut HashMap<String, RFile>

List of files this Pack contains.

pub fn paths_mut(&mut self) -> &mut HashMap<String, Vec<String>>

List of file paths lowercased, with their casing counterparts. To quickly find files.

pub fn notes_mut(&mut self) -> &mut PackNotes

Notes added to the Pack. Exclusive of this lib.

pub fn settings_mut(&mut self) -> &mut PackSettings

Settings stored in the Pack itself, to be able to share them between installations.

impl Pack

pub fn set_disk_file_path(&mut self, val: String) -> &mut Self

The path of the Pack on disk, if exists. If not, then this should be empty.

pub fn set_disk_file_offset(&mut self, val: u64) -> &mut Self

The offset on the disk file the data of this Pack starts. Usually 0.

pub fn set_local_timestamp(&mut self, val: u64) -> &mut Self

Timestamp from the moment this Pack was open. To check if the file was edited on disk while we had it open.

pub fn set_header(&mut self, val: PackHeader) -> &mut Self

Header data of this Pack.

pub fn set_dependencies(&mut self, val: Vec<(bool, String)>) -> &mut Self

List of Packs this Pack depends on. If the boolean is true, the packs are also required to be loaded before himself when starting the game.

In other places, we may refer to this as the Dependency List.

pub fn set_files(&mut self, val: HashMap<String, RFile>) -> &mut Self

List of files this Pack contains.

pub fn set_paths(&mut self, val: HashMap<String, Vec<String>>) -> &mut Self

List of file paths lowercased, with their casing counterparts. To quickly find files.

pub fn set_notes(&mut self, val: PackNotes) -> &mut Self

Notes added to the Pack. Exclusive of this lib.

pub fn set_settings(&mut self, val: PackSettings) -> &mut Self

Settings stored in the Pack itself, to be able to share them between installations.

impl Pack

Implementation of Pack.

pub fn new_with_version(pfh_version: PFHVersion) -> Self

This function creates a new empty Pack with a specific PFHVersion.

pub fn new_with_name_and_version(name: &str, pfh_version: PFHVersion) -> Self

This function creates a new empty Pack with a name and a specific PFHVersion.

pub fn read_and_merge_ca_packs( game: &GameInfo, game_path: &Path, ) -> Result<Self>

This function reads and returns all CA Packs for the provided game merged as one, for easy manipulation.

This needs a GameInfo to get the Packs from, and a game path to search the Packs on.

pub fn read_and_merge( pack_paths: &[PathBuf], game: &GameInfo, lazy_load: bool, ignore_mods: bool, keep_order: bool, ) -> Result<Self>

Convenience function to open multiple Packs as one, taking care of overwriting files when needed.

If this function receives only one path, it works as a normal read_from_disk function. If it receives none, an error will be returned.

pub fn merge(packs: &[Self]) -> Result<Self>

Convenience function to merge open Packs as one, taking care of overwriting files when needed.

Packs are merged in the order they are provided. If you need to use a custom order, sort them before merging, or use the read_and_merge function instead.

Internal files are left in the state they were before. If you need them loaded, do it after this.

pub fn save( &mut self, path: Option<&Path>, game_info: &GameInfo, extra_data: &Option<EncodeableExtraData<'_>>, ) -> Result<()>

Convenience function to easily save a Pack to disk.

If a path is provided, the Pack will be saved to that path. Otherwise, it’ll use whatever path it had set before.

pub fn pfh_version(&self) -> PFHVersion

This function returns the current PFH Version of the provided Pack.

pub fn pfh_file_type(&self) -> PFHFileType

This function returns the current PFH File Type of the provided Pack.

pub fn bitmask(&self) -> PFHFlags

This function returns the bitmask applied to the provided Pack.

pub fn internal_timestamp(&self) -> u64

This function returns the timestamp of the last time the Pack was saved.

pub fn game_version(&self) -> u32

This function returns the Game version this Pack is intended for.

pub fn build_number(&self) -> u32

This function returns the build number of the game this Pack is intended for.

pub fn authoring_tool(&self) -> &str

This function returns the tool that created the Pack. Max 8 characters, 00-padded.

pub fn extra_subheader_data(&self) -> &[u8]

This function returns the Extra Subheader Data, if any.

pub fn compression_format(&self) -> CompressionFormat

This function returns the compression format of the Pack.

pub fn set_pfh_version(&mut self, version: PFHVersion)

This function sets the current Pack PFH Version to the provided one.

pub fn set_pfh_file_type(&mut self, file_type: PFHFileType)

This function sets the current Pack PFH File Type to the provided one.

pub fn set_bitmask(&mut self, bitmask: PFHFlags)

This function sets the current Pack bitmask to the provided one.

pub fn set_internal_timestamp(&mut self, timestamp: u64)

This function sets the current Pack timestamp to the provided one.

pub fn set_game_version(&mut self, game_version: u32)

This function sets the game version (as in X.Y.Z) this Pack is for.

pub fn set_build_number(&mut self, build_number: u32)

This function sets the build number this Pack is for.

pub fn set_authoring_tool(&mut self, authoring_tool: &str)

This function sets the authoring tool that last edited this Pack.

pub fn set_extra_subheader_data(&mut self, extra_subheader_data: &[u8])

This function sets the Extra Subheader Data of the Pack.

pub fn set_compression_format( &mut self, cf: CompressionFormat, game_info: &GameInfo, ) -> CompressionFormat

This function sets the compression format the pack should use.

Returns the new compression format. Support for each format varies depending on the game.

pub fn spoof_ca_authoring_tool(&mut self, spoof: bool)

This function allows to toggle CA Authoring tool spoofing for this Pack.

Passing spoof as false will reset the Authoring Tool to the default one.

pub fn is_compressible(&self) -> bool

This function returns if the Pack is compressible or not.

pub fn missing_locs_paths(&self) -> (String, String)

This function returns the paths (as Strings) of the files used for missing loc data generation for the loaded Pack.

The first one is the one for existing entries. The second one is the one for new entries.

pub fn generate_missing_loc_data( &mut self, existing_locs: &HashMap<String, String>, ) -> Result<Vec<ContainerPath>>

This function is used to generate all loc entries missing from a Pack into a missing.loc file.

pub fn patch_siege_ai(&mut self) -> Result<(String, Vec<ContainerPath>)>

This function is used to patch Warhammer I & II Siege map packs so their AI actually works.

This also removes the useless xml files left by Terry in the Pack.

pub fn live_export( &mut self, game: &GameInfo, game_path: &Path, disable_regen_table_guid: bool, keys_first: bool, ) -> Result<()>

Function to perform a live extraction, meaning the files will be extracted while the game is running, allowing for real-time updates and modifications without the need for a full game restart.

Only works in Warhammer 3.

pub fn update_anim_ids( &mut self, game: &GameInfo, starting_id: i32, offset: i32, ) -> Result<Vec<ContainerPath>>

Function to update the anim ids of the pack on mass, based on a starting id and an offset.

Trait Implementations

impl Clone for Pack

fn clone(&self) -> Pack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Container for Pack

fn extract_metadata(&mut self, destination_path: &Path) -> Result<Vec<PathBuf>>

This method allows us to extract the metadata associated to the provided container as .json or .md files.

Pack implementation extracts the PackSettings of the provided Pack and its associated notes.

fn move_path( &mut self, source_path: &ContainerPath, destination_path: &ContainerPath, ) -> Result<Vec<(ContainerPath, ContainerPath)>>

This function allows you to move any RFile of folder of RFiles from one folder to another.

It returns a list with all the new ContainerPath.

fn insert(&mut self, file: RFile) -> Result<Option<ContainerPath>>

Inserts an RFile into the container.

fn disk_file_path(&self) -> &str

Returns the full path on disk where this container is stored.

fn files(&self) -> &HashMap<String, RFile>

Returns a reference to the internal file map.

fn files_mut(&mut self) -> &mut HashMap<String, RFile>

Returns a mutable reference to the internal file map.

fn disk_file_offset(&self) -> u64

Returns the byte offset of this container’s data within its disk file.

fn paths_cache(&self) -> &HashMap<String, Vec<String>>

Returns the paths cache mapping lowercase paths to their original-cased variants.

fn paths_cache_mut(&mut self) -> &mut HashMap<String, Vec<String>>

Returns a mutable reference to the paths cache.

fn internal_timestamp(&self) -> u64

This method returns the Last modified date stored on the provided Container, in seconds.

fn local_timestamp(&self) -> u64

This method returns the Last modified date the filesystem reports for the container file, in seconds.

fn extract( &mut self, container_path: ContainerPath, destination_path: &Path, keep_container_path_structure: bool, schema: &Option<Schema>, case_insensitive: bool, keys_first: bool, extra_data: &Option<EncodeableExtraData<'_>>, keep_data_in_memory: bool, ) -> Result<Vec<PathBuf>>

Extracts files from the container to disk.

fn insert_file( &mut self, source_path: &Path, container_path_folder: &str, schema: &Option<Schema>, ) -> Result<Option<ContainerPath>>

Inserts a file from disk into the container.

fn insert_folder( &mut self, source_path: &Path, container_path_folder: &str, ignored_paths: &Option<Vec<&str>>, schema: &Option<Schema>, include_base_folder: bool, ) -> Result<Vec<ContainerPath>>

Inserts an entire folder from disk into the container recursively.

fn remove(&mut self, path: &ContainerPath) -> Vec<ContainerPath>

Removes files matching the provided ContainerPath from the container.

fn disk_file_name(&self) -> String

Returns the filename of the container on disk.

fn has_file(&self, path: &str) -> bool

Checks if a file with the specified path exists in the container.

fn has_folder(&self, path: &str) -> bool

Checks if a non-empty folder exists at the specified path.

fn file(&self, path: &str, case_insensitive: bool) -> Option<&RFile>

Returns a reference to an RFile in the container by path.

fn file_mut(&mut self, path: &str, case_insensitive: bool) -> Option<&mut RFile>

Returns a mutable reference to an RFile in the container by path.

fn files_by_type(&self, file_types: &[FileType]) -> Vec<&RFile>

Returns references to all files of the specified types.

fn files_by_type_mut(&mut self, file_types: &[FileType]) -> Vec<&mut RFile>

Returns mutable references to all files of the specified types.

fn files_by_path( &self, path: &ContainerPath, case_insensitive: bool, ) -> Vec<&RFile>

Returns references to files matching the provided ContainerPath.

fn files_by_path_mut( &mut self, path: &ContainerPath, case_insensitive: bool, ) -> Vec<&mut RFile>

Returns mutable references to files matching the provided ContainerPath.

fn files_by_paths( &self, paths: &[ContainerPath], case_insensitive: bool, ) -> Vec<&RFile>

Returns references to files matching any of the provided ContainerPaths.

fn files_by_paths_mut( &mut self, paths: &[ContainerPath], case_insensitive: bool, ) -> Vec<&mut RFile>

Returns mutable references to files matching any of the provided ContainerPaths.

fn files_by_type_and_paths( &self, file_types: &[FileType], paths: &[ContainerPath], case_insensitive: bool, ) -> Vec<&RFile>

Returns references to files matching both type and path criteria.

fn files_by_type_and_paths_mut( &mut self, file_types: &[FileType], paths: &[ContainerPath], case_insensitive: bool, ) -> Vec<&mut RFile>

Returns mutable references to files matching both type and path criteria.

fn paths_cache_generate(&mut self)

Regenerates the internal paths cache from the current file list.

fn paths_cache_insert_path(&mut self, path: &str)

Adds a single path to the paths cache.

fn paths_cache_remove_path(&mut self, path: &str)

Removes a single path from the paths cache.

fn paths_folders_raw(&self) -> HashSet<String>

Returns a set of all folder paths contained within the container.

fn paths(&self) -> Vec<ContainerPath>

This method returns the list of ContainerPath corresponding to RFiles within the provided Container.

fn paths_raw(&self) -> Vec<&str>

This method returns the list of paths (as &str) corresponding to RFiles within the provided Container.

fn paths_raw_from_container_path(&self, path: &ContainerPath) -> Vec<String>

This function returns the list of paths (as String) corresponding to RFiles that match the provided ContainerPath.

fn preload(&mut self) -> Result<()>

This function preloads to memory any lazy-loaded RFile within this container.

fn move_paths( &mut self, in_out_paths: &[(ContainerPath, ContainerPath)], ) -> Result<Vec<(ContainerPath, ContainerPath)>>

This function allows you to move multiple RFiles or folders of RFiles from one folder to another.

fn clean_undecoded(&mut self)

This function removes all not-in-memory-already Files from the Container.

impl Debug for Pack

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

Formats the value using the given formatter.

impl Decodeable for Pack

fn decode<R: ReadBytes>( data: &mut R, extra_data: &Option<DecodeableExtraData<'_>>, ) -> Result<Self>

Decodes binary data into the implementing type.

impl Default for Pack

fn default() -> Pack

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Pack

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodeable for Pack

fn encode<W: WriteBytes>( &mut self, buffer: &mut W, extra_data: &Option<EncodeableExtraData<'_>>, ) -> Result<()>

Encodes the implementing type into binary data.

impl PartialEq for Pack

fn eq(&self, other: &Pack) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Pack

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Pack