save.c

Go to the documentation of this file.

 
#include "save.h"
 
#include "audio_utils.h"
#include "bitset.h"
#include "card.h"
#include "game.h"
#include "game_variables.h"
#include "joker.h"
#include "list.h"
#include "util.h"
#include "version.h"
 
#include <stdlib.h>
#include <string.h>
 
// See https://gbadev.net/gbadoc/memory.html for more details on SRAM
// A few important pieces of info:
//   - Read/Writes are limited to 8-bits words so they are done byte per byte
//   - Memory is filled with 1s by default
//     (at least in mgba, not sure about real HW)
 
#define HEADER_ADDRESS  0x0
#define OPTIONS_ADDRESS 0x10
#define GAME_ADDRESS    0x30
 
#define SAVE_SECTION_FLAG_NONE    0
#define SAVE_SECTION_FLAG_OPTIONS (1 << 0)
#define SAVE_SECTION_FLAG_GAME    (1 << 1)
 
#define CHECK_MAGIC     0x4C414247 // Spells GBAL, used to determine if the save data is junk
#define CHECK_HASH_SIZE 7
#define GIT_HASH_START  17 // starts after "GBALATRO-VERSION:" in the gbalatro_version var
 
#define SAVE_LABEL_SIZE 16
 
// clang-format off
// clang-format on
typedef struct SaveHeader
{
    u32 magic;
    bool dirty;
    char githash[CHECK_HASH_SIZE];
    u32 valid_sections;
} SaveHeader;
 
static const SaveHeader SaveHeader_default = {
    .magic = CHECK_MAGIC,
    .dirty = false,
    .githash = "fffffff",
    .valid_sections = SAVE_SECTION_FLAG_NONE
};
 
// clang-format off
// clang-format on
typedef struct SaveOptions
{
    char tag_options[SAVE_LABEL_SIZE];
    u8 game_speed;
    bool cards_high_contrast;
    bool cards_more_readable;
    u8 music_volume;
    u8 sound_volume;
    s8 padding[11];
} SaveOptions;
 
// clang-format off
static const SaveOptions SaveOptions_default = {
    .tag_options = "- OPTIONS DATA -",
    .game_speed = GAME_SPEED_MIN,
    .cards_high_contrast = DEFAULT_HIGH_CONTRAST,
    .cards_more_readable = DEFAULT_MORE_READABLE,
    .music_volume = VOLUME_OPTION_MAX,
    .sound_volume = VOLUME_OPTION_MAX,
    .padding = {
        UNDEFINED, UNDEFINED, UNDEFINED,
        UNDEFINED, UNDEFINED, UNDEFINED,
        UNDEFINED, UNDEFINED, UNDEFINED,
        UNDEFINED, UNDEFINED
    }
};
// clang-format on
 
typedef struct JokerObjectSaveData
{
    u32 id;
    u32 persistent_state;
} JokerObjectSaveData;
 
// clang-format off
// clang-format on
typedef struct SaveGame
{
    char tag_internal[SAVE_LABEL_SIZE];
    s32 timer;
    RngInfo rng_info;
    int round;
    int ante;
    int money;
    s32 padding[2];
 
    char tag_jokers[SAVE_LABEL_SIZE];
    JokerObjectSaveData jokers_data[MAX_JOKERS_HELD_SIZE];
 
    char tag_end[4];
} SaveGame;
 
static const SaveGame SaveGame_default = {
    .tag_internal = "-INTERNAL DATA -",
    .timer = 0,
    .rng_info = {0, {0}},
    .round = 0,
    .ante = 0,
    .money = 0,
    .padding = {UNDEFINED, UNDEFINED},
 
    .tag_jokers = "- OWNED JOKERS -",
    .jokers_data = {},
 
    .tag_end = "_END"
};
 
static inline void write_sram(u32 sram_base, const u8* bytes, u32 size)
{
    if (sram_base + size > SRAM_SIZE)
        return;
 
    for (u32 i = 0; i < size; i++)
    {
        sram_mem[sram_base + i] = bytes[i];
    }
}
 
static inline void read_sram(u32 sram_base, u8* bytes, u32 size)
{
    if (sram_base + size > SRAM_SIZE)
        return;
 
    for (u32 i = 0; i < size; i++)
    {
        bytes[i] = sram_mem[sram_base + i];
    }
}
 
