Asobo Save Game File Format Specification

This is the save game format used in FUEL. Other games have different formats. Saves are located in %USERPROFILE%\Documents\My Games\FUEL this directory contains one subdirectory for each GFWL profile name, where the name of the subdirectory is the same as the name of the profile. Each of these subdirectories contains a single FUEL_SAVE_V14.sav file which is the save game for that profile. Note that save games use the Alternate CRC-32 algorithm and not the primary one. For more information about the compression used, see the Asobo Arithmetic Coding Compression entry.

struct SaveGame
{
    std::uint32_t xliveHeaderSize;
        // Always 4
        // Written by xlive
    std::uint32_t saveGameDataCRC32Checksum0;
        // Alternate CRC-32 Checksum of saveGameData taken as a raw byte buffer
        // Equals saveGameDataCRC32Checksum1
        // Written by xlive
    SaveGameData saveGameData;
        // 199996 bytes
    std::uint32_t saveGameDataCRC32Checksum1;
        // Alternate CRC-32 Checksum of saveGameData taken as a raw byte buffer
        // Equals saveGameDataCRC32Checksum0
};

struct SaveGameData 
{
    std::uint32_t dataCompressedSize;
        // Includes the sizes of dataCompressedSize and dataDecompressedSize
    std::uint32_t dataDecompressedSize;
    std::uint8_t data[dataCompressedSize - 4 - 4];
        // dataCompressedSize and dataDecompressedSize are part of the compressed data so we subtract their size from the data array
        // Data is compressed using Asobo's Order 1 Arithmetic Coding
    std::uint8_t zeros[199996 - dataCompressedSize - 1];
        // Filled with 0x00
        // Used to pad the SaveGameData structure size to 199996 bytes
    std::uint8_t version;
        // Always equals 61
};

The following is an 010 Editor template for the decompressed save data.

struct AlignedCString
{
    local int len = ReadStringLength(FTell());
    char str[len];

    local int a = 4;
    local int x = FTell() + 1;
    local int r = x % a;
    FSeek(r ? x + (a - r) : x);
};

struct
{
    AlignedCString SectionName;
    uint32 unk0;
    byte x[66];
    int32 fuel;
    uint32 total_fuel_drums_found;
    uint32 camera_distance;
    uint32 y;
    uint32 hub_index;
    int32 yy;
    uint32 selected_vehicle_index;
    int32 unk2;
    uint32 head_type_index;
    uint32 chest_type_index;
    uint32 legs_type_index;
    uint32 head_livery_index;
    uint32 chest_livery_index;
    uint32 legs_livery_index;
    uint32 body_livery_index;
    uint32 body_color_index;
    byte race_info;
    byte ranking_info;
    byte gps;
    byte speed_meter;
    byte length_uint; // miles = 1, km = 0
    byte brightness; // 1 = changed, 0 = default
    byte padding[2];
    float xxx;
    float yyy;
    float zzz;
    uint32 h;
    uint32 distance_covered_in_free_ride_km;
    float distance_covered_in_free_ride_m;
    uint32 distance_covered_in_race_ride_km;
    float distance_covered_in_race_ride_m;
    uint32 distance_covered_on_road_km;
    float distance_covered_on_road_m;
    uint32 distance_covered_off_road_km;
    float distance_covered_off_road_m;
    float longest_jump;
    float unk3;
    uint32 unk4;
    uint32 developer_flags; // 0x1 on = hide huds
    byte z[12];
    uint32 sessions_played_and_finished;
    uint32 sessions_ranked_1st;
    byte zz[12];
    float max_time_spent_in_air;
    float peak_speed; // stored as m/s which is 0.277778 * km/h
    uint32 number_of_times_heliports_used;
    uint32 time_played; // milliseconds
    byte ww[8];
    float brightness;
    uint32 o;
    uint32 music_volume; // [0-16]
    uint32 sfx_volume; // [0-16]
    byte g[21];
    byte x_axis; // 1 = inverted, 0 = normal
    ushort vibrations;
    byte b[16];
    uint32 y_axis;
} SECTION_SAVESTRUCT_INFOS;

