KFC File Format Specification

OUTDATED: This format is based on KFC2. The lastest game version uses KFC3 which is not documented yet.

Everything is little-endian unless otherwise noted.

The format of resources is defined in the resource section.

Header

Addtional notes:

• version is a non-null-terminated ASCII string.
• resource_indices.count == resource_keys.count == resource_values.count

KFCLocation

To get the absolute file offset of the data, add relative_offset to the file offset of the relative_offset field itself. For example, if the relative_offset field is at file offset 0x20 and its value is 0x100, the data starts at file offset 0x120.

ContainerInfo

While the size is a uint64, ContentEntry uses a uint32 for the offset and size of each content, so no single content can be larger than 4 GiB.

ResourceLocation

There is currently always exactly one ResourceLocation entry. It may work with multiple entries, but this has not been tested yet.

StaticMapBucket

See Static Map for details.

ContentHash

A content hash is used to reference content assets within .dat files.

Here is how it is structured:

The hash of the content is computed with a custom algorithm which produces a 128-bit hash. The first 4 bytes of the result is then replaced with the size of the content.

The size field is used for determining the size of the content and there is no other way to get it.

Since content with the same data have the same ContentHash, you don't need to store the same content multiple times.

ContentEntry

Content is always aligned to 4096 bytes inside the .dat files. The size of the content is not stored here, but in the ContentHash.

ResourceId

A resource ID is used to reference resources within the .kfc file. It is a completely unique identifier for each resource. Here is how it is structured:

The hash of the resource id is a randomly generated UUIDv4.

ResourceEntry

The absolute offset of the resource can be calculated by adding the offset to the offset of the ResourceLocation.

ResourceBundleEntry

Static Map

Static maps consists of three arrays: buckets, keys and values. There are always N buckets, where N is a power of two, and the key and value arrays must always have the same length.

Here is how to look up a key in a static map in pseudocode:

hash = hash_function(key) % buckets.count
bucket = buckets[hash]

for i in 0 until bucket.count:
    idx = bucket.index + i

    if keys[idx] == key:
        return values[idx]

return not_found

Hash Functions

Note: The 64-bit word data = type_hash | (part_index << 32) is serialized in little-endian byte order and then fed, byte-by-byte, into FNV-1a32.

FNV-1a32

See FNV hash on Wikipedia.

Here is the pseudocode for FNV-1a32 used by the game:

function fnv1a32(data: byte[]) -> uint32:
    return fnv1a32_with_seed(data, 0x811C9DC5)

function fnv1a32_with_seed(data: byte[], seed: uint32) -> uint32:
    hash = seed

    for byte in data:
        hash = hash XOR byte
        hash = hash * 0x01000193

    return hash

Resource Bundles

Resource bundles are a collection of resources of the same type. You can use them to efficiently look up all resources of a specific type.

Here is how to get all resources of a specific type in pseudocode:

bundle = resource_bundles.get(type_hash)
bundle_resources = []

for i in 0 until bundle.count:
    idx = bundle.index + i

    resource_index = resource_indices[idx]
    resource_id = resource_keys[resource_index]
    resource_entry = resource_values[resource_index]

    bundle_resources.append((resource_id, resource_entry))

return bundle_resources