static inline bool check_hash(const char* prefix)
{
    for (u32 i = 0; i < CHECK_HASH_SIZE; i++)
    {
        if (gbalatro_version[GIT_HASH_START + i] != prefix[i])
        {
            return false;
        }
    }
 
    return true;
}
 
static inline bool is_version_dirty(void)
{
    return strlen(gbalatro_version) > GIT_HASH_START + CHECK_HASH_SIZE;
}
 
static inline bool get_save_header(SaveHeader* header)
{
    read_sram(HEADER_ADDRESS, (u8*)header, sizeof(*header));
    return (header->magic == CHECK_MAGIC) && header->dirty == is_version_dirty() &&
           check_hash(header->githash);
}
 
static inline void set_save_header(u32 section_flag)
{
    SaveHeader header;
 
    // Check for valid data. If it's junk, set all sections as invalid, else keep the flags.
    // Then add the requested flag.
    if (!get_save_header(&header))
    {
        memcpy(&header, &SaveHeader_default, sizeof(SaveHeader_default));
    }
 
    header.valid_sections |= section_flag;
 
    header.dirty = is_version_dirty();
    memcpy(&(header.githash), gbalatro_version + GIT_HASH_START, CHECK_HASH_SIZE);
 
    write_sram(HEADER_ADDRESS, (const u8*)&header, sizeof(header));
}
 
void save_options(void)
{
    SaveOptions options = SaveOptions_default;
 
    options.game_speed = g_game_vars.game_speed;
    options.cards_high_contrast = get_cards_high_contrast();
    options.cards_more_readable = get_cards_more_readable();
    options.music_volume = g_game_vars.music_volume;
    options.sound_volume = g_game_vars.sound_volume;
 
    write_sram(OPTIONS_ADDRESS, (const u8*)&options, sizeof(options));
    set_save_header(SAVE_SECTION_FLAG_OPTIONS);
}
 
void load_options(void)
{
    SaveHeader header;
    SaveOptions options = SaveOptions_default;
 
    // If options data doesn't exist or is invalid, just don't read from
    // SRAM and apply the default values
    if (get_save_header(&header) && (header.valid_sections & SAVE_SECTION_FLAG_OPTIONS))
        read_sram(OPTIONS_ADDRESS, (u8*)&options, sizeof(options));
 
    g_game_vars.game_speed = options.game_speed;
    g_game_vars.music_volume = options.music_volume;
    g_game_vars.sound_volume = options.sound_volume;
 
    set_volume(volume_module_step_to_val(g_game_vars.music_volume));
    set_cards_high_contrast(options.cards_high_contrast);
    set_cards_more_readable(options.cards_more_readable);
}
 
bool is_game_data_valid(void)
{
    SaveHeader header;
    return get_save_header(&header) && (header.valid_sections & SAVE_SECTION_FLAG_GAME);
}
 
void save_game(void)
{
    SaveGame game = SaveGame_default;
 
    // Fixed data
 
    game.timer = g_game_vars.timer;
    game.rng_info = g_game_vars.rng_info;
    game.round = g_game_vars.round;
    game.ante = g_game_vars.ante;
    game.money = g_game_vars.money;
 
    // Lists
 
    List* jokers_list = get_jokers_list();
    int nb_jokers = list_get_len(jokers_list);
 
    int i = 0;
    for (; i < nb_jokers; i++)
    {
        JokerObject* joker_object = list_get_at_idx(jokers_list, (u32)i);
        JokerObjectSaveData data = {
            (u32)joker_object->joker->id,
            joker_object->joker->persistent_state
        };
        game.jokers_data[i] = data;
    }
    for (; i < MAX_JOKERS_HELD_SIZE; i++)
    {
        JokerObjectSaveData data = {UNDEFINED, UNDEFINED};
        game.jokers_data[i] = data;
    }
 
    write_sram(GAME_ADDRESS, (const u8*)&game, sizeof(game));
    set_save_header(SAVE_SECTION_FLAG_GAME);
}
 
void load_game(void)
{
    SaveHeader header;
 
    if (!get_save_header(&header) || !(header.valid_sections & SAVE_SECTION_FLAG_GAME))
        return;
 
    SaveGame game = SaveGame_default;
    read_sram(GAME_ADDRESS, (u8*)&game, sizeof(game));
 
    g_game_vars.timer = game.timer;
    rng_restore(game.rng_info);
    g_game_vars.round = game.round;
    g_game_vars.ante = game.ante;
    g_game_vars.money = game.money;
 
    // TODO: load Jokers from stored minimal data
}