FileSystem API

Overview

The FileSystem class provides an abstraction layer for accessing Frostbite game file systems. It handles path resolution, catalog enumeration, superbundle management, and the InitFS memory file system.

using FrostySdk;

FileSystem fs = new FileSystem(@"C:\Program Files\FIFA 20");
fs.Initialize();

Constructor

FileSystem

constructor

Creates a new FileSystem instance for a game installation

FileSystem fs = new FileSystem(string basePath);

basePath

string

required

Path to the game installation directoryExample: @"C:\Program Files (x86)\Origin Games\Battlefield 5"

Initialization

Initialize

void

Initializes the file system by loading layout.toc and initfs

// Basic initialization
fs.Initialize();

// With encryption key (for games that require it)
byte[] encryptionKey = GetGameKey();
fs.Initialize(key: encryptionKey);

key

byte[]

default:"null"

Encryption key for games that use encrypted InitFS

This method:

Processes layout.toc (base and patch)
Loads catalogs from install manifest
Loads InitFS memory file system
Merges patch and base data

Properties

BasePath

string

Game installation directory path

Console.WriteLine($"Game path: {fs.BasePath}");

CacheName

string

Path to the cache file for this profile

string cachePath = fs.CacheName;
// Example: "Caches/FIFA20_3932059483"

Base

uint

Base version number from layout.toc

Head

uint

Head version number from layout.toc (current patch level)

Console.WriteLine($"Game version: {fs.Base} -> {fs.Head}");

SuperBundleCount

int

Total number of superbundles

int count = fs.SuperBundleCount;

SuperBundles

IEnumerable<string>

Enumerable collection of all superbundle names

foreach (string sb in fs.SuperBundles)
{
    Console.WriteLine($"SuperBundle: {sb}");
}

CatalogCount

int

Total number of catalogs

Catalogs

IEnumerable<string>

Enumerable collection of all catalog names

foreach (string catalog in fs.Catalogs)
{
    Console.WriteLine($"Catalog: {catalog}");
}

Path Resolution

ResolvePath

string

Resolves a game-relative path to an absolute file system path

// Resolve catalog
string catPath = fs.ResolvePath("native_data/installpackage_00/cas.cat");
// Returns: "C:\Games\FIFA20\Data\installpackage_00\cas.cat"

// Resolve patch file
string patchPath = fs.ResolvePath("native_patch/installpackage_00/cas_01.cas");

// Returns empty string if not found
string missing = fs.ResolvePath("nonexistent/file.dat");
if (missing == "")
{
    Console.WriteLine("File not found");
}

filename

string

required

Game-relative path using forward slashes

Returns: Absolute file system path, or empty string if not foundSupported prefixes:

native_data/ - Base game data
native_patch/ - Patch data
No prefix - Searches both locations

ResolvePath

string

Resolves a ManifestFileRef to an absolute path

ManifestFileRef fileRef = GetFileRef();
string path = fs.ResolvePath(fileRef);

fileRef

ManifestFileRef

required

Manifest file reference

Catalog Management

GetCatalogFromSuperBundle

string

Gets the catalog name that contains a specific superbundle

string catalog = fs.GetCatalogFromSuperBundle("win32/levels/mp_001");
// Returns: "win32/installpackage_00"

sbName

string

required

Superbundle name

GetCatalog

string

Gets the catalog name from a ManifestFileRef

string catalogName = fs.GetCatalog(fileRef);

EnumerateCatalogInfos

IEnumerable<CatalogInfo>

Enumerates detailed catalog information

foreach (CatalogInfo catalog in fs.EnumerateCatalogInfos())
{
    Console.WriteLine($"Catalog: {catalog.Name}");
    Console.WriteLine($"  ID: {catalog.Id}");
    Console.WriteLine($"  Always Installed: {catalog.AlwaysInstalled}");
    Console.WriteLine($"  SuperBundles: {catalog.SuperBundles.Count}");
    
    foreach (var sb in catalog.SuperBundles)
    {
        Console.WriteLine($"    - {sb.Key} (Split: {sb.Value})");
    }
}

CatalogInfo Properties:

Id (Guid) - Unique catalog identifier
Name (string) - Catalog path name
AlwaysInstalled (bool) - Whether catalog is required
SuperBundles (Dictionary<string, bool>) - SuperBundles in this catalog

InitFS / Memory File System

InitFS is a virtual file system stored in initfs_win32 that contains configuration files, scripts, and other data.

HasFileInMemoryFs

bool

Checks if a file exists in the memory file system

if (fs.HasFileInMemoryFs("Scripts/MyScript.lua"))
{
    byte[] script = fs.GetFileFromMemoryFs("Scripts/MyScript.lua");
}

