editor/file.c

Go to the documentation of this file.

#include "editor.h"

#define SET_NAME_MAXLEN 64

static char current_filename[64]="";
static char current_set_name[SET_NAME_MAXLEN]="Unnamed";

//{{{
void file_new(void)
{
    set_current_map(0);
    set_num_maps(1);
    default_map();
}
//}}}
//{{{
void file_open(void)
{
    char filename[64];
    dialog_read_string("Import what library?", filename, 30, 25, 100, 40);
    if(!load_kyelib(filename))
    {
        draw_current_map();
        show_dialog("File not found.", 25, 25, 70, 30);
    }
    strcpy(current_filename, filename);
}
//}}}
//{{{
void file_save(void)
{
    if(current_filename[0] == '\0')
        file_save_as();
    if(!save_skyelib_r2(current_filename))
    {
        draw_current_map();
        show_dialog("Error opening file.", 25, 25, 70, 30);
    }
}
//}}}
//{{{
void file_save_as(void)
{
    static char filename[64];
    unsigned short scratch;
    dialog_read_string("Save to what file?", filename, 30, 25, 100, 40);
    
    if(strlen(filename)<=0 ||
       ValidateSymName(filename)==FALSE ||
       CheckSysFunc(filename, &scratch))
    {
        draw_current_map();
        show_dialog("Invalid name!", 25, 25, 75, 20);
        return;
    }
    
    if(!save_skyelib_r2(filename))
    {
        draw_current_map();
        show_dialog("Error opening file.", 25, 25, 75, 20);
    }
    strcpy(current_filename, filename);
}
//}}}
//{{{
void file_exit(void)
{
    exit(0);
}
//}}}

//{{{
int load_kyelib(const char *filename)
{
    FILE *fin;
    int ret;
    file_header header;
    
    fin = fopen(filename, "rb");
    if(!fin) return 0;
    
    if(fread(&header, sizeof(file_header), 1, fin) < 1) {
        fclose(fin);
        return 0;
    }
    if( strncmp(header.magic_bytes, "SKye", 4) ) {
        fseek(fin, 0, SEEK_SET);
        ret = load_dckye_lib(fin);
    } else {
        ret = load_skye_lib(fin, &header);
    }
    fclose(fin);
    return ret;
}
//}}}

//{{{
int load_dckye_lib(FILE *fin)
{
    int ii=0;
    
    set_num_maps(1);
    set_current_map(0);
    
    do {
        if(load_dckye_level(fin, ii++))
            set_num_maps(num_maps + 1);
        else
            break;
    } while(1);
    
    set_num_maps(num_maps-1);
    return 1;
}
//}}}
//{{{
int load_skye_lib(FILE *fin, file_header *header)
{
    switch(header->revision) {
        case 1:
            return load_skye_lib_r1(fin, header);
        case 2:
            return load_skye_lib_r2(fin, header);
        default: // Unsupported version!
            return 0;
    }
}
//}}}
//{{{
int load_skye_lib_r1(FILE *fin, file_header *header)
{
    int ii;
    
    set_num_maps(header->num_levels);
    set_current_map(0);
    
    for(ii=0; ii<header->num_levels; ii++)
    {
        if( load_skye_level_r1(fin, ii)==0 )
        {
            // Error condition! (File too short)
            set_num_maps(max(ii,1));
            return 0;
        }
    }
    return 1;
}
//}}}
//{{{
int load_skye_level_r1(FILE *fin, int level)
{
    int ret;
    int xi, yi;
    map_r1 loaded_map;
    
    ret=fread(&loaded_map, sizeof(loaded_map), 1, fin);
    if(ret < 1)
        return 0;
    
    set_level_size(level, 20, 11);
    maps[level].gamerules = RULESET_DCKYE;
    strcpy(maps[level].name,    loaded_map.name);
    strcpy(maps[level].author,  loaded_map.author);
    strcpy(maps[level].hint,    "");
    strcpy(maps[level].congrat, "");
    
    for(yi=0; yi<11; yi++)
    for(xi=0; xi<20; xi++)
        maps[level].t[yi][xi] = loaded_map.t[yi][xi];
    
    return 1;
}
//}}}
//{{{
int load_skye_lib_r2(FILE *fin, file_header *header)
{
    unsigned short *map_offsets;
    int ii;
    
    map_offsets = alloca(header->num_levels * sizeof(*map_offsets));
    set_num_maps(header->num_levels);
    set_current_map(0);
    
    fread(map_offsets, sizeof(*map_offsets), header->num_levels, fin);
    freadstr(current_set_name, SET_NAME_MAXLEN, fin);
    
    for(ii=0; ii<header->num_levels; ii++)
    {
        if( fseek(fin, map_offsets[ii], SEEK_SET) != 0 ) // Seek failed!
        {
            set_num_maps(max(ii,1));
            return 0;
        }
        if( load_skye_level_r2(fin, ii)==0 )
        {
            // Error condition! (Probably, file too short)
            set_num_maps(max(ii,1));
            return 0;
        }
    }
    return 1;
}
//}}}
//{{{
int load_skye_level_r2(FILE *fin, int level)
{
    int ret;
    int ii;
    map_r2 loaded_map;
    
    ret=fread(&loaded_map, sizeof(loaded_map), 1, fin);
    if(ret < 1)
        return 0;
    
    set_level_size(level, loaded_map.width, loaded_map.height);
    freadstr(maps[level].name, 64, fin);
    freadstr(maps[level].author, 64, fin);
    freadstr(maps[level].hint, 64, fin);
    freadstr(maps[level].congrat, 64, fin);
    maps[level].gamerules = loaded_map.gamerules;
    for(ii=0; ii<loaded_map.height; ii++) {
        fread( maps[level].t[ii], sizeof(map_square), loaded_map.width, fin);
    }
    return 1;
}
//}}}

