src/files.c

Go to the documentation of this file.

/* {{{
 * CalcRogue, a roguelike game for PCs, calculators and PDAs
 * Copyright (C) 2003 Jim Babcock
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * }}} */
// file.c

#include "crogue.h"

void compress_tiles(void);

static const uchar save_file_extension[6] = { 0,'S','A','V',0,0xf8 };

#ifdef IS_CALCULATOR
//{{{
static void archive_file(const char *filename, int filesize)
{
    ulong space_free, block_free;
    
    filesize += 16; // Margin of error for various overheads.
    
    EM_survey(NULL, &space_free, &block_free, NULL, NULL, NULL);
    space_free += block_free;
    
    if(space_free < filesize) {
        message(gettext("WARNING: Not enough archive free. Using main memory."));
        read_char();
        return;
    } else if(block_free < filesize) {
        if(prompt(gettext("Garbage collect archive memory?")))
        {
            message(gettext("Garbage collecting archive memory."));
            EM_GC(FALSE);
            EM_survey(NULL, &space_free, &block_free, NULL, NULL, NULL);
            if(space_free < filesize)
            {
                message(gettext("Still not enough archive free. Using main memory."));
                return;
            }
        } else {
            message(gettext("Not enough archive free. Using main memory."));
            read_char();
            return;
        }
    }
    EM_moveSymToExtMem(SYMSTR(filename), HS_NULL);
}
//}}}
#endif

//{{{
void link_data_file(void)
{
    w->tiledescs     = (struct tiledesc* )deref_file_ptr(w->desc.tileoffset);
    w->itemdescs     = (struct filelink* )deref_file_ptr(w->desc.itemoffset);
    w->spelldescs    = (struct spelldesc*)deref_file_ptr(w->desc.spelllist);
    w->shopdescs     = (struct shopdesc* )deref_file_ptr(w->desc.shopdescs);
    w->playerclasses = (struct classdesc*)deref_file_ptr(w->desc.playerclasses);
    w->shuffledata   = (struct filelink* )deref_file_ptr(w->desc.stdata);
#ifdef IS_CALCULATOR
    w->dll_functions = _DLL_call(const void**,(const import_functions *f),0)(&body_functions);
    w->dll_interface = (const export_functions*)w->dll_functions;
#else
    w->dll_functions = dll_load(&body_functions);
    w->dll_interface = (const export_functions*)w->dll_functions;
#endif
}
//}}}

