+#endif
+
+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].e[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->num_ball_arrays = level->num_ball_contents;
+
+ 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 =
+ map_direction_RND_to_EM(level->wind_direction_initial);
+ lev->wind_cnt_initial = (level->wind_direction_initial != MV_NONE ?
+ lev->wind_time : 0);
+
+ for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
+ for (j = 0; j < 8; j++)
+ lev->ball_array[i][j] =
+ map_element_RND_to_EM(level->
+ ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]);
+
+ map_android_clone_elements_RND_to_EM(level);
+
+#if 0
+ for (i = 0; i < 16; i++)
+ lev->android_array[i] = FALSE; /* !!! YET TO COME !!! */
+#endif
+
+ /* 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 1
+ /* !!! CURRENTLY ONLY SUPPORT FOR ONE PLAYER !!! */
+ if (ELEM_IS_PLAYER(level->field[x][y]))
+ {
+ 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
+ /* !!! ADD SUPPORT FOR MORE THAN ONE PLAYER !!! */
+ 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);
+ }
+#endif
+ }
+}
+
+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].e[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->num_ball_contents = lev->num_ball_arrays;
+
+ 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 =
+ map_direction_EM_to_RND(lev->wind_direction_initial);
+
+ for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
+ for (j = 0; j < 8; j++)
+ level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]] =
+ map_element_EM_to_RND(lev->ball_array[i][j]);
+
+ map_android_clone_elements_EM_to_RND(level);
+
+#if 0
+ for (i = 0; i < 16; i++)
+ level->android_array[i] = FALSE; /* !!! YET TO COME !!! */
+#endif
+
+ /* 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;
+}
+
+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 */
+/* ------------------------------------------------------------------------- */
+
+#define NUM_SUPAPLEX_LEVELS_PER_PACKAGE 111
+#define SP_LEVEL_SIZE 1536
+#define SP_LEVEL_XSIZE 60
+#define SP_LEVEL_YSIZE 24
+#define SP_LEVEL_NAME_LEN 23
+
+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++)
+ {
+ for (x = 0; x < SP_LEVEL_XSIZE; x++)
+ {
+ int element_old = fgetc(file);
+ 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, "in level %d, at position %d, %d:", nr, x, y);
+ Error(ERR_WARN, "invalid level element %d", element_old);
+
+ element_new = EL_UNKNOWN;
+ }
+
+ level->field[x][y] = element_new;
+ }
+ }
+
+ ReadUnusedBytesFromFile(file, 4); /* (not used by Supaplex engine) */
+
+ /* initial gravity: 1 == "on", anything else (0) == "off" */
+ level->initial_gravity = (fgetc(file) == 1 ? TRUE : FALSE);
+
+ 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, 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
+ (a multiple of 256 infotrons will result in "0 infotrons needed"!) */
+ level->gems_needed = fgetc(file);
+
+ /* 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 = 0; /* no time limit */
+ level->amoeba_speed = 0;
+ level->time_magic_wall = 0;
+ level->time_wheel = 0;
+ level->amoeba_content = EL_EMPTY;
+
+ 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++)
+ level->yamyam_content[i].e[x][y] = EL_EMPTY;
+}
+
+static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
+ struct LevelFileInfo *level_file_info)
+{
+ char *filename = level_file_info->filename;
+ FILE *file;
+ int nr = level_file_info->nr - leveldir_current->first_level;
+ int i, l, x, y;
+ char name_first, name_last;
+ struct LevelInfo multipart_level;
+ int multipart_xpos, multipart_ypos;
+ boolean is_multipart_level;
+ boolean is_first_part;
+ boolean reading_multipart_level = FALSE;
+ boolean use_empty_level = FALSE;
+
+ if (!(file = fopen(filename, MODE_READ)))
+ {
+ level->no_valid_file = TRUE;
+
+ Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
+
+ return;
+ }
+
+ /* position file stream to the requested level inside the level package */
+ if (fseek(file, nr * SP_LEVEL_SIZE, SEEK_SET) != 0)
+ {
+ level->no_valid_file = TRUE;
+
+ Error(ERR_WARN, "cannot fseek level '%s' -- using empty level", filename);
+
+ return;
+ }
+
+ /* there exist Supaplex level package files with multi-part levels which
+ can be detected as follows: instead of leading and trailing dashes ('-')
+ to pad the level name, they have leading and trailing numbers which are
+ the x and y coordinations of the current part of the multi-part level;
+ if there are '?' characters instead of numbers on the left or right side
+ of the level name, the multi-part level consists of only horizontal or
+ vertical parts */
+
+ for (l = nr; l < NUM_SUPAPLEX_LEVELS_PER_PACKAGE; l++)
+ {
+ LoadLevelFromFileStream_SP(file, level, l);
+
+ /* check if this level is a part of a bigger multi-part level */
+
+ name_first = level->name[0];
+ name_last = level->name[SP_LEVEL_NAME_LEN - 1];
+
+ is_multipart_level =
+ ((name_first == '?' || (name_first >= '0' && name_first <= '9')) &&
+ (name_last == '?' || (name_last >= '0' && name_last <= '9')));
+
+ is_first_part =
+ ((name_first == '?' || name_first == '1') &&
+ (name_last == '?' || name_last == '1'));
+
+ /* correct leading multipart level meta information in level name */
+ for (i = 0; i < SP_LEVEL_NAME_LEN && level->name[i] == name_first; i++)
+ level->name[i] = '-';
+
+ /* correct trailing multipart level meta information in level name */
+ for (i = SP_LEVEL_NAME_LEN - 1; i>=0 && level->name[i] == name_last; i--)
+ level->name[i] = '-';
+
+ /* ---------- check for normal single level ---------- */
+
+ if (!reading_multipart_level && !is_multipart_level)
+ {
+ /* the current level is simply a normal single-part level, and we are
+ not reading a multi-part level yet, so return the level as it is */
+
+ break;
+ }
+
+ /* ---------- check for empty level (unused multi-part) ---------- */
+
+ if (!reading_multipart_level && is_multipart_level && !is_first_part)
+ {
+ /* this is a part of a multi-part level, but not the first part
+ (and we are not already reading parts of a multi-part level);
+ in this case, use an empty level instead of the single part */
+
+ use_empty_level = TRUE;
+
+ break;
+ }
+
+ /* ---------- check for finished multi-part level ---------- */
+
+ if (reading_multipart_level &&
+ (!is_multipart_level ||
+ strcmp(level->name, multipart_level.name) != 0))
+ {
+ /* we are already reading parts of a multi-part level, but this level is
+ either not a multi-part level, or a part of a different multi-part
+ level; in both cases, the multi-part level seems to be complete */
+
+ break;
+ }
+
+ /* ---------- here we have one part of a multi-part level ---------- */
+
+ reading_multipart_level = TRUE;
+
+ if (is_first_part) /* start with first part of new multi-part level */
+ {
+ /* copy level info structure from first part */
+ multipart_level = *level;
+
+ /* clear playfield of new multi-part level */
+ for (y = 0; y < MAX_LEV_FIELDY; y++)
+ for (x = 0; x < MAX_LEV_FIELDX; x++)
+ multipart_level.field[x][y] = EL_EMPTY;
+ }
+
+ if (name_first == '?')
+ name_first = '1';
+ if (name_last == '?')
+ name_last = '1';
+
+ multipart_xpos = (int)(name_first - '0');
+ multipart_ypos = (int)(name_last - '0');
+
+#if 0
+ printf("----------> part (%d/%d) of multi-part level '%s'\n",
+ multipart_xpos, multipart_ypos, multipart_level.name);
+#endif
+
+ if (multipart_xpos * SP_LEVEL_XSIZE > MAX_LEV_FIELDX ||
+ multipart_ypos * SP_LEVEL_YSIZE > MAX_LEV_FIELDY)
+ {
+ Error(ERR_WARN, "multi-part level is too big -- ignoring part of it");
+
+ break;
+ }
+
+ multipart_level.fieldx = MAX(multipart_level.fieldx,
+ multipart_xpos * SP_LEVEL_XSIZE);
+ multipart_level.fieldy = MAX(multipart_level.fieldy,
+ multipart_ypos * SP_LEVEL_YSIZE);
+
+ /* copy level part at the right position of multi-part level */
+ for (y = 0; y < SP_LEVEL_YSIZE; y++)
+ {
+ for (x = 0; x < SP_LEVEL_XSIZE; x++)
+ {
+ int start_x = (multipart_xpos - 1) * SP_LEVEL_XSIZE;
+ int start_y = (multipart_ypos - 1) * SP_LEVEL_YSIZE;
+
+ multipart_level.field[start_x + x][start_y + y] = level->field[x][y];
+ }
+ }
+ }
+
+ fclose(file);
+
+ if (use_empty_level)
+ {
+ setLevelInfoToDefaults(level);
+
+ level->fieldx = SP_LEVEL_XSIZE;
+ level->fieldy = SP_LEVEL_YSIZE;
+
+ for (y = 0; y < SP_LEVEL_YSIZE; y++)
+ for (x = 0; x < SP_LEVEL_XSIZE; x++)
+ level->field[x][y] = EL_EMPTY;
+
+ strcpy(level->name, "-------- EMPTY --------");
+
+ Error(ERR_WARN, "single part of multi-part level -- using empty level");
+ }
+
+ if (reading_multipart_level)
+ *level = multipart_level;
+}
+
+/* ------------------------------------------------------------------------- */
+/* functions for loading generic level */
+/* ------------------------------------------------------------------------- */
+