Struct AnimPack 

pub struct AnimPack { /* private fields */ }

Represents an AnimPack file decoded in memory.

AnimPacks are container files that bundle animation-related assets into a single archive. This struct holds the complete AnimPack structure including metadata and all contained files.

Fields

• disk_file_path: Path to the AnimPack file on disk (empty if in-memory only)
• disk_file_offset: Byte offset within the disk file (0 if standalone file)
• local_timestamp: Last modified timestamp for change detection
• paths: Lowercase path lookup cache for case-insensitive file searches
• files: Map of file paths to their RFile data

Binary Format

Bytes	Type	Data
4	u32	File Count
X * File Count	File List	List of files inside the AnimPack File

File Structure

Bytes	Type	Data
*	Sized StringU8	File Path
4	u32	File Length in bytes
File Length	&[u8]	File Data

Container Implementation

AnimPack implements the Container trait, providing:

• File extraction and insertion
• Case-insensitive path lookup via paths cache
• Lazy loading support (when unencrypted)
• Timestamp-based change detection

Lazy Loading

When lazy_load is enabled in DecodeableExtraData, file data is not read immediately but loaded on-demand. This reduces memory usage for large AnimPacks. Lazy loading requires:

• Valid disk_file_path to a file on disk
• Unencrypted data (encrypted files are always fully loaded)

Example

use rpfm_lib::files::animpack::AnimPack;
use rpfm_lib::files::Container;

// Create a new empty AnimPack
let mut animpack = AnimPack::default();

// Add a file
animpack.insert(rfile, "battle/animations/unit.bin")?;

// Look up a file (case-insensitive)
if let Some(file) = animpack.file_by_path("BATTLE/animations/UNIT.bin") {
    println!("Found file!");
}

Trait Implementations

impl Clone for AnimPack

fn clone(&self) -> AnimPack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Container for AnimPack

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 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 extract_metadata(&mut self, _destination_path: &Path) -> Result<Vec<PathBuf>>

Extracts container metadata as .json files.

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

Inserts an RFile into the container.

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 internal_timestamp(&self) -> u64

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

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 move_path( &mut self, source_path: &ContainerPath, destination_path: &ContainerPath, ) -> Result<Vec<(ContainerPath, ContainerPath)>>

This function allows you to move any RFile or folder 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 AnimPack

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

Formats the value using the given formatter.

impl Decodeable for AnimPack

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

Decodes an AnimPack from a binary data source.

Parameters

• data: Binary reader implementing ReadBytes
• extra_data: Required decoding context (see below)

Required Extra Data Fields

This implementation requires DecodeableExtraData with:

• lazy_load: Enable lazy loading (ignored if encrypted)
• is_encrypted: Whether the AnimPack data is encrypted
• disk_file_path: Path to file on disk (required for lazy loading)
• disk_file_offset: Offset within disk file (0 for standalone files)
• data_size: Total size of AnimPack data in bytes
• timestamp: Last modified timestamp in seconds (0 for in-memory)

Returns

• Ok(AnimPack): Successfully decoded AnimPack with all files
• Err(_): I/O error, malformed data, or missing required extra data

Lazy Loading Behavior

When lazy_load is true and data is unencrypted:

• File metadata is read immediately
• File data is loaded on-demand when accessed
• Requires valid disk_file_path to a file on disk

When encrypted or lazy loading disabled:

• All file data is read into memory immediately

Example

use std::fs::File;
use std::io::BufReader;
use rpfm_lib::binary::ReadBytes;
use rpfm_lib::files::{Decodeable, DecodeableExtraData, animpack::AnimPack};
use rpfm_lib::utils::last_modified_time_from_file;

let path = "animations/unit.animpack";
let mut reader = BufReader::new(File::open(path)?);

let mut extra_data = DecodeableExtraData::default();
extra_data.set_disk_file_path(Some(path));
extra_data.set_data_size(reader.len()?);
extra_data.set_timestamp(last_modified_time_from_file(reader.get_ref())?);

let animpack = AnimPack::decode(&mut reader, &Some(extra_data))?;

impl Default for AnimPack

fn default() -> AnimPack

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AnimPack

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodeable for AnimPack

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

Encodes this AnimPack to a binary data stream.

Parameters

• buffer: Binary writer implementing WriteBytes
• extra_data: Encoding options (not used, pass None)

Returns

• Ok(()): Successfully encoded AnimPack
• Err(_): I/O error, file too large, or encoding error

Encoding Behavior

• Files are sorted alphabetically by path (case-insensitive)
• Paths use forward slashes (/) not backslashes (\)
• Each file is encoded inline with its size prefix
• Files larger than 4GB (u32::MAX) return an error

Path Format

Important: Encoded paths use forward slashes because animation sets created by assed tool break if backslashes are used.

Example

use std::fs::File;
use std::io::{BufWriter, Write};
use rpfm_lib::files::{Encodeable, animpack::AnimPack};

let mut animpack = AnimPack::default();
// ... add files to animpack ...

let mut encoded = vec![];
animpack.encode(&mut encoded, &None)?;

// Write to disk
let mut writer = BufWriter::new(File::create("output.animpack")?);
writer.write_all(&encoded)?;

impl PartialEq for AnimPack

fn eq(&self, other: &AnimPack) -> 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 AnimPack

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 AnimPack