//{{{
//
// Save the game state
// Presently, just byte-dumps the main data structure
// This needs to be changed to include compression for the
// bigger parts.
//
void save_game(void)
{
    FILE *sg;
    const char *filename;
#   ifdef EXTERNAL_COMPRESSOR
    char cmd[512];
#   endif
    
#   ifdef IS_CALCULATOR
        int filesize;
#   endif
    
    // If a previous version of this game exists, delete it before writing new one
#   ifdef IS_CALCULATOR
        EM_moveSymFromExtMem(SYMSTR(SAVEFILENAME), HS_NULL);
        SymDel(SYMSTR(SAVEFILENAME));
#   endif
    
#   ifdef SHARED_SCORES
    filename = retprintf("%s%s_%s", file_prefix, getlogin(), SAVEFILENAME);
#   else
    filename = SAVEFILENAME;
#   endif
    
    sg = fopen(filename, "wb");
    
    if(sg)
    {
        frleinit_write(sg, &fhuffmanputc);
        fhuffmaninit_write();
        frlewrite(w, sizeof(world), sizeof(monster), sg);
        frlewrite(&w->t[0][0], sizeof(tile)*w->mapsize_x*w->mapsize_y, sizeof(tile), sg);
        frlewrite(w->shuffletranslation, sizeof(uint)*w->desc.shuffletabsize, sizeof(uint), sg);
        frlewrite(w->itemids, (w->desc.itementries/32 + 1) * 4, 1, sg);
        frlewrite(w->plr.spellknowledge, sizeof(slong)*w->desc.numspells, sizeof(slong), sg);
        frlewrite(w->items.items, sizeof(item)*w->items.alloced, sizeof(item), sg);
        if(w->wandering_monsters_num)
            frlewrite(w->wandering_monsters, sizeof(monster)*w->wandering_monsters_num, sizeof(monster), sg);
        frleflush(sg);
        fhuffmanflush(sg);
#       ifdef IS_CALCULATOR
            fwrite(save_file_extension, 6, 1, sg);
            filesize = peek_w(sg->base);
#       endif
        frlefinalize(sg);
        fclose(sg);
#       ifdef IS_CALCULATOR
            if(w->options[OPTION_AUTOARCHIVE] == OPTION_ARCHIVE_YES)
                archive_file(SAVEFILENAME, filesize);
#       endif
#       ifdef EXTERNAL_COMPRESSOR
        sprintf(cmd, EXTERNAL_COMPRESSOR " -f -q %s", filename);
        system(cmd);
#       endif
    }
}
//}}}
//{{{
//
// Attempts to load a saved game from the filesystem.
// Returns 1 if successful or 0 if no saved game exists.
//
int restore_game(void)
{
    FILE *fin;
    
#ifdef SHARED_SCORES
    char filename[512];
    sprintf(filename, "%s%s_%s", file_prefix, getlogin(), SAVEFILENAME);
#else
    const char *filename = SAVEFILENAME;
#endif
    
#ifdef EXTERNAL_COMPRESSOR
    system( retprintf(EXTERNAL_COMPRESSOR " -f -q -d %s.gz", filename) );
#endif
    
    fin = fopen( filename, "rb");
    if( fin )
    {
        if(!frleverify(fin))
        {
            message(gettext("There's a corrupted save file here..."));
            fclose(fin);
            read_char();
            return 0;
        }
        frleinit_read(fin);
        fhuffmaninit_read();
        
        frleread(w, sizeof(world), sizeof(monster), fin);
        w->t = NULL;
        resize_map_store(w->mapsize_x, w->mapsize_y);
        frleread(&w->t[0][0], sizeof(tile)*w->mapsize_x*w->mapsize_y, sizeof(tile), fin);
        sys_init_data_file();
        
        w->shuffletranslation = (uint*)debug_malloc( sizeof(uint) * w->desc.shuffletabsize );
        init_discoveries();
        w->items.items = (item*)debug_malloc(w->items.alloced*sizeof(item));
        init_spells();
        
        frleread(w->shuffletranslation, sizeof(uint)*w->desc.shuffletabsize, sizeof(uint), fin);
        frleread(w->itemids, (w->desc.itementries/32 + 1) * 4, 1, fin);
        frleread(w->plr.spellknowledge, sizeof(slong)*w->desc.numspells, sizeof(slong), fin);
        frleread(w->items.items, sizeof(item)*w->items.alloced, sizeof(item), fin);
        if(w->wandering_monsters_num)
        {
            w->wandering_monsters = debug_malloc(sizeof(monster)*w->wandering_monsters_num);
            frleread(w->wandering_monsters, sizeof(monster)*w->wandering_monsters_num, sizeof(monster), fin);
        }
        
        w->current_map = deref_file_ptr(w->current_map_link);
        
        fclose(fin);
#ifdef EXTERNAL_COMPRESSOR
        // Recompress save
        system( retprintf(EXTERNAL_COMPRESSOR " -f -q %s", filename) );
#endif
        return 1;
    } else {
        return 0;
    }
}
//}}}

const uchar level_file_extension[6] = { 0,'L','E','V',0,0xf8 };

