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

constructor

Creates a new FileSystem instance for a game installation

FileSystem fs = new FileSystem(string basePath);

string

required

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

Initialization

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);

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

string

Game installation directory path

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

string

Path to the cache file for this profile

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

uint

Base version number from layout.toc

uint

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

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

int

Total number of superbundles

int count = fs.SuperBundleCount;

IEnumerable<string>

Enumerable collection of all superbundle names

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

int

Total number of catalogs

IEnumerable<string>

Enumerable collection of all catalog names

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

Path Resolution

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");
}

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

string

Resolves a ManifestFileRef to an absolute path

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

ManifestFileRef

required

Manifest file reference

Catalog Management

string

Gets the catalog name that contains a specific superbundle

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

string

required

Superbundle name

string

Gets the catalog name from a ManifestFileRef

string catalogName = fs.GetCatalog(fileRef);

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.

bool

Checks if a file exists in the memory file system

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

string

required

File path in InitFS

byte[]

Gets file data from the memory file system

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

string

required

File path in InitFS

Returns: File data, or null if not found

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

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);

string

required

Relative path from BasePath

bool

default:"false"

Recursively add subdirectories containing package.mft

Manifest Operations

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.)

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);

string

Bundle name

int

Bundle name hash

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

ManifestFileRef

Gets a ManifestFileRef from an absolute path

ManifestFileRef fileRef = fs.GetFileRef(absolutePath);

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);

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}");

// Find catalog file
string catPath = fs.ResolvePath("native_data/installpackage_00/cas.cat");
if (catPath != "")
{
    Console.WriteLine($"Found catalog: {catPath}");
    // Open and process catalog
}

// Find patch file
string patchPath = fs.ResolvePath("native_patch/installpackage_00/cas_01.cas");
if (patchPath != "")
{
    Console.WriteLine("Game has patches installed");
}

// List all catalogs and their superbundles
foreach (CatalogInfo catalog in fs.EnumerateCatalogInfos())
{
    Console.WriteLine($"\nCatalog: {catalog.Name}");
    Console.WriteLine($"  Always Installed: {catalog.AlwaysInstalled}");
    
    foreach (var sb in catalog.SuperBundles)
    {
        Console.WriteLine($"  - {sb.Key}");
    }
}

// Find which catalog contains a superbundle
string sbName = "win32/levels/mp_metropolis";
string catalog = fs.GetCatalogFromSuperBundle(sbName);
Console.WriteLine($"{sbName} is in {catalog}");

// List all InitFS files
Console.WriteLine("InitFS Contents:");
foreach (string file in fs.EnumerateFilesInMemoryFs())
{
    Console.WriteLine($"  {file}");
}

// Load specific files
if (fs.HasFileInMemoryFs("Scripts/CasEncrypt.yaml"))
{
    byte[] data = fs.GetFileFromMemoryFs("Scripts/CasEncrypt.yaml");
    string content = Encoding.UTF8.GetString(data);
    Console.WriteLine(content);
}

// Load decompression dictionary
if (fs.HasFileInMemoryFs("Dictionaries/ebx.dict"))
{
    byte[] dict = fs.GetFileFromMemoryFs("Dictionaries/ebx.dict");
    ZStd.SetDictionary(dict);
}

// List all superbundles
Console.WriteLine("SuperBundles:");
foreach (string sb in fs.SuperBundles)
{
    Console.WriteLine($"  {sb}");
    
    // Find its catalog
    string catalog = fs.GetCatalogFromSuperBundle(sb);
    Console.WriteLine($"    -> {catalog}");
}

// For FIFA 19+, Anthem, etc.
if (fs.GetManifestBundle("bundleName") != null)
{
    Console.WriteLine("Game uses manifest-based loading");
    
    // Enumerate bundles
    foreach (DbObject bundle in fs.EnumerateBundles())
    {
        string name = bundle.GetValue<string>("name");
        DbObject ebxList = bundle.GetValue<DbObject>("ebx");
        Console.WriteLine($"Bundle {name} has {ebxList?.Count ?? 0} EBX assets");
    }
}

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

​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

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