static const char file_extension[] = { 0, 'S', 'K', 'y', 'e', 0, 0xF8 };
//{{{
int load_dckye_level(FILE *fin, int level)
{
    int xi, yi;
    int ret;
    ret=fread(maps[level].t, sizeof(map_square), FIELD_WIDTH*FIELD_HEIGHT, fin);
    if(ret < FIELD_WIDTH*FIELD_HEIGHT)
        return 0;
    
    // Convert from kyelev format to internal format (collapse the 4-element
    // gap)
    for(yi=0; yi<FIELD_HEIGHT; yi++)
    for(xi=0; xi<FIELD_WIDTH; xi++)
    {
        if(maps[level].t[yi][xi] >= TILE_UNUSED)
            maps[level].t[yi][xi] -= 4;
    }
    
    // Fields not provided by kyelev format
    strcpy(maps[level].name, "kyelev");
    strcpy(maps[level].author, "");
    return 1;
}
//}}}

//{{{
int save_skyelib_r2(const char *filename)
{
    FILE *fout;
    int ii;
    unsigned short offset;
    file_header header;
    
    memcpy(header.magic_bytes, "SKye", 4);
    header.revision = 2;
    header.num_levels = num_maps;
    
    fout = fopen(filename, "wb");
    if(!fout) return 0;
    
    fwrite(&header, sizeof(file_header), 1, fout);
    for(ii=0; ii<num_maps*sizeof(unsigned short); ii++)
        fputc(0, fout);
//  fseek(fout, num_maps*sizeof(unsigned short), SEEK_CUR);
    fwritestr(current_set_name, fout);
    
    for(ii=0; ii<num_maps; ii++)
    {
        // Write offset into table
        offset = ftell(fout);
        fseek(fout, sizeof(file_header)+ii*sizeof(unsigned short), SEEK_SET);
        fwrite(&offset, sizeof(offset), 1, fout);
        fseek(fout, offset, SEEK_SET);
        write_skye_level_r2(fout, ii);
    }
    
    fseek(fout, 0, SEEK_END);
    fwrite(file_extension, 7, 1, fout);
    fclose(fout);
    return 1;
}
//}}}
//{{{
void write_skye_level_r2(FILE *fout, int level)
{
    int ii;
    map_r2 out;
    out.width = maps[level].width;
    out.height = maps[level].height;
    out.gamerules = maps[level].gamerules;
    memset(out.unused, 0, 5*sizeof(short));
    
    fwrite(&out, sizeof(out), 1, fout);
    fwritestr(maps[level].name, fout);
    fwritestr(maps[level].author, fout);
    fwritestr(maps[level].hint, fout);
    fwritestr(maps[level].congrat, fout);
    
    for(ii=0; ii<out.height; ii++)
        fwrite(maps[level].t[ii], sizeof(map_square), out.width, fout);
}
//}}}

---