X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ffiles.c;h=954fb3e4a0f4e4e322843bbc03b6d8c374cb0bbb;hb=3ceb03c19a3a327efa33bf98d494f9c9c6087d91;hp=239b85ec89a51863584162e5c2a7a9f840016854;hpb=5ba7f2d9a3f07f342afdf215a3307d5487cb6d43;p=rocksndiamonds.git diff --git a/src/files.c b/src/files.c index 239b85ec..954fb3e4 100644 --- a/src/files.c +++ b/src/files.c @@ -1587,8 +1587,10 @@ static void setLevelInfoToDefaults(struct LevelInfo *level) *level = li; /* copy temporary buffer back to level data */ setLevelInfoToDefaults_EM(); + setLevelInfoToDefaults_SP(); level->native_em_level = &native_em_level; + level->native_sp_level = &native_sp_level; level->file_version = FILE_VERSION_ACTUAL; level->game_version = GAME_VERSION_ACTUAL; @@ -1768,21 +1770,33 @@ static char *getLevelFilenameFromBasename(char *basename) static int getFileTypeFromBasename(char *basename) { + /* !!! ALSO SEE COMMENT IN checkForPackageFromBasename() !!! */ + static char *filename = NULL; struct stat file_status; /* ---------- try to determine file type from filename ---------- */ /* check for typical filename of a Supaplex level package file */ +#if 1 + if (strlen(basename) == 10 && strPrefixLower(basename, "levels.d")) + return LEVEL_FILE_TYPE_SP; +#else if (strlen(basename) == 10 && (strncmp(basename, "levels.d", 8) == 0 || strncmp(basename, "LEVELS.D", 8) == 0)) return LEVEL_FILE_TYPE_SP; +#endif /* check for typical filename of a Diamond Caves II level package file */ - if (strSuffix(basename, ".dc") || - strSuffix(basename, ".dc2")) + if (strSuffixLower(basename, ".dc") || + strSuffixLower(basename, ".dc2")) return LEVEL_FILE_TYPE_DC; + /* check for typical filename of a Sokoban level package file */ + if (strSuffixLower(basename, ".xsb") && + strchr(basename, '%') == NULL) + return LEVEL_FILE_TYPE_SB; + /* ---------- try to determine file type from filesize ---------- */ checked_free(filename); @@ -1798,6 +1812,14 @@ static int getFileTypeFromBasename(char *basename) return LEVEL_FILE_TYPE_UNKNOWN; } +static boolean checkForPackageFromBasename(char *basename) +{ + /* !!! WON'T WORK ANYMORE IF getFileTypeFromBasename() ALSO DETECTS !!! + !!! SINGLE LEVELS (CURRENTLY ONLY DETECTS LEVEL PACKAGES !!! */ + + return (getFileTypeFromBasename(basename) != LEVEL_FILE_TYPE_UNKNOWN); +} + static char *getSingleLevelBasename(int nr) { static char basename[MAX_FILENAME_LEN]; @@ -1951,6 +1973,9 @@ static void determineLevelFileInfo_Filename(struct LevelFileInfo *lfi) setLevelFileInfo_FormatLevelFilename(lfi, filetype, leveldir_current->level_filename, nr); + + lfi->packed = checkForPackageFromBasename(leveldir_current->level_filename); + if (fileExists(lfi->filename)) return; } @@ -3799,30 +3824,13 @@ void CopyNativeLevel_EM_to_RND(struct LevelInfo *level) } } -static void LoadLevelFromFileInfo_EM(struct LevelInfo *level, - struct LevelFileInfo *level_file_info) -{ - if (!LoadNativeLevel_EM(level_file_info->filename)) - level->no_valid_file = TRUE; -} - -void CopyNativeLevel_RND_to_Native(struct LevelInfo *level) -{ - if (level->game_engine_type == GAME_ENGINE_TYPE_EM) - CopyNativeLevel_RND_to_EM(level); -} - -void CopyNativeLevel_Native_to_RND(struct LevelInfo *level) -{ - if (level->game_engine_type == GAME_ENGINE_TYPE_EM) - CopyNativeLevel_EM_to_RND(level); -} - /* ------------------------------------------------------------------------- */ /* functions for loading SP level */ /* ------------------------------------------------------------------------- */ +#if 0 + #define NUM_SUPAPLEX_LEVELS_PER_PACKAGE 111 #define SP_LEVEL_SIZE 1536 #define SP_LEVEL_XSIZE 60 @@ -4013,7 +4021,8 @@ static void LoadLevelFromFileInfo_SP(struct LevelInfo *level, } /* position file stream to the requested level inside the level package */ - if (fseek(file, nr * SP_LEVEL_SIZE, SEEK_SET) != 0) + if (level_file_info->packed && + fseek(file, nr * SP_LEVEL_SIZE, SEEK_SET) != 0) { level->no_valid_file = TRUE; @@ -4167,6 +4176,187 @@ static void LoadLevelFromFileInfo_SP(struct LevelInfo *level, *level = multipart_level; } +#endif + +void CopyNativeLevel_RND_to_SP(struct LevelInfo *level) +{ + struct LevelInfo_SP *level_sp = level->native_sp_level; + LevelInfoType *header = &level_sp->header; + int i, x, y; + + level_sp->width = level->fieldx; + level_sp->height = level->fieldy; + + for (x = 0; x < level->fieldx; x++) + { + for (y = 0; y < level->fieldy; y++) + { + int element_old = level->field[x][y]; + int element_new; + + if (element_old >= EL_SP_START && + element_old <= EL_SP_END) + element_new = element_old - EL_SP_START; + else if (element_old == EL_EMPTY_SPACE) + element_new = 0x00; + else if (element_old == EL_INVISIBLE_WALL) + element_new = 0x28; + else + element_new = 0x20; /* map unknown elements to yellow "hardware" */ + + level_sp->playfield[x][y] = element_new; + } + } + + header->InitialGravity = (level->initial_player_gravity[0] ? 1 : 0); + + for (i = 0; i < SP_LEVEL_NAME_LEN; i++) + header->LevelTitle[i] = level->name[i]; + /* !!! NO STRING TERMINATION IN SUPAPLEX VB CODE YET -- FIX THIS !!! */ + + header->InfotronsNeeded = level->gems_needed; + + /* !!! ADD SPECIAL PORT DATABASE STUFF !!! */ +} + +void CopyNativeLevel_SP_to_RND(struct LevelInfo *level) +{ + struct LevelInfo_SP *level_sp = level->native_sp_level; + LevelInfoType *header = &level_sp->header; + int i, x, y; + + level->fieldx = level_sp->width; + level->fieldy = level_sp->height; + + for (x = 0; x < level->fieldx; x++) + { + for (y = 0; y < level->fieldy; y++) + { + int element_old = level_sp->playfield[x][y]; + int element_new; + + if (element_old <= 0x27) + element_new = getMappedElement(EL_SP_START + element_old); + else if (element_old == 0x28) + element_new = EL_INVISIBLE_WALL; + else + { + Error(ERR_WARN, "invalid element %d at position %d, %d", + element_old, x, y); + + element_new = EL_UNKNOWN; + } + + level->field[x][y] = element_new; + } + } + + for (i = 0; i < MAX_PLAYERS; i++) + level->initial_player_gravity[i] = + (header->InitialGravity == 1 ? TRUE : FALSE); + + for (i = 0; i < SP_LEVEL_NAME_LEN; i++) + level->name[i] = header->LevelTitle[i]; + level->name[SP_LEVEL_NAME_LEN] = '\0'; + + level->gems_needed = header->InfotronsNeeded; + + for (i = 0; i < header->SpecialPortCount; i++) + { + SpecialPortType *port = &header->SpecialPort[i]; + int port_location = port->PortLocation; + int gravity = port->Gravity; + int port_x, port_y, port_element; + + port_x = (port_location / 2) % level->fieldx; + port_y = (port_location / 2) / level->fieldx; + + if (port_x < 0 || port_x >= level->fieldx || + port_y < 0 || port_y >= level->fieldy) + { + Error(ERR_WARN, "special port position (%d, %d) out of bounds", + port_x, port_y); + + continue; + } + + port_element = level->field[port_x][port_y]; + + if (port_element < EL_SP_GRAVITY_PORT_RIGHT || + port_element > EL_SP_GRAVITY_PORT_UP) + { + Error(ERR_WARN, "no special port at position (%d, %d)", port_x, port_y); + + continue; + } + + /* change previous (wrong) gravity inverting special port to either + gravity enabling special port or gravity disabling special port */ + level->field[port_x][port_y] += + (gravity == 1 ? EL_SP_GRAVITY_ON_PORT_RIGHT : + EL_SP_GRAVITY_OFF_PORT_RIGHT) - EL_SP_GRAVITY_PORT_RIGHT; + } + + /* change special gravity ports without database entries to normal ports */ + for (x = 0; x < level->fieldx; x++) + for (y = 0; y < level->fieldy; y++) + if (level->field[x][y] >= EL_SP_GRAVITY_PORT_RIGHT && + level->field[x][y] <= EL_SP_GRAVITY_PORT_UP) + level->field[x][y] += EL_SP_PORT_RIGHT - EL_SP_GRAVITY_PORT_RIGHT; + + level->time = 0; /* no time limit */ + level->amoeba_speed = 0; + level->time_magic_wall = 0; + level->time_wheel = 0; + level->amoeba_content = EL_EMPTY; + +#if 1 + /* original Supaplex does not use score values -- use default values */ +#else + for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++) + level->score[i] = 0; +#endif + + /* there are no yamyams in supaplex levels */ + for (i = 0; i < level->num_yamyam_contents; i++) + for (x = 0; x < 3; x++) + for (y = 0; y < 3; y++) + level->yamyam_content[i].e[x][y] = EL_EMPTY; +} + +static void setTapeInfoToDefaults(); + +static void CopyNativeTape_SP_to_RND(struct LevelInfo *level) +{ + struct LevelInfo_SP *level_sp = level->native_sp_level; + struct DemoInfo_SP *demo = &level_sp->demo; + int i; + + /* always start with reliable default values */ + setTapeInfoToDefaults(); + + tape.level_nr = demo->level_nr; /* (currently not used) */ + tape.length = demo->length - 1; /* without "end of demo" byte */ + tape.random_seed = level_sp->header.DemoRandomSeed; + + // tape.date = + + for (i = 0; i < demo->length - 1; i++) + { + int demo_action = demo->data[i] & 0x0f; + int demo_repeat = (demo->data[i] & 0xf0) >> 4; + + tape.pos[i].action[0] = map_key_SP_to_RND(demo_action); + tape.pos[i].delay = demo_repeat + 1; + } + + tape.length_seconds = GetTapeLength(); +} + + +/* ------------------------------------------------------------------------- */ +/* functions for loading DC level */ +/* ------------------------------------------------------------------------- */ #define DC_LEVEL_HEADER_SIZE 344 @@ -6137,6 +6327,328 @@ static void LoadLevelFromFileInfo_DC(struct LevelInfo *level, #endif +/* ------------------------------------------------------------------------- */ +/* functions for loading SB level */ +/* ------------------------------------------------------------------------- */ + +static void LoadLevelFromFileInfo_SB(struct LevelInfo *level, + struct LevelFileInfo *level_file_info) +{ + char *filename = level_file_info->filename; + char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN]; + char last_comment[MAX_LINE_LEN]; + char level_name[MAX_LINE_LEN]; + char *line_ptr; + FILE *file; + int num_levels_to_skip = level_file_info->nr - leveldir_current->first_level; + boolean read_continued_line = FALSE; + boolean reading_playfield = FALSE; + boolean got_valid_playfield_line = FALSE; + boolean invalid_playfield_char = FALSE; + int file_level_nr = 0; + int line_nr = 0; + int x, y; + + if (!(file = fopen(filename, MODE_READ))) + { + level->no_valid_file = TRUE; + + Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename); + + return; + } + +#if 0 + printf("::: looking for level number %d [%d]\n", + level_file_info->nr, num_levels_to_skip); +#endif + + last_comment[0] = '\0'; + level_name[0] = '\0'; + + while (!feof(file)) + { + /* level successfully read, but next level may follow here */ + if (!got_valid_playfield_line && reading_playfield) + { +#if 0 + printf("::: read complete playfield\n"); +#endif + + /* read playfield from single level file -- skip remaining file */ + if (!level_file_info->packed) + break; + + if (file_level_nr >= num_levels_to_skip) + break; + + file_level_nr++; + + last_comment[0] = '\0'; + level_name[0] = '\0'; + + reading_playfield = FALSE; + } + + got_valid_playfield_line = FALSE; + + /* read next line of input file */ + if (!fgets(line, MAX_LINE_LEN, file)) + break; + + /* check if line was completely read and is terminated by line break */ + if (strlen(line) > 0 && line[strlen(line) - 1] == '\n') + line_nr++; + + /* cut trailing line break (this can be newline and/or carriage return) */ + for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--) + if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0') + *line_ptr = '\0'; + + /* copy raw input line for later use (mainly debugging output) */ + strcpy(line_raw, line); + + if (read_continued_line) + { + /* append new line to existing line, if there is enough space */ + if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN) + strcat(previous_line, line_ptr); + + strcpy(line, previous_line); /* copy storage buffer to line */ + + read_continued_line = FALSE; + } + + /* if the last character is '\', continue at next line */ + if (strlen(line) > 0 && line[strlen(line) - 1] == '\\') + { + line[strlen(line) - 1] = '\0'; /* cut off trailing backslash */ + strcpy(previous_line, line); /* copy line to storage buffer */ + + read_continued_line = TRUE; + + continue; + } + + /* skip empty lines */ + if (line[0] == '\0') + continue; + + /* extract comment text from comment line */ + if (line[0] == ';') + { + for (line_ptr = line; *line_ptr; line_ptr++) + if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != ';') + break; + + strcpy(last_comment, line_ptr); + +#if 0 + printf("::: found comment '%s' in line %d\n", last_comment, line_nr); +#endif + + continue; + } + + /* extract level title text from line containing level title */ + if (line[0] == '\'') + { + strcpy(level_name, &line[1]); + + if (strlen(level_name) > 0 && level_name[strlen(level_name) - 1] == '\'') + level_name[strlen(level_name) - 1] = '\0'; + +#if 0 + printf("::: found level name '%s' in line %d\n", level_name, line_nr); +#endif + + continue; + } + + /* skip lines containing only spaces (or empty lines) */ + for (line_ptr = line; *line_ptr; line_ptr++) + if (*line_ptr != ' ') + break; + if (*line_ptr == '\0') + continue; + + /* at this point, we have found a line containing part of a playfield */ + +#if 0 + printf("::: found playfield row in line %d\n", line_nr); +#endif + + got_valid_playfield_line = TRUE; + + if (!reading_playfield) + { + reading_playfield = TRUE; + invalid_playfield_char = FALSE; + + for (x = 0; x < MAX_LEV_FIELDX; x++) + for (y = 0; y < MAX_LEV_FIELDY; y++) + level->field[x][y] = EL_EMPTY; + + level->fieldx = 0; + level->fieldy = 0; + + /* start with topmost tile row */ + y = 0; + } + + /* skip playfield line if larger row than allowed */ + if (y >= MAX_LEV_FIELDY) + continue; + + /* start with leftmost tile column */ + x = 0; + + /* read playfield elements from line */ + for (line_ptr = line; *line_ptr; line_ptr++) + { + /* stop parsing playfield line if larger column than allowed */ + if (x >= MAX_LEV_FIELDX) + break; + + switch (*line_ptr) + { + case '#': /* wall */ + level->field[x][y] = EL_STEELWALL; + break; + + case '@': /* player */ + level->field[x][y] = EL_PLAYER_1; + break; + + case '+': /* player on goal square */ + level->field[x][y] = EL_SOKOBAN_FIELD_PLAYER; + break; + + case '$': /* box */ + level->field[x][y] = EL_SOKOBAN_OBJECT; + break; + + case '*': /* box on goal square */ + level->field[x][y] = EL_SOKOBAN_FIELD_FULL; + break; + + case '.': /* goal square */ + level->field[x][y] = EL_SOKOBAN_FIELD_EMPTY; + break; + + case ' ': /* floor (space) */ + level->field[x][y] = EL_EMPTY; + break; + + default: + invalid_playfield_char = TRUE; + break; + } + + if (invalid_playfield_char) + break; + + /* continue with next tile column */ + x++; + + level->fieldx = MAX(x, level->fieldx); + } + + if (invalid_playfield_char) + { + /* if first playfield line, treat invalid lines as comment lines */ + if (y == 0) + reading_playfield = FALSE; + + continue; + } + + /* continue with next tile row */ + y++; + } + + level->fieldy = y; + + level->fieldx = MIN(MAX(MIN_LEV_FIELDX, level->fieldx), MAX_LEV_FIELDX); + level->fieldy = MIN(MAX(MIN_LEV_FIELDY, level->fieldy), MAX_LEV_FIELDY); + + fclose(file); + + if (!reading_playfield) + { + level->no_valid_file = TRUE; + + Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename); + + return; + } + + if (*level_name != '\0') + { + strncpy(level->name, level_name, MAX_LEVEL_NAME_LEN); + level->name[MAX_LEVEL_NAME_LEN] = '\0'; + +#if 0 + printf(":1: level name: '%s'\n", level->name); +#endif + } + else if (*last_comment != '\0') + { + strncpy(level->name, last_comment, MAX_LEVEL_NAME_LEN); + level->name[MAX_LEVEL_NAME_LEN] = '\0'; + +#if 0 + printf(":2: level name: '%s'\n", level->name); +#endif + } + else + { + sprintf(level->name, "--> Level %d <--", level_file_info->nr); + } +} + + +/* ------------------------------------------------------------------------- */ +/* functions for handling native levels */ +/* ------------------------------------------------------------------------- */ + +static void LoadLevelFromFileInfo_EM(struct LevelInfo *level, + struct LevelFileInfo *level_file_info) +{ + if (!LoadNativeLevel_EM(level_file_info->filename)) + level->no_valid_file = TRUE; +} + +static void LoadLevelFromFileInfo_SP(struct LevelInfo *level, + struct LevelFileInfo *level_file_info) +{ + int pos = 0; + + /* determine position of requested level inside level package */ + if (level_file_info->packed) + pos = level_file_info->nr - leveldir_current->first_level; + + if (!LoadNativeLevel_SP(level_file_info->filename, pos)) + level->no_valid_file = TRUE; +} + +void CopyNativeLevel_RND_to_Native(struct LevelInfo *level) +{ + if (level->game_engine_type == GAME_ENGINE_TYPE_EM) + CopyNativeLevel_RND_to_EM(level); + else if (level->game_engine_type == GAME_ENGINE_TYPE_SP) + CopyNativeLevel_RND_to_SP(level); +} + +void CopyNativeLevel_Native_to_RND(struct LevelInfo *level) +{ + if (level->game_engine_type == GAME_ENGINE_TYPE_EM) + CopyNativeLevel_EM_to_RND(level); + else if (level->game_engine_type == GAME_ENGINE_TYPE_SP) + CopyNativeLevel_SP_to_RND(level); +} + + /* ------------------------------------------------------------------------- */ /* functions for loading generic level */ /* ------------------------------------------------------------------------- */ @@ -6160,15 +6672,17 @@ void LoadLevelFromFileInfo(struct LevelInfo *level, case LEVEL_FILE_TYPE_SP: LoadLevelFromFileInfo_SP(level, level_file_info); -#if 1 level->game_engine_type = GAME_ENGINE_TYPE_SP; -#endif break; case LEVEL_FILE_TYPE_DC: LoadLevelFromFileInfo_DC(level, level_file_info); break; + case LEVEL_FILE_TYPE_SB: + LoadLevelFromFileInfo_SB(level, level_file_info); + break; + default: LoadLevelFromFileInfo_RND(level, level_file_info); break; @@ -6563,7 +7077,8 @@ static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename) lev_fieldy = level->fieldy; /* determine border element for this level */ - if (level->file_info.type == LEVEL_FILE_TYPE_DC) + if (level->file_info.type == LEVEL_FILE_TYPE_DC || + level->file_info.type == LEVEL_FILE_TYPE_SB) BorderElement = EL_EMPTY; /* (in editor, SetBorderElement() is used) */ else SetBorderElement(); @@ -7841,6 +8356,13 @@ void LoadSolutionTape(int nr) char *filename = getSolutionTapeFilename(nr); LoadTapeFromFilename(filename); + +#if 1 + if (TAPE_IS_EMPTY(tape) && + level.game_engine_type == GAME_ENGINE_TYPE_SP && + level.native_sp_level->demo.is_available) + CopyNativeTape_SP_to_RND(&level); +#endif } static void SaveTape_VERS(FILE *file, struct TapeInfo *tape)