struct
{
    AlignedCString SectionName;
    int unk1;
    int vehicles_size;
    struct
    {
        uint32 vehicle_crc32;
        byte unlocked;
        byte owned;
        byte pad0;
        byte pad1;
        float distance;
    } vehicles[vehicles_size];
} SECTION_VEHICLES_INFOS;

struct
{
    AlignedCString SectionName;
    uint32 unk0;
    uint32 datasizebytes;
    // data begins
    uint32 schemes_size;
    struct
    {
        uint32 bindings_size;
        struct
        {
            short a;
            short key_code;
            short c;
            short d;
            int32 e;
        } bindings[bindings_size] <optimize=false>;
    } schemes[schemes_size] <optimize=false>;
    // data ends
} SECTION_INPUT;

struct
{
    AlignedCString SectionName;
    int unk1;
    int actionsSize;
    struct
    {
        int index;
        byte unlocked;
        byte completed;
    } actions[actionsSize];
} SECTION_TUTORIAL;

struct
{
    AlignedCString SectionName;
    int unk1;
    int unlockedSize;
    struct
    {
        byte unk1;
        byte unk2;
    } unlocked[unlockedSize] <optimize=false>;
} SECTION_HUB_INFOS;

struct
{
    AlignedCString SectionName;
    int unk1;
    int hubs_size;
    struct
    {
        int unlockeds_size;
        short unlockeds[unlockeds_size] <optimize=false>;
    } hubs[hubs_size] <optimize=false>;
} SECTION_VISTAPOINT_INFOS;

struct
{
    AlignedCString SectionName;
    int unk1;
    local int editedRacesSize = 10;
    struct
    {
        uint32 b;
        uint32 c;
        uint32 d;
        uint32 e;
        uint32 numUsedCheckpoints;
        local int numCheckpoints = 32;
        struct
        {
            float x;
            float z;
            float y;
            uint32 a;
            uint32 b;
            uint32 c;
            float d;
            uint32 e;
            uint32 f;
        } checkpoints[numCheckpoints];
    } editedRaces[editedRacesSize] <optimize=true>;
} SECTION_EDITEDRACE_INFOS;

struct
{
    AlignedCString SectionName;
    uint32 unk0;
    uint32 hubs_ssize;
    struct
    {
        uint32 hub_index;
        uint32 unk3;
        uint32 careers_ssize;
        struct
        {
            byte x[40];
        } careers[careers_ssize] <optimize=false>;
        uint32 challenges_size;
        struct
        {
            byte x[40];
        } challenges[challenges_size] <optimize=false>;
    } hubs[hubs_ssize] <optimize=false>;
} SECTION_MISSION_INFOS;

struct
{
    AlignedCString SectionName;
    uint32 unk0;
    uint32 hubs_size;
    struct
    {
        uint32 traffics_size;
        struct
        {
            uint32 crc32;
            byte spotted;
            byte found;
        } traffics[traffics_size] <optimize=false>;
    } hubs[hubs_size] <optimize=false>;
} SECTION_TRAFFIC_INFOS;

struct
{
    AlignedCString SectionName;
    uint32 unk0;
    uint32 hubs_size;
    struct
    {
        uint32 liveries_size;
        struct
        {
            uint32 crc32;
            byte spotted;
            byte found;
        } liveries[liveries_size] <optimize=false>;
    } hubs[hubs_size] <optimize=false>;
} SECTION_VEHICLES_LIVERIES_INFOS;

struct
{
    AlignedCString SectionName;
    int unk1;
    int unlockedSize;
    byte unlocked[unlockedSize];
    int selected_size;
    struct
    {
        uint32 slot_crc32;
        int32 item_index;
    } selected[selected_size];
} SECTION_PILOT_LIVERIES_INFOS;