#define CHUNK_SIZE_NONE -1 /* do not write chunk size */
#define FILE_VERS_CHUNK_SIZE 8 /* size of file version chunk */
#define LEVEL_HEADER_SIZE 80 /* size of level file header */
-#define LEVEL_HEADER_UNUSED 1 /* unused level header bytes */
+#define LEVEL_HEADER_UNUSED 0 /* unused level header bytes */
#define LEVEL_CHUNK_CNT2_SIZE 160 /* size of level CNT2 chunk */
#define LEVEL_CHUNK_CNT2_UNUSED 11 /* unused CNT2 chunk bytes */
#define LEVEL_CHUNK_CNT3_HEADER 16 /* size of level CNT3 header */
#define TAPE_COOKIE_TMPL "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
#define SCORE_COOKIE "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
-/* values for level file type identifier */
-#define LEVEL_FILE_TYPE_UNKNOWN 0
-#define LEVEL_FILE_TYPE_RND 1
-#define LEVEL_FILE_TYPE_BD 2
-#define LEVEL_FILE_TYPE_EM 3
-#define LEVEL_FILE_TYPE_SP 4
-#define LEVEL_FILE_TYPE_DX 5
-#define LEVEL_FILE_TYPE_SB 6
-#define LEVEL_FILE_TYPE_DC 7
-
-#define LEVEL_FILE_TYPE_RND_PACKED (10 + LEVEL_FILE_TYPE_RND)
-#define LEVEL_FILE_TYPE_EM_PACKED (10 + LEVEL_FILE_TYPE_EM)
-
-#define IS_SINGLE_LEVEL_FILE(x) (x < 10)
-#define IS_PACKED_LEVEL_FILE(x) (x > 10)
+static struct
+{
+ int filetype;
+ char *id;
+}
+filetype_id_list[] =
+{
+ { LEVEL_FILE_TYPE_RND, "RND" },
+ { LEVEL_FILE_TYPE_BD, "BD" },
+ { LEVEL_FILE_TYPE_EM, "EM" },
+ { LEVEL_FILE_TYPE_SP, "SP" },
+ { LEVEL_FILE_TYPE_DX, "DX" },
+ { LEVEL_FILE_TYPE_SB, "SB" },
+ { LEVEL_FILE_TYPE_DC, "DC" },
+ { -1, NULL },
+};
/* ========================================================================= */
static void setLevelInfoToDefaults(struct LevelInfo *level)
{
static boolean clipboard_elements_initialized = FALSE;
-
int i, j, x, y;
+ setLevelInfoToDefaults_EM();
+
+ level->native_em_level = &native_em_level;
+
+ level->game_engine_type = GAME_ENGINE_TYPE_RND;
+
level->file_version = FILE_VERSION_ACTUAL;
level->game_version = GAME_VERSION_ACTUAL;
level->double_speed = FALSE;
level->initial_gravity = FALSE;
level->em_slippery_gems = FALSE;
- level->block_last_field = FALSE;
- level->sp_block_last_field = TRUE;
level->instant_relocation = FALSE;
level->can_pass_to_walkable = FALSE;
level->grow_into_diggable = TRUE;
+ level->block_last_field = FALSE; /* EM does not block by default */
+ level->sp_block_last_field = TRUE; /* SP blocks the last field */
+ level->block_delay = 8; /* when blocking, block 8 frames */
+ level->sp_block_delay = 9; /* SP indeed blocks 9 frames, not 8 */
+
level->can_move_into_acid_bits = ~0; /* everything can move into acid */
- level->dont_collide_with_bits = ~0; /* always deadly when colliding */
+ level->dont_collide_with_bits = ~0; /* always deadly when colliding */
level->use_spring_bug = FALSE;
level->use_step_counter = FALSE;
+ /* values for the new EMC elements */
+ level->android_move_time = 10;
+ level->android_clone_time = 10;
+ level->ball_random = FALSE;
+ level->ball_state_initial = FALSE;
+ level->ball_time = 10;
+ level->lenses_score = 10;
+ level->magnify_score = 10;
+ level->slurp_score = 10;
+ level->lenses_time = 10;
+ level->magnify_time = 10;
+ level->wind_direction_initial = MV_NO_MOVING;
+ for (i = 0; i < NUM_MAGIC_BALL_CONTENTS; i++)
+ for (x = 0; x < 3; x++)
+ for (y = 0; y < 3; y++)
+ level->ball_content[i][x][y] = EL_EMPTY;
+ for (i = 0; i < 16; i++)
+ level->android_array[i] = FALSE;
+
level->use_custom_template = FALSE;
for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
element_info[element].use_gfx_element = FALSE;
element_info[element].gfx_element = EL_EMPTY_SPACE;
+
+ element_info[element].modified_settings = FALSE;
}
if (IS_CUSTOM_ELEMENT(element) ||
element_info[element].move_pattern = MV_ALL_DIRECTIONS;
element_info[element].move_direction_initial = MV_START_AUTOMATIC;
element_info[element].move_stepsize = TILEX / 8;
+
element_info[element].move_enter_element = EL_EMPTY_SPACE;
element_info[element].move_leave_element = EL_EMPTY_SPACE;
element_info[element].move_leave_type = LEAVE_TYPE_UNLIMITED;
element_info[element].slippery_type = SLIPPERY_ANY_RANDOM;
+ element_info[element].explosion_type = EXPLODES_3X3;
element_info[element].explosion_delay = 16;
element_info[element].ignition_delay = 8;
element_info[element].walk_to_action = 0;
element_info[element].smash_targets = 0;
element_info[element].deadliness = 0;
- element_info[element].consistency = 0;
element_info[element].can_explode_by_fire = FALSE;
element_info[element].can_explode_smashed = FALSE;
/* now set default properties */
SET_PROPERTY(element, EP_CAN_MOVE_INTO_ACID, TRUE);
-
- element_info[element].modified_settings = FALSE;
}
if (IS_GROUP_ELEMENT(element) ||
level->no_valid_file = FALSE;
+ level->changed = FALSE;
+
if (leveldir_current == NULL) /* only when dumping level */
return;
return LEVEL_FILE_TYPE_UNKNOWN;
}
-static char *getSingleLevelBasename(int nr, int type)
+static char *getSingleLevelBasename(int nr)
{
static char basename[MAX_FILENAME_LEN];
- char *level_filename = getStringCopy(leveldir_current->level_filename);
-
- if (level_filename == NULL)
- level_filename = getStringCat2("%03d.", LEVELFILE_EXTENSION);
-
- switch (type)
- {
- case LEVEL_FILE_TYPE_RND:
- if (nr < 0)
- sprintf(basename, "template.%s", LEVELFILE_EXTENSION);
- else
- sprintf(basename, "%03d.%s", nr, LEVELFILE_EXTENSION);
- break;
-
- case LEVEL_FILE_TYPE_EM:
- sprintf(basename, "%d", nr);
- break;
-
- case LEVEL_FILE_TYPE_UNKNOWN:
- default:
- sprintf(basename, level_filename, nr);
- break;
- }
- free(level_filename);
+ if (nr < 0)
+ sprintf(basename, "template.%s", LEVELFILE_EXTENSION);
+ else
+ sprintf(basename, "%03d.%s", nr, LEVELFILE_EXTENSION);
return basename;
}
return basename;
}
-static char *getSingleLevelFilename(int nr, int type)
+static char *getSingleLevelFilename(int nr)
{
- return getLevelFilenameFromBasename(getSingleLevelBasename(nr, type));
+ return getLevelFilenameFromBasename(getSingleLevelBasename(nr));
}
#if 0
char *getDefaultLevelFilename(int nr)
{
- return getSingleLevelFilename(nr, LEVEL_FILE_TYPE_RND);
+ return getSingleLevelFilename(nr);
}
+#if 0
static void setLevelFileInfo_SingleLevelFilename(struct LevelFileInfo *lfi,
int type)
{
lfi->basename = getSingleLevelBasename(lfi->nr, lfi->type);
lfi->filename = getLevelFilenameFromBasename(lfi->basename);
}
+#endif
+
+static void setLevelFileInfo_FormatLevelFilename(struct LevelFileInfo *lfi,
+ int type, char *format, ...)
+{
+ static char basename[MAX_FILENAME_LEN];
+ va_list ap;
+
+ va_start(ap, format);
+ vsprintf(basename, format, ap);
+ va_end(ap);
+
+ lfi->type = type;
+ lfi->packed = FALSE;
+ lfi->basename = basename;
+ lfi->filename = getLevelFilenameFromBasename(lfi->basename);
+}
static void setLevelFileInfo_PackedLevelFilename(struct LevelFileInfo *lfi,
int type)
lfi->filename = getLevelFilenameFromBasename(lfi->basename);
}
-static void determineLevelFileInfo_Filename(struct LevelFileInfo *lfi)
+static int getFiletypeFromID(char *filetype_id)
+{
+ char *filetype_id_lower;
+ int filetype = LEVEL_FILE_TYPE_UNKNOWN;
+ int i;
+
+ if (filetype_id == NULL)
+ return LEVEL_FILE_TYPE_UNKNOWN;
+
+ filetype_id_lower = getStringToLower(filetype_id);
+
+ for (i = 0; filetype_id_list[i].id != NULL; i++)
+ {
+ char *id_lower = getStringToLower(filetype_id_list[i].id);
+
+ if (strcmp(filetype_id_lower, id_lower) == 0)
+ filetype = filetype_id_list[i].filetype;
+
+ free(id_lower);
+
+ if (filetype != LEVEL_FILE_TYPE_UNKNOWN)
+ break;
+ }
+
+ free(filetype_id_lower);
+
+ return filetype;
+}
+
+#if 0
+static void OLD_determineLevelFileInfo_Filename(struct LevelFileInfo *lfi)
{
/* special case: level number is negative => check for level template file */
if (lfi->nr < 0)
if (leveldir_current->level_filename != NULL)
{
+ int filetype = getFiletypeFromID(leveldir_current->level_filetype);
+
/* check for file name/pattern specified in "levelinfo.conf" */
- setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
+ setLevelFileInfo_SingleLevelFilename(lfi, filetype);
+
if (fileExists(lfi->filename))
return;
}
/* no known level file found -- try to use default values */
setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
}
+#endif
+
+static void determineLevelFileInfo_Filename(struct LevelFileInfo *lfi)
+{
+ int nr = lfi->nr;
+
+ /* special case: level number is negative => check for level template file */
+ if (nr < 0)
+ {
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
+ "template.%s", LEVELFILE_EXTENSION);
+
+ /* no fallback if template file not existing */
+ return;
+ }
+
+ /* special case: check for file name/pattern specified in "levelinfo.conf" */
+ if (leveldir_current->level_filename != NULL)
+ {
+ int filetype = getFiletypeFromID(leveldir_current->level_filetype);
+
+ setLevelFileInfo_FormatLevelFilename(lfi, filetype,
+ leveldir_current->level_filename, nr);
+ if (fileExists(lfi->filename))
+ return;
+ }
+
+ /* check for native Rocks'n'Diamonds level file */
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
+ "%03d.%s", nr, LEVELFILE_EXTENSION);
+ if (fileExists(lfi->filename))
+ return;
+
+ /* check for Emerald Mine level file (V1) */
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "a%c%c",
+ 'a' + (nr / 10) % 26, '0' + nr % 10);
+ if (fileExists(lfi->filename))
+ return;
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "A%c%c",
+ 'A' + (nr / 10) % 26, '0' + nr % 10);
+ if (fileExists(lfi->filename))
+ return;
+
+ /* check for Emerald Mine level file (V2 to V5) */
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%d", nr);
+ if (fileExists(lfi->filename))
+ return;
+
+ /* check for Emerald Mine level file (V6 / single mode) */
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02ds", nr);
+ if (fileExists(lfi->filename))
+ return;
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dS", nr);
+ if (fileExists(lfi->filename))
+ return;
+
+ /* check for Emerald Mine level file (V6 / teamwork mode) */
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dt", nr);
+ if (fileExists(lfi->filename))
+ return;
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dT", nr);
+ if (fileExists(lfi->filename))
+ return;
+
+ /* check for various packed level file formats */
+ setLevelFileInfo_PackedLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
+ if (fileExists(lfi->filename))
+ return;
+
+ /* no known level file found -- use default values (and fail later) */
+ setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
+ "%03d.%s", nr, LEVELFILE_EXTENSION);
+}
static void determineLevelFileInfo_Filetype(struct LevelFileInfo *lfi)
{
lfi->type = getFileTypeFromBasename(lfi->basename);
}
+#if 1
+static void setLevelFileInfo(struct LevelFileInfo *level_file_info, int nr)
+{
+ /* always start with reliable default values */
+ setFileInfoToDefaults(level_file_info);
+
+ level_file_info->nr = nr; /* set requested level number */
+
+ determineLevelFileInfo_Filename(level_file_info);
+ determineLevelFileInfo_Filetype(level_file_info);
+}
+
+#else
+
static struct LevelFileInfo *getLevelFileInfo(int nr)
{
static struct LevelFileInfo level_file_info;
return &level_file_info;
}
-
+#endif
/* ------------------------------------------------------------------------- */
/* functions for loading R'n'D level */
level->can_pass_to_walkable = (getFile8Bit(file) == 1 ? TRUE : FALSE);
level->grow_into_diggable = (getFile8Bit(file) == 1 ? TRUE : FALSE);
+ level->game_engine_type = getFile8Bit(file);
+
ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
return chunk_size;
ei->explosion_delay = getFile8Bit(file);
ei->ignition_delay = getFile8Bit(file);
+ ei->explosion_type = getFile8Bit(file);
/* some free bytes for future custom property values and padding */
- ReadUnusedBytesFromFile(file, 2);
+ ReadUnusedBytesFromFile(file, 1);
/* read change property values */
/* functions for loading EM level */
/* ------------------------------------------------------------------------- */
+#if 0
+
static int map_em_element_yam(int element)
{
switch (element)
#define EM_LEVEL_XSIZE 64
#define EM_LEVEL_YSIZE 32
-static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
- struct LevelFileInfo *level_file_info)
+static void OLD_LoadLevelFromFileInfo_EM(struct LevelInfo *level,
+ struct LevelFileInfo *level_file_info)
{
char *filename = level_file_info->filename;
FILE *file;
unsigned char leveldata[EM_LEVEL_SIZE];
unsigned char *header = &leveldata[EM_LEVEL_XSIZE * EM_LEVEL_YSIZE];
- unsigned char code0 = 0x65;
- unsigned char code1 = 0x11;
- boolean level_is_crypted = FALSE;
int nr = level_file_info->nr;
int i, x, y;
return;
}
- for(i = 0; i < EM_LEVEL_SIZE; i++)
+ for (i = 0; i < EM_LEVEL_SIZE; i++)
leveldata[i] = fgetc(file);
fclose(file);
if ((leveldata[0] == 0xf1 ||
leveldata[0] == 0xf5) && leveldata[2] == 0xe7 && leveldata[3] == 0xee)
{
- level_is_crypted = TRUE;
+ unsigned char code0 = 0x65;
+ unsigned char code1 = 0x11;
if (leveldata[0] == 0xf5) /* error in crypted Emerald Mine 2 levels */
leveldata[0] = 0xf1;
- }
- if (level_is_crypted) /* decode crypted level data */
- {
- for(i = 0; i < EM_LEVEL_SIZE; i++)
+ /* decode crypted level data */
+
+ for (i = 0; i < EM_LEVEL_SIZE; i++)
{
leveldata[i] ^= code0;
leveldata[i] -= code1;
- code0 = (code0 + 7) & 0xff;
+ code0 = (code0 + 7) & 0xff;
}
}
level->num_yamyam_contents = 4;
- for(i = 0; i < level->num_yamyam_contents; i++)
- for(y = 0; y < 3; y++)
- for(x = 0; x < 3; x++)
+ for (i = 0; i < level->num_yamyam_contents; i++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
level->yamyam_content[i][x][y] =
map_em_element_yam(header[i * 9 + y * 3 + x]);
level->field[x][y] = EL_PLAYER_2;
}
+#else
+
+void CopyNativeLevel_RND_to_EM(struct LevelInfo *level)
+{
+ static int ball_xy[8][2] =
+ {
+ { 0, 0 },
+ { 1, 0 },
+ { 2, 0 },
+ { 0, 1 },
+ { 2, 1 },
+ { 0, 2 },
+ { 1, 2 },
+ { 2, 2 },
+ };
+ struct LevelInfo_EM *level_em = level->native_em_level;
+ struct LEVEL *lev = level_em->lev;
+ struct PLAYER *ply1 = level_em->ply1;
+ struct PLAYER *ply2 = level_em->ply2;
+ int i, j, x, y;
+
+ lev->width = MIN(level->fieldx, EM_MAX_CAVE_WIDTH);
+ lev->height = MIN(level->fieldy, EM_MAX_CAVE_HEIGHT);
+
+ lev->time_seconds = level->time;
+ lev->required_initial = level->gems_needed;
+
+ lev->emerald_score = level->score[SC_EMERALD];
+ lev->diamond_score = level->score[SC_DIAMOND];
+ lev->alien_score = level->score[SC_ROBOT];
+ lev->tank_score = level->score[SC_SPACESHIP];
+ lev->bug_score = level->score[SC_BUG];
+ lev->eater_score = level->score[SC_YAMYAM];
+ lev->nut_score = level->score[SC_NUT];
+ lev->dynamite_score = level->score[SC_DYNAMITE];
+ lev->key_score = level->score[SC_KEY];
+ lev->exit_score = level->score[SC_TIME_BONUS];
+
+ for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ lev->eater_array[i][y * 3 + x] =
+ map_element_RND_to_EM(level->yamyam_content[i][x][y]);
+
+ lev->amoeba_time = level->amoeba_speed;
+ lev->wonderwall_time_initial = level->time_magic_wall;
+ lev->wheel_time = level->time_wheel;
+
+ lev->android_move_time = level->android_move_time;
+ lev->android_clone_time = level->android_clone_time;
+ lev->ball_random = level->ball_random;
+ lev->ball_state_initial = level->ball_state_initial;
+ lev->ball_time = level->ball_time;
+
+ lev->lenses_score = level->lenses_score;
+ lev->magnify_score = level->magnify_score;
+ lev->slurp_score = level->slurp_score;
+
+ lev->lenses_time = level->lenses_time;
+ lev->magnify_time = level->magnify_time;
+ lev->wind_direction_initial = level->wind_direction_initial;
+
+ for (i = 0; i < NUM_MAGIC_BALL_CONTENTS; i++)
+ for (j = 0; j < 8; j++)
+ lev->ball_array[i][j] =
+ map_element_RND_to_EM(level->
+ ball_content[i][ball_xy[j][0]][ball_xy[j][1]]);
+
+ for (i = 0; i < 16; i++)
+ lev->android_array[i] = FALSE; /* !!! YET TO COME !!! */
+
+ /* first fill the complete playfield with the default border element */
+ for (y = 0; y < EM_MAX_CAVE_HEIGHT; y++)
+ for (x = 0; x < EM_MAX_CAVE_WIDTH; x++)
+ level_em->cave[x][y] = ZBORDER;
+
+ /* then copy the real level contents from level file into the playfield */
+ for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
+ {
+ int new_element = map_element_RND_to_EM(level->field[x][y]);
+
+ if (level->field[x][y] == EL_AMOEBA_DEAD)
+ new_element = map_element_RND_to_EM(EL_AMOEBA_WET);
+
+ level_em->cave[x + 1][y + 1] = new_element;
+ }
+
+ ply1->x_initial = 0;
+ ply1->y_initial = 0;
+
+ ply2->x_initial = 0;
+ ply2->y_initial = 0;
+
+ /* initialize player positions and delete players from the playfield */
+ for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
+ {
+ if (level->field[x][y] == EL_PLAYER_1)
+ {
+ ply1->x_initial = x + 1;
+ ply1->y_initial = y + 1;
+ level_em->cave[x + 1][y + 1] = map_element_RND_to_EM(EL_EMPTY);
+ }
+ else if (level->field[x][y] == EL_PLAYER_2)
+ {
+ ply2->x_initial = x + 1;
+ ply2->y_initial = y + 1;
+ level_em->cave[x + 1][y + 1] = map_element_RND_to_EM(EL_EMPTY);
+ }
+ }
+}
+
+void CopyNativeLevel_EM_to_RND(struct LevelInfo *level)
+{
+ static int ball_xy[8][2] =
+ {
+ { 0, 0 },
+ { 1, 0 },
+ { 2, 0 },
+ { 0, 1 },
+ { 2, 1 },
+ { 0, 2 },
+ { 1, 2 },
+ { 2, 2 },
+ };
+ struct LevelInfo_EM *level_em = level->native_em_level;
+ struct LEVEL *lev = level_em->lev;
+ struct PLAYER *ply1 = level_em->ply1;
+ struct PLAYER *ply2 = level_em->ply2;
+ int i, j, x, y;
+
+ level->fieldx = MIN(lev->width, MAX_LEV_FIELDX);
+ level->fieldy = MIN(lev->height, MAX_LEV_FIELDY);
+
+ level->time = lev->time_seconds;
+ level->gems_needed = lev->required_initial;
+
+ sprintf(level->name, "Level %d", level->file_info.nr);
+
+ level->score[SC_EMERALD] = lev->emerald_score;
+ level->score[SC_DIAMOND] = lev->diamond_score;
+ level->score[SC_ROBOT] = lev->alien_score;
+ level->score[SC_SPACESHIP] = lev->tank_score;
+ level->score[SC_BUG] = lev->bug_score;
+ level->score[SC_YAMYAM] = lev->eater_score;
+ level->score[SC_NUT] = lev->nut_score;
+ level->score[SC_DYNAMITE] = lev->dynamite_score;
+ level->score[SC_KEY] = lev->key_score;
+ level->score[SC_TIME_BONUS] = lev->exit_score;
+
+ level->num_yamyam_contents = MAX_ELEMENT_CONTENTS;
+
+ for (i = 0; i < level->num_yamyam_contents; i++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ level->yamyam_content[i][x][y] =
+ map_element_EM_to_RND(lev->eater_array[i][y * 3 + x]);
+
+ level->amoeba_speed = lev->amoeba_time;
+ level->time_magic_wall = lev->wonderwall_time_initial;
+ level->time_wheel = lev->wheel_time;
+
+ level->android_move_time = lev->android_move_time;
+ level->android_clone_time = lev->android_clone_time;
+ level->ball_random = lev->ball_random;
+ level->ball_state_initial = lev->ball_state_initial;
+ level->ball_time = lev->ball_time;
+
+ level->lenses_score = lev->lenses_score;
+ level->magnify_score = lev->magnify_score;
+ level->slurp_score = lev->slurp_score;
+
+ level->lenses_time = lev->lenses_time;
+ level->magnify_time = lev->magnify_time;
+ level->wind_direction_initial = lev->wind_direction_initial;
+
+ for (i = 0; i < NUM_MAGIC_BALL_CONTENTS; i++)
+ for (j = 0; j < 8; j++)
+ level->ball_content[i][ball_xy[j][0]][ball_xy[j][1]] =
+ map_element_EM_to_RND(lev->ball_array[i][j]);
+
+ for (i = 0; i < 16; i++)
+ level->android_array[i] = FALSE; /* !!! YET TO COME !!! */
+
+ /* convert the playfield (some elements need special treatment) */
+ for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
+ {
+ int new_element = map_element_EM_to_RND(level_em->cave[x + 1][y + 1]);
+
+ if (new_element == EL_AMOEBA_WET && level->amoeba_speed == 0)
+ new_element = EL_AMOEBA_DEAD;
+
+ level->field[x][y] = new_element;
+ }
+
+ /* in case of both players set to the same field, use the first player */
+ level->field[ply2->x_initial - 1][ply2->y_initial - 1] = EL_PLAYER_2;
+ level->field[ply1->x_initial - 1][ply1->y_initial - 1] = EL_PLAYER_1;
+
+#if 0
+ printf("::: native Emerald Mine file version: %d\n", level_em->file_version);
+#endif
+}
+
+static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
+ struct LevelFileInfo *level_file_info)
+{
+ if (!LoadNativeLevel_EM(level_file_info->filename))
+ level->no_valid_file = TRUE;
+}
+
+#endif
+
+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 */
/* ------------------------------------------------------------------------- */
static void LoadLevelFromFileStream_SP(FILE *file, struct LevelInfo *level,
int nr)
{
+ int num_special_ports;
int i, x, y;
+ /* for details of the Supaplex level format, see Herman Perk's Supaplex
+ documentation file "SPFIX63.DOC" from his Supaplex "SpeedFix" package */
+
/* read level body (width * height == 60 * 24 tiles == 1440 bytes) */
for (y = 0; y < SP_LEVEL_YSIZE; y++)
{
}
}
- ReadUnusedBytesFromFile(file, 4);
+ ReadUnusedBytesFromFile(file, 4); /* (not used by Supaplex engine) */
- /* Initial gravitation: 1 == "on", anything else (0) == "off" */
+ /* initial gravity: 1 == "on", anything else (0) == "off" */
level->initial_gravity = (fgetc(file) == 1 ? TRUE : FALSE);
- ReadUnusedBytesFromFile(file, 1);
+ ReadUnusedBytesFromFile(file, 1); /* (not used by Supaplex engine) */
/* level title in uppercase letters, padded with dashes ("-") (23 bytes) */
for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
level->name[i] = fgetc(file);
level->name[SP_LEVEL_NAME_LEN] = '\0';
- /* initial "freeze zonks": 2 == "on", anything else (0) == "off" */
- ReadUnusedBytesFromFile(file, 1); /* !!! NOT SUPPORTED YET !!! */
+ /* initial "freeze zonks": 2 == "on", anything else (0, 1) == "off" */
+ ReadUnusedBytesFromFile(file, 1); /* (not used by R'n'D engine) */
/* number of infotrons needed; 0 means that Supaplex will count the total
- amount of infotrons in the level and use the low byte of that number.
+ amount of infotrons in the level and use the low byte of that number
(a multiple of 256 infotrons will result in "0 infotrons needed"!) */
level->gems_needed = fgetc(file);
- /* information about special gravity port entries */
- ReadUnusedBytesFromFile(file, 65); /* !!! NOT SUPPORTED YET !!! */
+ /* number of special ("gravity") port entries below (maximum 10 allowed) */
+ num_special_ports = fgetc(file);
+
+ /* database of properties of up to 10 special ports (6 bytes per port) */
+ for (i = 0; i < 10; i++)
+ {
+ int port_location, port_x, port_y, port_element;
+ int gravity;
+
+ /* high and low byte of the location of a special port; if (x, y) are the
+ coordinates of a port in the field and (0, 0) is the top-left corner,
+ the 16 bit value here calculates as 2 * (x + (y * 60)) (this is twice
+ of what may be expected: Supaplex works with a game field in memory
+ which is 2 bytes per tile) */
+ port_location = getFile16BitBE(file);
+
+ /* change gravity: 1 == "turn on", anything else (0) == "turn off" */
+ gravity = fgetc(file);
+
+ /* "freeze zonks": 2 == "turn on", anything else (0, 1) == "turn off" */
+ ReadUnusedBytesFromFile(file, 1); /* (not used by R'n'D engine) */
+
+ /* "freeze enemies": 1 == "turn on", anything else (0) == "turn off" */
+ ReadUnusedBytesFromFile(file, 1); /* (not used by R'n'D engine) */
+
+ ReadUnusedBytesFromFile(file, 1); /* (not used by Supaplex engine) */
+
+ if (i >= num_special_ports)
+ continue;
+
+ port_x = (port_location / 2) % SP_LEVEL_XSIZE;
+ port_y = (port_location / 2) / SP_LEVEL_XSIZE;
+
+ if (port_x < 0 || port_x >= SP_LEVEL_XSIZE ||
+ port_y < 0 || port_y >= SP_LEVEL_YSIZE)
+ {
+ 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;
+ }
+
+ ReadUnusedBytesFromFile(file, 4); /* (not used by Supaplex engine) */
+
+ /* change special gravity ports without database entries to normal ports */
+ for (y = 0; y < SP_LEVEL_YSIZE; y++)
+ for (x = 0; x < SP_LEVEL_XSIZE; x++)
+ 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;
+
+ /* auto-determine number of infotrons if it was stored as "0" -- see above */
+ if (level->gems_needed == 0)
+ {
+ for (y = 0; y < SP_LEVEL_YSIZE; y++)
+ for (x = 0; x < SP_LEVEL_XSIZE; x++)
+ if (level->field[x][y] == EL_SP_INFOTRON)
+ level->gems_needed++;
+
+ level->gems_needed &= 0xff; /* only use low byte -- see above */
+ }
level->fieldx = SP_LEVEL_XSIZE;
level->fieldy = SP_LEVEL_YSIZE;
level->time_wheel = 0;
level->amoeba_content = EL_EMPTY;
- for(i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
+ for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
level->score[i] = 0; /* !!! CORRECT THIS !!! */
/* there are no yamyams in supaplex levels */
- for(i = 0; i < level->num_yamyam_contents; i++)
- for(y = 0; y < 3; y++)
- for(x = 0; x < 3; x++)
+ for (i = 0; i < level->num_yamyam_contents; i++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
level->yamyam_content[i][x][y] = EL_EMPTY;
}
case LEVEL_FILE_TYPE_EM:
LoadLevelFromFileInfo_EM(level, level_file_info);
+ level->game_engine_type = GAME_ENGINE_TYPE_EM;
break;
case LEVEL_FILE_TYPE_SP:
LoadLevelFromFileInfo_RND(level, level_file_info);
break;
}
+
+ /* if level file is invalid, restore level structure to default values */
+ if (level->no_valid_file)
+ setLevelInfoToDefaults(level);
+
+ if (level->game_engine_type == GAME_ENGINE_TYPE_UNKNOWN)
+ level->game_engine_type = GAME_ENGINE_TYPE_RND;
+
+ if (level_file_info->type == LEVEL_FILE_TYPE_RND)
+ CopyNativeLevel_RND_to_Native(level);
+ else
+ CopyNativeLevel_Native_to_RND(level);
}
void LoadLevelFromFilename(struct LevelInfo *level, char *filename)
if (level->game_version == VERSION_IDENT(2,0,1,0))
level->em_slippery_gems = TRUE;
+ /* springs could be pushed over pits before (pre-release version) 2.2.0 */
if (level->game_version < VERSION_IDENT(2,2,0,0))
level->use_spring_bug = TRUE;
+ /* only few elements were able to actively move into acid before 3.1.0 */
if (level->game_version < VERSION_IDENT(3,1,0,0))
{
int i, j;
}
}
}
+
+#if 1 /* USE_NEW_BLOCK_STYLE */
+ /* blocking the last field when moving was corrected in version 3.1.1 */
+ if (level->game_version < VERSION_IDENT(3,1,1,0))
+ {
+#if 0
+ printf("::: %d\n", level->block_last_field);
+#endif
+
+ /* even "not blocking" was blocking the last field for one frame */
+ level->block_delay = (level->block_last_field ? 7 : 1);
+ level->sp_block_delay = (level->sp_block_last_field ? 7 : 1);
+
+ level->block_last_field = TRUE;
+ level->sp_block_last_field = TRUE;
+ }
+#endif
}
- else
+ else /* always use the latest game engine version */
{
#if 0
printf("\n::: ALWAYS USE LATEST ENGINE FOR THIS LEVEL: [%d] '%s'\n",
}
}
+ /* initialize "can_explode" field for old levels which did not store this */
+ /* !!! CHECK THIS -- "<= 3,1,0,0" IS PROBABLY WRONG !!! */
+ if (level->game_version <= VERSION_IDENT(3,1,0,0))
+ {
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ int element = EL_CUSTOM_START + i;
+
+ if (EXPLODES_1X1_OLD(element))
+ element_info[element].explosion_type = EXPLODES_1X1;
+
+ SET_PROPERTY(element, EP_CAN_EXPLODE, (EXPLODES_BY_FIRE(element) ||
+ EXPLODES_SMASHED(element) ||
+ EXPLODES_IMPACT(element)));
+ }
+ }
+
+ /* correct previously hard-coded move delay values for maze runner style */
+ if (level->game_version < VERSION_IDENT(3,1,1,0))
+ {
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ int element = EL_CUSTOM_START + i;
+
+ if (element_info[element].move_pattern & MV_MAZE_RUNNER_STYLE)
+ {
+ /* previously hard-coded and therefore ignored */
+ element_info[element].move_delay_fixed = 9;
+ element_info[element].move_delay_random = 0;
+ }
+ }
+ }
+
#if 0
/* set default push delay values (corrected since version 3.0.7-1) */
if (level->game_version < VERSION_IDENT(3,0,7,1))
void LoadLevelTemplate(int nr)
{
+#if 1
+ char *filename;
+
+ setLevelFileInfo(&level_template.file_info, nr);
+ filename = level_template.file_info.filename;
+
+ LoadLevelFromFileInfo(&level_template, &level_template.file_info);
+
+#else
+
#if 1
struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
char *filename = level_file_info->filename;
LoadLevelFromFilename_RND(&level_template, filename);
#endif
+#endif
+#if 1
+ LoadLevel_InitVersion(&level_template, filename);
+ LoadLevel_InitElements(&level_template, filename);
+#else
LoadLevel_InitVersion(&level, filename);
LoadLevel_InitElements(&level, filename);
+#endif
ActivateLevelTemplate();
}
void LoadLevel(int nr)
{
+#if 1
+ char *filename;
+
+ setLevelFileInfo(&level.file_info, nr);
+ filename = level.file_info.filename;
+
+ LoadLevelFromFileInfo(&level, &level.file_info);
+
+#else
+
#if 1
struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
char *filename = level_file_info->filename;
char *filename = getLevelFilename(nr);
LoadLevelFromFilename_RND(&level, filename);
+#endif
#endif
if (level.use_custom_template)
putFile8Bit(file, (level->can_pass_to_walkable ? 1 : 0));
putFile8Bit(file, (level->grow_into_diggable ? 1 : 0));
+ putFile8Bit(file, level->game_engine_type);
+
WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
}
putFile8Bit(file, ei->explosion_delay);
putFile8Bit(file, ei->ignition_delay);
+ putFile8Bit(file, ei->explosion_type);
/* some free bytes for future custom property values and padding */
- WriteUnusedBytesToFile(file, 2);
+ WriteUnusedBytesToFile(file, 1);
/* write change property values */
printf_line("-", 79);
printf("Tape of Level %03d (file version %08d, game version %08d)\n",
tape->level_nr, tape->file_version, tape->game_version);
+ printf(" (effective engine version %08d)\n",
+ tape->engine_version);
printf("Level series identifier: '%s'\n", tape->level_identifier);
printf_line("-", 79);
/* editor setup */
#define SETUP_TOKEN_EDITOR_EL_BOULDERDASH 0
#define SETUP_TOKEN_EDITOR_EL_EMERALD_MINE 1
-#define SETUP_TOKEN_EDITOR_EL_MORE 2
-#define SETUP_TOKEN_EDITOR_EL_SOKOBAN 3
-#define SETUP_TOKEN_EDITOR_EL_SUPAPLEX 4
-#define SETUP_TOKEN_EDITOR_EL_DIAMOND_CAVES 5
-#define SETUP_TOKEN_EDITOR_EL_DX_BOULDERDASH 6
-#define SETUP_TOKEN_EDITOR_EL_CHARS 7
-#define SETUP_TOKEN_EDITOR_EL_CUSTOM 8
-#define SETUP_TOKEN_EDITOR_EL_CUSTOM_MORE 9
-#define SETUP_TOKEN_EDITOR_EL_HEADLINES 10
-#define SETUP_TOKEN_EDITOR_EL_USER_DEFINED 11
-
-#define NUM_EDITOR_SETUP_TOKENS 12
+#define SETUP_TOKEN_EDITOR_EL_EMERALD_MINE_CLUB 2
+#define SETUP_TOKEN_EDITOR_EL_MORE 3
+#define SETUP_TOKEN_EDITOR_EL_SOKOBAN 4
+#define SETUP_TOKEN_EDITOR_EL_SUPAPLEX 5
+#define SETUP_TOKEN_EDITOR_EL_DIAMOND_CAVES 6
+#define SETUP_TOKEN_EDITOR_EL_DX_BOULDERDASH 7
+#define SETUP_TOKEN_EDITOR_EL_CHARS 8
+#define SETUP_TOKEN_EDITOR_EL_CUSTOM 9
+#define SETUP_TOKEN_EDITOR_EL_CUSTOM_MORE 10
+#define SETUP_TOKEN_EDITOR_EL_HEADLINES 11
+#define SETUP_TOKEN_EDITOR_EL_USER_DEFINED 12
+
+#define NUM_EDITOR_SETUP_TOKENS 13
/* shortcut setup */
#define SETUP_TOKEN_SHORTCUT_SAVE_GAME 0
{
{ TYPE_SWITCH, &sei.el_boulderdash, "editor.el_boulderdash" },
{ TYPE_SWITCH, &sei.el_emerald_mine, "editor.el_emerald_mine" },
+ { TYPE_SWITCH, &sei.el_emerald_mine_club,"editor.el_emerald_mine_club"},
{ TYPE_SWITCH, &sei.el_more, "editor.el_more" },
{ TYPE_SWITCH, &sei.el_sokoban, "editor.el_sokoban" },
{ TYPE_SWITCH, &sei.el_supaplex, "editor.el_supaplex" },
si->override_level_sounds = FALSE;
si->override_level_music = FALSE;
- si->editor.el_boulderdash = TRUE;
- si->editor.el_emerald_mine = TRUE;
- si->editor.el_more = TRUE;
- si->editor.el_sokoban = TRUE;
- si->editor.el_supaplex = TRUE;
- si->editor.el_diamond_caves = TRUE;
- si->editor.el_dx_boulderdash = TRUE;
- si->editor.el_chars = TRUE;
- si->editor.el_custom = TRUE;
- si->editor.el_custom_more = FALSE;
+ si->editor.el_boulderdash = TRUE;
+ si->editor.el_emerald_mine = TRUE;
+ si->editor.el_emerald_mine_club = TRUE;
+ si->editor.el_more = TRUE;
+ si->editor.el_sokoban = TRUE;
+ si->editor.el_supaplex = TRUE;
+ si->editor.el_diamond_caves = TRUE;
+ si->editor.el_dx_boulderdash = TRUE;
+ si->editor.el_chars = TRUE;
+ si->editor.el_custom = TRUE;
+ si->editor.el_custom_more = FALSE;
si->editor.el_headlines = TRUE;
si->editor.el_user_defined = FALSE;
END_HASH_ITERATION(hash, itr)
#endif
}
+
+
+/* ------------------------------------------------------------------------- *
+ * convert levels
+ * ------------------------------------------------------------------------- */
+
+#define MAX_NUM_CONVERT_LEVELS 1000
+
+void ConvertLevels()
+{
+ static LevelDirTree *convert_leveldir = NULL;
+ static int convert_level_nr = -1;
+ static int num_levels_handled = 0;
+ static int num_levels_converted = 0;
+ static boolean levels_failed[MAX_NUM_CONVERT_LEVELS];
+ int i;
+
+ convert_leveldir = getTreeInfoFromIdentifier(leveldir_first,
+ global.convert_leveldir);
+
+ if (convert_leveldir == NULL)
+ Error(ERR_EXIT, "no such level identifier: '%s'",
+ global.convert_leveldir);
+
+ leveldir_current = convert_leveldir;
+
+ if (global.convert_level_nr != -1)
+ {
+ convert_leveldir->first_level = global.convert_level_nr;
+ convert_leveldir->last_level = global.convert_level_nr;
+ }
+
+ convert_level_nr = convert_leveldir->first_level;
+
+ printf_line("=", 79);
+ printf("Converting levels\n");
+ printf_line("-", 79);
+ printf("Level series identifier: '%s'\n", convert_leveldir->identifier);
+ printf("Level series name: '%s'\n", convert_leveldir->name);
+ printf("Level series author: '%s'\n", convert_leveldir->author);
+ printf("Number of levels: %d\n", convert_leveldir->levels);
+ printf_line("=", 79);
+ printf("\n");
+
+ for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
+ levels_failed[i] = FALSE;
+
+ while (convert_level_nr <= convert_leveldir->last_level)
+ {
+ char *level_filename;
+ boolean new_level;
+
+ level_nr = convert_level_nr++;
+
+ printf("Level %03d: ", level_nr);
+
+ LoadLevel(level_nr);
+ if (level.no_valid_file)
+ {
+ printf("(no level)\n");
+ continue;
+ }
+
+ printf("converting level ... ");
+
+ level_filename = getDefaultLevelFilename(level_nr);
+ new_level = !fileExists(level_filename);
+
+ if (new_level)
+ {
+ SaveLevel(level_nr);
+
+ num_levels_converted++;
+
+ printf("converted.\n");
+ }
+ else
+ {
+ if (level_nr >= 0 && level_nr < MAX_NUM_CONVERT_LEVELS)
+ levels_failed[level_nr] = TRUE;
+
+ printf("NOT CONVERTED -- LEVEL ALREADY EXISTS.\n");
+ }
+
+ num_levels_handled++;
+ }
+
+ printf("\n");
+ printf_line("=", 79);
+ printf("Number of levels handled: %d\n", num_levels_handled);
+ printf("Number of levels converted: %d (%d%%)\n", num_levels_converted,
+ (num_levels_handled ?
+ num_levels_converted * 100 / num_levels_handled : 0));
+ printf_line("-", 79);
+ printf("Summary (for automatic parsing by scripts):\n");
+ printf("LEVELDIR '%s', CONVERTED %d/%d (%d%%)",
+ convert_leveldir->identifier, num_levels_converted,
+ num_levels_handled,
+ (num_levels_handled ?
+ num_levels_converted * 100 / num_levels_handled : 0));
+
+ if (num_levels_handled != num_levels_converted)
+ {
+ printf(", FAILED:");
+ for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
+ if (levels_failed[i])
+ printf(" %03d", i);
+ }
+
+ printf("\n");
+ printf_line("=", 79);
+
+ CloseAllAndExit(0);
+}
projects / rocksndiamonds.git / blobdiff