name

string

required

File path in InitFS

GetFileFromMemoryFs

byte[]

Gets file data from the memory file system

byte[] data = fs.GetFileFromMemoryFs("Dictionaries/ebx.dict");
if (data != null)
{
    ProcessDictionary(data);
}

name

string

required

File path in InitFS

Returns: File data, or null if not found

EnumerateFilesInMemoryFs

IEnumerable<string>

Enumerates all files in the memory file system

foreach (string file in fs.EnumerateFilesInMemoryFs())
{
    Console.WriteLine($"InitFS file: {file}");
}

Common InitFS files:

Scripts/ - Configuration and script files
Dictionaries/ - Decompression dictionaries
Profiles/ - Profile definitions
Various configuration files

Source Management

AddSource

void

Adds a file system source path to search

// Add single path
fs.AddSource("Data");

// Add path and iterate subdirectories
fs.AddSource("SubDir", iterateSubPaths: true);

path

string

required

Relative path from BasePath

iterateSubPaths

bool

default:"false"

Recursively add subdirectories containing package.mft

Manifest Operations

EnumerateBundles

IEnumerable<DbObject>

Enumerates bundle data from manifest

foreach (DbObject bundle in fs.EnumerateBundles())
{
    string name = bundle.GetValue<string>("name");
    string catalog = bundle.GetValue<string>("catalog");
    Console.WriteLine($"Bundle: {name} in {catalog}");
}

Only available for games using manifest-based loading (FIFA 19+, Anthem, etc.)

GetManifestBundle

ManifestBundleInfo

Gets manifest bundle information by name or hash

// By name
ManifestBundleInfo bundle = fs.GetManifestBundle("win32/levels/mp_001");

// By hash
ManifestBundleInfo bundle = fs.GetManifestBundle(nameHash);

name

string

Bundle name

nameHash

int

Bundle name hash

GetManifestChunk

ManifestChunkInfo

Gets manifest chunk information by GUID

ManifestChunkInfo chunk = fs.GetManifestChunk(chunkGuid);
if (chunk != null)
{
    Console.WriteLine($"Chunk at offset: {chunk.file.offset}");
}

Utility Methods

GetFileRef

ManifestFileRef

Gets a ManifestFileRef from an absolute path

ManifestFileRef fileRef = fs.GetFileRef(absolutePath);

GetFilePath

string

Gets the file path for a CAS file

// By index
string path = fs.GetFilePath(fileIndex);

// By catalog and CAS index
string path = fs.GetFilePath(catalogIndex, casIndex, isPatch);

CreateDeobfuscator

IDeobfuscator

Creates a deobfuscator instance for this game

IDeobfuscator deobfuscator = fs.CreateDeobfuscator();

Used internally for reading obfuscated files like layout.toc

Usage Examples

using FrostySdk;
using System;

// Initialize file system
FileSystem fs = new FileSystem(@"C:\Games\Battlefield V");
fs.Initialize();

Console.WriteLine($"Game: {ProfilesLibrary.DisplayName}");
Console.WriteLine($"Version: {fs.Base} -> {fs.Head}");
Console.WriteLine($"SuperBundles: {fs.SuperBundleCount}");
Console.WriteLine($"Catalogs: {fs.CatalogCount}");

Game-Specific Behavior

Different Frostbite games use different file system layouts: Legacy Games (BF4, DAI, NFS, etc.)

Single Data directory
Simple catalog structure
No manifest system

Modern Games (FIFA 19+, BFV, Anthem)

Install chunks/packages
Manifest-based loading
Split superbundles across catalogs
May use encryption

Edge Case: NFS Edge

Uses .das files instead of CAS
Special DAS/DAL file format

The FileSystem class handles these differences automatically based on the loaded profile.

Core APIs

Asset Types

Plugin APIs

Data Structures

Overview

Constructor

Initialization

Properties

Path Resolution

Catalog Management

InitFS / Memory File System

Source Management

Manifest Operations

Utility Methods

Usage Examples

Game-Specific Behavior

See Also

Build docs developers (and LLMs) love

Core APIs

Asset Types

Plugin APIs

Data Structures

​Overview

​Constructor

​Initialization

​Properties

​Path Resolution

​Catalog Management

​InitFS / Memory File System

​Source Management

​Manifest Operations

​Utility Methods

​Usage Examples

​Game-Specific Behavior

​See Also

Build docs developers (and LLMs) love

Overview

Constructor

Initialization

Properties

Path Resolution

Catalog Management

InitFS / Memory File System

Source Management

Manifest Operations

Utility Methods

Usage Examples

Game-Specific Behavior

See Also