//{{{
const char *levelfile_name(int levelnum)
{
#ifdef IS_CALCULATOR
    return retprintf("ROGLVL%i", levelnum);
#endif
#ifdef REALCOMPUTER
    #ifdef SHARED_SCORES
    return retprintf("%s%s_roglvl%i.sav", file_prefix, getlogin(), levelnum);
    #else
    return retprintf("roglvl%i.sav", levelnum);
    #endif
#endif  
#ifdef PALMOS
    return retprintf("roglvl%i", levelnum);
#endif
}
//}}}
//{{{
//
// Save the current level (the parts of the game state which should be restored
// when the player comes back: items, monsters, walls/floor, etc). The two large
// tables (monsters and tiles) are written using a special form of run-length
// encoding. The first byts of each struct are ordered sequentially, followed
// by the second byte of each struct, etc. This avoids the complexity of having
// a single run length handle more than one character, while keeping similar
// bytes together.
//
// File naming convention depends on platform.
//
void save_level(void)
{
    FILE *save;
    const char *name;
    ushort map_size[2];
#   ifdef EXTERNAL_COMPRESSOR
    char cmd[512];
#   endif
#   ifdef IS_CALCULATOR
    int filesize;
#   endif
    
    name = levelfile_name(w->level);
    
#ifdef IS_CALCULATOR
    // Unlink pre-existing level of the same name
    EM_moveSymFromExtMem(SYMSTR(name), HS_NULL);
    SymDel(SYMSTR(name));
#endif
    
    // Prep for efficient writing
    compress_items();
    compress_monsters();
    
    save = fopen(name, "wb");
    
    frleinit_write(save, &fhuffmanputc);
    fhuffmaninit_write();
    
    frlewrite( (char*)(&w->m[0]), sizeof(monster)*MONSTERS_MAX, sizeof(monster), save );
    map_size[0] = w->mapsize_x; map_size[1] = w->mapsize_y;
    frlewrite( (char*)(map_size), sizeof(ushort)*2, sizeof(ushort), save );
    frlewrite( (char*)(&w->t[0][0]), sizeof(tile)*MAPSIZE_X*MAPSIZE_Y, sizeof(tile), save );
    
    // Write items
    frlewrite(&w->items, sizeof(itemsinfo), 1, save);
    frlewrite(w->items.items, sizeof(item)*w->items.alloced, sizeof(item), save);
    
    frleflush(save);
    fhuffmanflush(save);
    
#   ifdef IS_CALCULATOR
        fwrite(level_file_extension, 6, 1, save);
        filesize = peek_w(save->base);
#   endif
    frlefinalize(save);
    fclose(save);

#   ifdef EXTERNAL_COMPRESSOR
        sprintf(cmd, EXTERNAL_COMPRESSOR " -f -q %s", name);
        system(cmd);
#   endif
#   ifdef IS_CALCULATOR 
        if(w->options[OPTION_AUTOARCHIVE] == OPTION_ARCHIVE_YES)
            archive_file(name, filesize);
#   endif
}
//}}}
//{{{
//
// Load the level number given in w->level from a run-length encoded file.
// Returns 1 if successful, 0 if the file does not exist.
//
int load_level(int source, coord pos)
{
    FILE *save;
    const char *name;
    ushort map_size[2];
#ifdef EXTERNAL_COMPRESSOR
    char cmd[512];
#endif
    
    name = levelfile_name(w->level);
    
#ifdef EXTERNAL_COMPRESSOR
    // Check for file existance and accessibility
    sprintf(cmd, "%s.gz", name);
    if(access(cmd, R_OK) != 0)
        return 0;
    
    // Open file
    sprintf(cmd, EXTERNAL_COMPRESSOR " -f -q -d %s.gz", name);
    system(cmd);
#endif
    
    save = fopen(name, "rb");
    
    if( !save )
        return 0;
    
    if(!frleverify(save))
    {
        message(gettext("This level is corrupt... I'll build a new one."));
        fclose(save);
        return 0;
    }
    frleinit_read(save);
    fhuffmaninit_read();
    
    frleread( (char*)(&w->m[0]), sizeof(monster)*MONSTERS_MAX, sizeof(monster), save );
    frleread( (char*)(map_size), sizeof(ushort)*2, sizeof(ushort), save );
    resize_map_store(map_size[0], map_size[1]);
    frleread( (char*)(&w->t[0][0]), sizeof(tile)*MAPSIZE_X*MAPSIZE_Y, sizeof(tile), save );
    
    place_player_on_map(source, pos);
    
    // Read items
    cleanup_items();
    frleread(&w->items, sizeof(itemsinfo), 1, save);
    w->items.items = (item*)debug_malloc(w->items.alloced*sizeof(item));
    frleread(w->items.items, sizeof(item)*w->items.alloced, sizeof(item), save);
    
    fclose(save);
    
#ifdef EXTERNAL_COMPRESSOR
    // Recompress file
    sprintf(cmd, EXTERNAL_COMPRESSOR " -f -q %s", name);
    system(cmd);
#endif

    full_redraw();
    
    return 1;
}
//}}}
//{{{
//
// Delete any remnants of saved games (the saved game and saved levels). This
// is called when the player dies to prevent him from using the files to cheat
// and bring his character back.
//
void cleanup_save(void)
{
#ifdef IS_CALCULATOR
    int i;
    const char *name;
    
    EM_moveSymFromExtMem(SYMSTR(SAVEFILENAME), HS_NULL);
    SymDel(SYMSTR(SAVEFILENAME));
    
    for(i=1; i<=w->maxlevel; i++)
    {
        name = levelfile_name(i);
        EM_moveSymFromExtMem(SYMSTR(name), HS_NULL);
        SymDel(SYMSTR(name));
    }
#else
    int i;
    const char *name;
    #ifdef SHARED_SCORES
        #ifdef EXTERNAL_COMPRESSOR
        name = retprintf("%s%s_%s.gz", file_prefix, getlogin(), SAVEFILENAME);
        #else
        name = retprintf("%s%s_%s", file_prefix, getlogin(), SAVEFILENAME);
        #endif
    #else
    name = SAVEFILENAME;
    #endif
    
    remove(name);
    
    for(i=1; i<=w->maxlevel+1; i++)
    {
        name = levelfile_name(i);
        remove(name);
    }
#endif
}
//}}}

//{{{
void compress_tiles(void)
{
    int i, j;
    
    for(i=0; i<MAPSIZE_Y; i++)
    for(j=0; j<MAPSIZE_X; j++)
    {
        w->t[i][j].flags &= ~TFLAG_LIT;
    }
}
//}}}

---