#define TAPE_COOKIE_TMPL "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
#define SCORE_COOKIE "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
+/* values for "CONF" chunk */
+#define CONF_MASK_1_BYTE 0x00
+#define CONF_MASK_2_BYTE 0x40
+#define CONF_MASK_4_BYTE 0x80
+#define CONF_MASK_MULTI_BYTES 0xc0
+
+#define CONF_MASK_BYTES 0xc0
+#define CONF_MASK_TOKEN 0x3f
+
+#define CONF_LAST_ENTRY (CONF_MASK_1_BYTE | 0)
+
+#define CONF_VALUE_SCORE_1 (CONF_MASK_1_BYTE | 1)
+#define CONF_VALUE_SCORE_2 (CONF_MASK_1_BYTE | 2)
+#define CONF_VALUE_SCORE_3 (CONF_MASK_1_BYTE | 3)
+#define CONF_VALUE_SCORE_4 (CONF_MASK_1_BYTE | 4)
+#define CONF_VALUE_TIME_1 (CONF_MASK_1_BYTE | 5)
+#define CONF_VALUE_TIME_2 (CONF_MASK_1_BYTE | 6)
+#define CONF_VALUE_TIME_3 (CONF_MASK_1_BYTE | 7)
+#define CONF_VALUE_TIME_4 (CONF_MASK_1_BYTE | 8)
+#define CONF_VALUE_SWITCH_1 (CONF_MASK_1_BYTE | 9)
+#define CONF_VALUE_SWITCH_2 (CONF_MASK_1_BYTE | 10)
+#define CONF_VALUE_SWITCH_3 (CONF_MASK_1_BYTE | 11)
+#define CONF_VALUE_SWITCH_4 (CONF_MASK_1_BYTE | 12)
+#define CONF_VALUE_USE_BUG_1 (CONF_MASK_1_BYTE | 13)
+#define CONF_VALUE_USE_BUG_2 (CONF_MASK_1_BYTE | 14)
+#define CONF_VALUE_USE_BUG_3 (CONF_MASK_1_BYTE | 15)
+#define CONF_VALUE_USE_BUG_4 (CONF_MASK_1_BYTE | 16)
+
+#define CONF_VALUE_ELEMENT_1 (CONF_MASK_2_BYTE | 1)
+#define CONF_VALUE_ELEMENT_2 (CONF_MASK_2_BYTE | 2)
+
+#define CONF_VALUE_CONTENT_1 (CONF_MASK_MULTI_BYTES | 1)
+#define CONF_VALUE_CONTENT_8 (CONF_MASK_MULTI_BYTES | 2)
+
+#define CONF_VALUE_BOOLEAN(x) ((x) >= CONF_VALUE_SWITCH_1 && \
+ (x) <= CONF_VALUE_USE_BUG_4)
+
+#define CONF_VALUE_NUM_BYTES(x) ((x) == CONF_MASK_1_BYTE ? 1 : \
+ (x) == CONF_MASK_2_BYTE ? 2 : \
+ (x) == CONF_MASK_4_BYTE ? 4 : 0)
+
+#define CONF_CONTENT_NUM_ELEMENTS (3 * 3)
+#define CONF_CONTENT_NUM_BYTES (CONF_CONTENT_NUM_ELEMENTS * 2)
+
+#define CONF_CONTENT_ELEMENT_POS(c,x,y) ((c) * CONF_CONTENT_NUM_ELEMENTS + \
+ (y) * 3 + (x))
+#define CONF_CONTENT_BYTE_POS(c,x,y) (CONF_CONTENT_ELEMENT_POS(c,x,y) * 2)
+#define CONF_CONTENT_ELEMENT(b,c,x,y) ((b[CONF_CONTENT_BYTE_POS(c,x,y)] << 8)|\
+ (b[CONF_CONTENT_BYTE_POS(c,x,y) + 1]))
+
+static struct LevelInfo li;
+
+static struct
+{
+ int element;
+ int type;
+ void *value;
+} element_conf[] =
+{
+ /* 1-byte values */
+ { EL_EMC_ANDROID, CONF_VALUE_TIME_1, &li.android_move_time },
+ { EL_EMC_ANDROID, CONF_VALUE_TIME_2, &li.android_clone_time },
+ { EL_EMC_MAGIC_BALL, CONF_VALUE_TIME_1, &li.ball_time },
+ { EL_EMC_LENSES, CONF_VALUE_SCORE_1, &li.lenses_score },
+ { EL_EMC_LENSES, CONF_VALUE_TIME_1, &li.lenses_time },
+ { EL_EMC_MAGNIFIER, CONF_VALUE_SCORE_1, &li.magnify_score },
+ { EL_EMC_MAGNIFIER, CONF_VALUE_TIME_1, &li.magnify_time },
+ { EL_ROBOT, CONF_VALUE_SCORE_2, &li.slurp_score },
+
+ /* multi-byte values */
+ { EL_EMC_MAGIC_BALL, CONF_VALUE_CONTENT_8, &li.ball_content },
+
+ { -1, -1, NULL },
+};
+
+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 },
+};
+
/* ========================================================================= */
/* level file functions */
void setElementChangeInfoToDefaults(struct ElementChangeInfo *change)
{
- int x, y;
+ int i, x, y;
change->can_change = FALSE;
- change->events = CE_BITMASK_DEFAULT;
+ for (i = 0; i < NUM_CHANGE_EVENTS; i++)
+ change->has_event[i] = FALSE;
change->trigger_player = CH_PLAYER_ANY;
change->trigger_side = CH_SIDE_ANY;
change->random_percentage = 100;
change->replace_when = CP_WHEN_EMPTY;
+ change->has_action = FALSE;
+ change->action_type = CA_NO_ACTION;
+ change->action_mode = CA_MODE_UNDEFINED;
+ change->action_arg = CA_ARG_UNDEFINED;
+
for (x = 0; x < 3; x++)
for (y = 0; y < 3; y++)
- change->target_content[x][y] = EL_EMPTY_SPACE;
+ change->target_content.e[x][y] = EL_EMPTY_SPACE;
change->direct_action = 0;
change->other_action = 0;
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->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->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 < MAX_ELEMENT_CONTENTS; i++)
+ for (x = 0; x < 3; x++)
+ for (y = 0; y < 3; y++)
+ level->ball_content[i].e[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++)
for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
for (x = 0; x < 3; x++)
for (y = 0; y < 3; y++)
- level->yamyam_content[i][x][y] =
+ level->yamyam_content[i].e[x][y] =
(i < STD_ELEMENT_CONTENTS ? EL_ROCK : EL_EMPTY);
level->field[0][0] = EL_PLAYER_1;
{
element_info[element].access_direction = MV_ALL_DIRECTIONS;
- element_info[element].collect_score = 10; /* special default */
- element_info[element].collect_count = 1; /* special default */
+ element_info[element].collect_score_initial = 10; /* special default */
+ element_info[element].collect_count_initial = 1; /* special default */
element_info[element].push_delay_fixed = -1; /* initialize later */
element_info[element].push_delay_random = -1; /* initialize later */
for (x = 0; x < 3; x++)
for (y = 0; y < 3; y++)
- element_info[element].content[x][y] = EL_EMPTY_SPACE;
+ element_info[element].content.e[x][y] = EL_EMPTY_SPACE;
element_info[element].access_type = 0;
element_info[element].access_layer = 0;
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 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;
+}
+
static void determineLevelFileInfo_Filename(struct LevelFileInfo *lfi)
{
+ int nr = lfi->nr;
+
/* special case: level number is negative => check for level template file */
- if (lfi->nr < 0)
+ if (nr < 0)
{
- setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_RND);
+ 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)
{
- /* check for file name/pattern specified in "levelinfo.conf" */
- setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
+ 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_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_RND);
+ 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 classic Emerald Mine level file */
- setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_EM);
+ /* 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;
if (fileExists(lfi->filename))
return;
- /* no known level file found -- try to use default values */
- setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
+ /* 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 */
determineLevelFileInfo_Filetype(level_file_info);
}
-#else
-
-static struct LevelFileInfo *getLevelFileInfo(int nr)
-{
- static struct LevelFileInfo level_file_info;
-
- /* 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);
-
- return &level_file_info;
-}
-#endif
-
/* ------------------------------------------------------------------------- */
/* functions for loading R'n'D level */
/* ------------------------------------------------------------------------- */
{
/* remap some (historic, now obsolete) elements */
-#if 1
switch (element)
{
case EL_PLAYER_OBSOLETE:
}
break;
}
-#else
- if (element >= NUM_FILE_ELEMENTS)
- {
- Error(ERR_WARN, "invalid level element %d", element);
-
- element = EL_UNKNOWN;
- }
- else if (element == EL_PLAYER_OBSOLETE)
- element = EL_PLAYER_1;
- else if (element == EL_KEY_OBSOLETE)
- element = EL_KEY_1;
-#endif
return element;
}
for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- level->yamyam_content[i][x][y] = getMappedElement(getFile8Bit(file));
+ level->yamyam_content[i].e[x][y] = getMappedElement(getFile8Bit(file));
level->amoeba_speed = getFile8Bit(file);
level->time_magic_wall = getFile8Bit(file);
for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- level->yamyam_content[i][x][y] =
+ level->yamyam_content[i].e[x][y] =
getMappedElement(level->encoding_16bit_field ?
getFile16BitBE(file) : getFile8Bit(file));
return chunk_size;
for (i = 0; i < num_contents; i++)
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- level->yamyam_content[i][x][y] = content_array[i][x][y];
+ level->yamyam_content[i].e[x][y] = content_array[i][x][y];
}
else if (element == EL_BD_AMOEBA)
{
for (i = 0; i < num_changed_custom_elements; i++)
{
int element = getFile16BitBE(file);
+ unsigned long event_bits;
if (!IS_CUSTOM_ELEMENT(element))
{
element_info[element].gfx_element =
getMappedElement(getFile16BitBE(file));
- element_info[element].collect_score = getFile8Bit(file);
- element_info[element].collect_count = getFile8Bit(file);
+ element_info[element].collect_score_initial = getFile8Bit(file);
+ element_info[element].collect_count_initial = getFile8Bit(file);
element_info[element].push_delay_fixed = getFile16BitBE(file);
element_info[element].push_delay_random = getFile16BitBE(file);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- element_info[element].content[x][y] =
+ element_info[element].content.e[x][y] =
getMappedElement(getFile16BitBE(file));
- element_info[element].change->events = getFile32BitBE(file);
+ event_bits = getFile32BitBE(file);
+ for (j = 0; j < NUM_CHANGE_EVENTS; j++)
+ if (event_bits & (1 << j))
+ element_info[element].change->has_event[j] = TRUE;
element_info[element].change->target_element =
getMappedElement(getFile16BitBE(file));
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- element_info[element].change->target_content[x][y] =
+ element_info[element].change->target_content.e[x][y] =
getMappedElement(getFile16BitBE(file));
element_info[element].slippery_type = getFile8Bit(file);
struct ElementInfo *ei;
int chunk_size_expected;
int element;
- int i, x, y;
+ int i, j, x, y;
element = getFile16BitBE(file);
ei->use_gfx_element = getFile8Bit(file);
ei->gfx_element = getMappedElement(getFile16BitBE(file));
- ei->collect_score = getFile8Bit(file);
- ei->collect_count = getFile8Bit(file);
+ ei->collect_score_initial = getFile8Bit(file);
+ ei->collect_count_initial = getFile8Bit(file);
ei->drop_delay_fixed = getFile8Bit(file);
ei->push_delay_fixed = getFile8Bit(file);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- ei->content[x][y] = getMappedElement(getFile16BitBE(file));
+ ei->content.e[x][y] = getMappedElement(getFile16BitBE(file));
ei->move_enter_element = getMappedElement(getFile16BitBE(file));
ei->move_leave_element = getMappedElement(getFile16BitBE(file));
for (i = 0; i < ei->num_change_pages; i++)
{
struct ElementChangeInfo *change = &ei->change_page[i];
+ unsigned long event_bits;
/* always start with reliable default values */
setElementChangeInfoToDefaults(change);
- change->events = getFile32BitBE(file);
+ event_bits = getFile32BitBE(file);
+ for (j = 0; j < NUM_CHANGE_EVENTS; j++)
+ if (event_bits & (1 << j))
+ change->has_event[j] = TRUE;
change->target_element = getMappedElement(getFile16BitBE(file));
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- change->target_content[x][y] = getMappedElement(getFile16BitBE(file));
+ change->target_content.e[x][y]= getMappedElement(getFile16BitBE(file));
change->can_change = getFile8Bit(file);
change->trigger_side = getFile8Bit(file);
-#if 1
change->trigger_player = getFile8Bit(file);
change->trigger_page = getFile8Bit(file);
change->trigger_page = (change->trigger_page == CH_PAGE_ANY_FILE ?
CH_PAGE_ANY : (1 << change->trigger_page));
- /* some free bytes for future change property values and padding */
- ReadUnusedBytesFromFile(file, 6);
-
-#else
+ change->has_action = getFile8Bit(file);
+ change->action_type = getFile8Bit(file);
+ change->action_mode = getFile8Bit(file);
+ change->action_arg = getFile16BitBE(file);
/* some free bytes for future change property values and padding */
- ReadUnusedBytesFromFile(file, 8);
-#endif
+ ReadUnusedBytesFromFile(file, 1);
}
/* mark this custom element as modified */
return chunk_size;
}
+static int LoadLevel_CONF(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ int real_chunk_size = 0;
+ int i;
+
+ while (!feof(file))
+ {
+ int element = getFile16BitBE(file);
+ int type = getFile8Bit(file);
+ int bytes = type & CONF_MASK_BYTES;
+ boolean element_found = FALSE;
+
+ real_chunk_size += 3;
+
+ li = *level; /* copy level information into temporary buffer */
+
+ if (bytes == CONF_MASK_MULTI_BYTES)
+ {
+ int num_bytes = getFile16BitBE(file);
+ byte *buffer = checked_malloc(num_bytes);
+
+ ReadBytesFromFile(file, buffer, num_bytes);
+
+ for (i = 0; element_conf[i].element != -1; i++)
+ {
+ if (element_conf[i].element == element &&
+ element_conf[i].type == type)
+ {
+ element_found = TRUE;
+
+ if (type == CONF_VALUE_CONTENT_8)
+ {
+ struct Content *content= (struct Content *)(element_conf[i].value);
+ int num_contents = num_bytes / CONF_CONTENT_NUM_BYTES;
+ int c, x, y;
+
+ for (c = 0; c < num_contents; c++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ content[c].e[x][y] =
+ getMappedElement(CONF_CONTENT_ELEMENT(buffer, c, x, y));
+ }
+ else
+ element_found = FALSE;
+
+ break;
+ }
+ }
+
+ checked_free(buffer);
+
+ real_chunk_size += 2 + num_bytes;
+ }
+ else
+ {
+ int value = (bytes == CONF_MASK_1_BYTE ? getFile8Bit (file) :
+ bytes == CONF_MASK_2_BYTE ? getFile16BitBE(file) :
+ bytes == CONF_MASK_4_BYTE ? getFile32BitBE(file) : 0);
+
+ for (i = 0; element_conf[i].element != -1; i++)
+ {
+ if (element_conf[i].element == element &&
+ element_conf[i].type == type)
+ {
+ if (CONF_VALUE_BOOLEAN(type))
+ *(boolean *)(element_conf[i].value) = value;
+ else
+ *(int *) (element_conf[i].value) = value;
+
+ element_found = TRUE;
+
+ break;
+ }
+ }
+
+ real_chunk_size += CONF_VALUE_NUM_BYTES(bytes);
+ }
+
+ *level = li; /* copy temporary buffer back to level information */
+
+ if (!element_found)
+ Error(ERR_WARN, "cannot load CONF value for element %d", element);
+
+ if (type == CONF_LAST_ENTRY || real_chunk_size >= chunk_size)
+ break;
+ }
+
+ return real_chunk_size;
+}
+
static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
struct LevelFileInfo *level_file_info)
{
{ "CUS3", -1, LoadLevel_CUS3 },
{ "CUS4", -1, LoadLevel_CUS4 },
{ "GRP1", -1, LoadLevel_GRP1 },
+ { "CONF", -1, LoadLevel_CONF },
+
{ NULL, 0, NULL }
};
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] =
+ level->yamyam_content[i].e[x][y] =
map_em_element_yam(header[i * 9 + y * 3 + x]);
level->amoeba_speed = (header[52] * 256 + header[53]) % 256;
level->field[x][y] = EL_PLAYER_2;
}
-#else
+#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->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 < 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]]);
+
+ 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].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->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 < 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]);
+
+ 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)
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);
+}
/* ------------------------------------------------------------------------- */
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;
+ level->yamyam_content[i].e[x][y] = EL_EMPTY;
}
static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
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)
#endif
/* determine correct game engine version of current level */
-#if 1
if (!leveldir_current->latest_engine)
-#else
- if (IS_LEVELCLASS_CONTRIB(leveldir_current) ||
- IS_LEVELCLASS_PRIVATE(leveldir_current) ||
- IS_LEVELCLASS_UNDEFINED(leveldir_current))
-#endif
{
-#if 0
- printf("\n::: This level is private or contributed: '%s'\n", filename);
-#endif
-
-#if 0
- printf("\n::: Use the stored game engine version for this level\n");
-#endif
-
/* For all levels which are not forced to use the latest game engine
version (normally user contributed, private and undefined levels),
use the version of the game engine the levels were created for.
pre-2.0 levels, where the game version is still taken from the
file format version used to store the level -- see above). */
-#if 1
/* player was faster than enemies in 1.0.0 and before */
if (level->file_version == FILE_VERSION_1_0)
level->double_speed = TRUE;
-#else
- /* do some special adjustments to support older level versions */
- if (level->file_version == FILE_VERSION_1_0)
- {
- Error(ERR_WARN, "level file '%s' has version number 1.0", filename);
- Error(ERR_WARN, "using high speed movement for player");
-
- /* player was faster than monsters in (pre-)1.0 levels */
- level->double_speed = TRUE;
- }
-#endif
/* default behaviour for EM style gems was "slippery" only in 2.0.1 */
if (level->game_version == VERSION_IDENT(2,0,1,0))
level->use_spring_bug = TRUE;
/* only few elements were able to actively move into acid before 3.1.0 */
+ /* trigger settings did not exist before 3.1.0; set to default "any" */
if (level->game_version < VERSION_IDENT(3,1,0,0))
{
int i, j;
+ /* correct "can move into acid" settings (all zero in old levels) */
+
level->can_move_into_acid_bits = 0; /* nothing can move into acid */
level->dont_collide_with_bits = 0; /* nothing is deadly when colliding */
for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
SET_PROPERTY(EL_CUSTOM_START + i, EP_CAN_MOVE_INTO_ACID, TRUE);
+ /* correct trigger settings (stored as zero == "none" in old levels) */
+
for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
}
}
}
-
-#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 /* always use the latest game engine version */
{
-#if 0
- printf("\n::: ALWAYS USE LATEST ENGINE FOR THIS LEVEL: [%d] '%s'\n",
- leveldir_current->sort_priority, filename);
-#endif
-
-#if 0
- printf("\n::: Use latest game engine version for this level.\n");
-#endif
-
/* For all levels which are forced to use the latest game engine version
(normally all but user contributed, private and undefined levels), set
the game engine version to the actual version; this allows for actual
of the corresponding game more accurate, while (hopefully) not breaking
existing levels created from other players. */
-#if 0
- printf("::: changing engine from %d to %d\n",
- level->game_version, GAME_VERSION_ACTUAL);
-#endif
-
level->game_version = GAME_VERSION_ACTUAL;
/* Set special EM style gems behaviour: EM style gems slip down from
if (level->file_version < FILE_VERSION_2_0)
level->em_slippery_gems = TRUE;
}
-
-#if 0
- printf("::: => %d\n", level->game_version);
-#endif
}
static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
int i, j, x, y;
/* map custom element change events that have changed in newer versions
- (these following values were accidentally changed in version 3.0.1) */
+ (these following values were accidentally changed in version 3.0.1)
+ (this seems to be needed only for 'ab_levelset3' and 'ab_levelset4') */
if (level->game_version <= VERSION_IDENT(3,0,0,0))
{
for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
int element = EL_CUSTOM_START + i;
/* order of checking and copying events to be mapped is important */
- for (j = CE_BY_OTHER_ACTION; j >= CE_BY_PLAYER_OBSOLETE; j--)
+ for (j = CE_BY_OTHER_ACTION; j >= CE_COUNT_AT_ZERO; j--)
{
if (HAS_CHANGE_EVENT(element, j - 2))
{
}
/* order of checking and copying events to be mapped is important */
- for (j = CE_OTHER_GETS_COLLECTED; j >= CE_HITTING_SOMETHING; j--)
+ for (j = CE_PLAYER_COLLECTS_X; j >= CE_HITTING_SOMETHING; j--)
{
if (HAS_CHANGE_EVENT(element, j - 1))
{
}
}
- /* some custom element change events get mapped since version 3.0.3 */
- for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
- {
- int element = EL_CUSTOM_START + i;
-
- if (HAS_CHANGE_EVENT(element, CE_BY_PLAYER_OBSOLETE) ||
- HAS_CHANGE_EVENT(element, CE_BY_COLLISION_OBSOLETE))
- {
- SET_CHANGE_EVENT(element, CE_BY_PLAYER_OBSOLETE, FALSE);
- SET_CHANGE_EVENT(element, CE_BY_COLLISION_OBSOLETE, FALSE);
-
- SET_CHANGE_EVENT(element, CE_BY_DIRECT_ACTION, TRUE);
- }
- }
-
/* initialize "can_change" field for old levels with only one change page */
if (level->game_version <= VERSION_IDENT(3,0,2,0))
{
}
/* correct custom element values (for old levels without these options) */
- for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ if (level->game_version < VERSION_IDENT(3,1,1,0))
{
- int element = EL_CUSTOM_START + i;
- struct ElementInfo *ei = &element_info[element];
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ int element = EL_CUSTOM_START + i;
+ struct ElementInfo *ei = &element_info[element];
- if (ei->access_direction == MV_NO_MOVING)
- ei->access_direction = MV_ALL_DIRECTIONS;
+ if (ei->access_direction == MV_NO_DIRECTIONS)
+ ei->access_direction = MV_ALL_DIRECTIONS;
- for (j = 0; j < ei->num_change_pages; j++)
+#if 0
+ for (j = 0; j < ei->num_change_pages; j++)
+ {
+ struct ElementChangeInfo *change = &ei->change_page[j];
+
+ if (change->trigger_side == CH_SIDE_NONE)
+ change->trigger_side = CH_SIDE_ANY;
+ }
+#endif
+ }
+ }
+
+#if 1
+ /* correct custom element values (fix invalid values for all versions) */
+ if (1)
+ {
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
- struct ElementChangeInfo *change = &ei->change_page[j];
+ int element = EL_CUSTOM_START + i;
+ struct ElementInfo *ei = &element_info[element];
- if (change->trigger_side == CH_SIDE_NONE)
- change->trigger_side = CH_SIDE_ANY;
+ for (j = 0; j < ei->num_change_pages; j++)
+ {
+ struct ElementChangeInfo *change = &ei->change_page[j];
+
+ if (change->trigger_player == CH_PLAYER_NONE)
+ change->trigger_player = CH_PLAYER_ANY;
+
+ if (change->trigger_side == CH_SIDE_NONE)
+ change->trigger_side = CH_SIDE_ANY;
+ }
}
}
+#endif
/* initialize "can_explode" field for old levels which did not store this */
/* !!! CHECK THIS -- "<= 3,1,0,0" IS PROBABLY WRONG !!! */
}
}
-#if 0
- /* set default push delay values (corrected since version 3.0.7-1) */
- if (level->game_version < VERSION_IDENT(3,0,7,1))
- {
- game.default_push_delay_fixed = 2;
- game.default_push_delay_random = 8;
- }
- else
- {
- game.default_push_delay_fixed = 8;
- game.default_push_delay_random = 8;
- }
-
- /* set uninitialized push delay values of custom elements in older levels */
- for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
- {
- int element = EL_CUSTOM_START + i;
-
- if (element_info[element].push_delay_fixed == -1)
- element_info[element].push_delay_fixed = game.default_push_delay_fixed;
- if (element_info[element].push_delay_random == -1)
- element_info[element].push_delay_random = game.default_push_delay_random;
- }
-#endif
-
/* map elements that have changed in newer versions */
level->amoeba_content = getMappedElementByVersion(level->amoeba_content,
level->game_version);
for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
for (x = 0; x < 3; x++)
for (y = 0; y < 3; y++)
- level->yamyam_content[i][x][y] =
- getMappedElementByVersion(level->yamyam_content[i][x][y],
+ level->yamyam_content[i].e[x][y] =
+ getMappedElementByVersion(level->yamyam_content[i].e[x][y],
level->game_version);
/* initialize element properties for level editor etc. */
/* map elements that have changed in newer versions */
for (y = 0; y < level->fieldy; y++)
- {
for (x = 0; x < level->fieldx; x++)
- {
- int element = level->field[x][y];
-
-#if 1
- element = getMappedElementByVersion(element, level->game_version);
-#else
- if (level->game_version <= VERSION_IDENT(2,2,0,0))
- {
- /* map game font elements */
- element = (element == EL_CHAR('[') ? EL_CHAR_AUMLAUT :
- element == EL_CHAR('\\') ? EL_CHAR_OUMLAUT :
- element == EL_CHAR(']') ? EL_CHAR_UUMLAUT :
- element == EL_CHAR('^') ? EL_CHAR_COPYRIGHT : element);
- }
-
- if (level->game_version < VERSION_IDENT(3,0,0,0))
- {
- /* map Supaplex gravity tube elements */
- element = (element == EL_SP_GRAVITY_PORT_LEFT ? EL_SP_PORT_LEFT :
- element == EL_SP_GRAVITY_PORT_RIGHT ? EL_SP_PORT_RIGHT :
- element == EL_SP_GRAVITY_PORT_UP ? EL_SP_PORT_UP :
- element == EL_SP_GRAVITY_PORT_DOWN ? EL_SP_PORT_DOWN :
- element);
- }
-#endif
-
- level->field[x][y] = element;
- }
- }
+ level->field[x][y] = getMappedElementByVersion(level->field[x][y],
+ level->game_version);
/* copy elements to runtime playfield array */
for (x = 0; x < MAX_LEV_FIELDX; x++)
void LoadLevelTemplate(int nr)
{
-#if 1
char *filename;
setLevelFileInfo(&level_template.file_info, nr);
LoadLevelFromFileInfo(&level_template, &level_template.file_info);
-#else
-
-#if 1
- struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
- char *filename = level_file_info->filename;
-
- LoadLevelFromFileInfo(&level_template, level_file_info);
-#else
- char *filename = getDefaultLevelFilename(nr);
-
- 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);
LoadLevelFromFileInfo(&level, &level.file_info);
-#else
-
-#if 1
- struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
- char *filename = level_file_info->filename;
-
- LoadLevelFromFileInfo(&level, level_file_info);
-#else
- char *filename = getLevelFilename(nr);
-
- LoadLevelFromFilename_RND(&level, filename);
-#endif
-#endif
-
if (level.use_custom_template)
LoadLevelTemplate(-1);
-#if 1
LoadLevel_InitVersion(&level, filename);
LoadLevel_InitElements(&level, filename);
LoadLevel_InitPlayfield(&level, filename);
-#else
- LoadLevel_InitLevel(&level, filename);
-#endif
}
static void SaveLevel_VERS(FILE *file, struct LevelInfo *level)
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
putFile8Bit(file, (level->encoding_16bit_yamyam ? EL_EMPTY :
- level->yamyam_content[i][x][y]));
+ level->yamyam_content[i].e[x][y]));
putFile8Bit(file, level->amoeba_speed);
putFile8Bit(file, level->time_magic_wall);
putFile8Bit(file, level->time_wheel);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
if (level->encoding_16bit_field)
- putFile16BitBE(file, level->yamyam_content[i][x][y]);
+ putFile16BitBE(file, level->yamyam_content[i].e[x][y]);
else
- putFile8Bit(file, level->yamyam_content[i][x][y]);
+ putFile8Bit(file, level->yamyam_content[i].e[x][y]);
}
#endif
for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- content_array[i][x][y] = level->yamyam_content[i][x][y];
+ content_array[i][x][y] = level->yamyam_content[i].e[x][y];
}
else if (element == EL_BD_AMOEBA)
{
putFile8Bit(file, element_info[element].use_gfx_element);
putFile16BitBE(file, element_info[element].gfx_element);
- putFile8Bit(file, element_info[element].collect_score);
- putFile8Bit(file, element_info[element].collect_count);
+ putFile8Bit(file, element_info[element].collect_score_initial);
+ putFile8Bit(file, element_info[element].collect_count_initial);
putFile16BitBE(file, element_info[element].push_delay_fixed);
putFile16BitBE(file, element_info[element].push_delay_random);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- putFile16BitBE(file, element_info[element].content[x][y]);
+ putFile16BitBE(file, element_info[element].content.e[x][y]);
putFile32BitBE(file, element_info[element].change->events);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- putFile16BitBE(file, element_info[element].change->content[x][y]);
+ putFile16BitBE(file,element_info[element].change->content.e[x][y]);
putFile8Bit(file, element_info[element].slippery_type);
static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
{
struct ElementInfo *ei = &element_info[element];
- int i, x, y;
+ int i, j, x, y;
putFile16BitBE(file, element);
putFile8Bit(file, ei->use_gfx_element);
putFile16BitBE(file, ei->gfx_element);
- putFile8Bit(file, ei->collect_score);
- putFile8Bit(file, ei->collect_count);
+ putFile8Bit(file, ei->collect_score_initial);
+ putFile8Bit(file, ei->collect_count_initial);
putFile8Bit(file, ei->drop_delay_fixed);
putFile8Bit(file, ei->push_delay_fixed);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- putFile16BitBE(file, ei->content[x][y]);
+ putFile16BitBE(file, ei->content.e[x][y]);
putFile16BitBE(file, ei->move_enter_element);
putFile16BitBE(file, ei->move_leave_element);
for (i = 0; i < ei->num_change_pages; i++)
{
struct ElementChangeInfo *change = &ei->change_page[i];
+ unsigned long event_bits = 0;
+
+ for (j = 0; j < NUM_CHANGE_EVENTS; j++)
+ if (change->has_event[j])
+ event_bits |= (1 << j);
- putFile32BitBE(file, change->events);
+ putFile32BitBE(file, event_bits);
putFile16BitBE(file, change->target_element);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- putFile16BitBE(file, change->target_content[x][y]);
+ putFile16BitBE(file, change->target_content.e[x][y]);
putFile8Bit(file, change->can_change);
putFile8Bit(file, change->trigger_side);
-#if 1
putFile8Bit(file, change->trigger_player);
putFile8Bit(file, (change->trigger_page == CH_PAGE_ANY ? CH_PAGE_ANY_FILE :
log_2(change->trigger_page)));
- /* some free bytes for future change property values and padding */
- WriteUnusedBytesToFile(file, 6);
-
-#else
+ putFile8Bit(file, change->has_action);
+ putFile8Bit(file, change->action_type);
+ putFile8Bit(file, change->action_mode);
+ putFile16BitBE(file, change->action_arg);
/* some free bytes for future change property values and padding */
- WriteUnusedBytesToFile(file, 8);
-#endif
+ WriteUnusedBytesToFile(file, 1);
}
}
putFile16BitBE(file, group->element[i]);
}
+static int SaveLevel_CONF_Value(FILE *file, int element, int type, int value)
+{
+ int bytes = type & CONF_MASK_BYTES;
+ int num_bytes = 0;
+
+ if (bytes == CONF_MASK_MULTI_BYTES)
+ Error(ERR_EXIT, "SaveLevel_CONF_INT: invalid type CONF_MASK_MULTI_BYTES");
+
+ num_bytes += putFile16BitBE(file, element);
+ num_bytes += putFile8Bit(file, type);
+ num_bytes += (bytes == CONF_MASK_1_BYTE ? putFile8Bit (file, value) :
+ bytes == CONF_MASK_2_BYTE ? putFile16BitBE(file, value) :
+ bytes == CONF_MASK_4_BYTE ? putFile32BitBE(file, value) : 0);
+
+ return num_bytes;
+}
+
+static int SaveLevel_CONF_Content(FILE *file, int element, int type,
+ struct Content *content, int num_contents)
+{
+ int num_bytes = 0;
+ int i, x, y;
+
+ num_bytes += putFile16BitBE(file, element);
+ num_bytes += putFile8Bit(file, type);
+ num_bytes += putFile16BitBE(file, num_contents * CONF_CONTENT_NUM_BYTES);
+
+ for (i = 0; i < num_contents; i++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ num_bytes += putFile16BitBE(file, content[i].e[x][y]);
+
+ return num_bytes;
+}
+
+static int SaveLevel_CONF(FILE *file, struct LevelInfo *level)
+{
+ int chunk_size = 0;
+ int i;
+
+ li = *level; /* copy level information into temporary buffer */
+
+ for (i = 0; element_conf[i].element != -1; i++)
+ {
+ int element = element_conf[i].element;
+ int type = element_conf[i].type;
+ void *value = element_conf[i].value;
+ int bytes = type & CONF_MASK_BYTES;
+
+ if (bytes == CONF_MASK_MULTI_BYTES)
+ {
+ if (type == CONF_VALUE_CONTENT_8)
+ {
+ struct Content *content = (struct Content *)value;
+
+ chunk_size += SaveLevel_CONF_Content(file, element, type,
+ content, MAX_ELEMENT_CONTENTS);
+ }
+ else
+ Error(ERR_WARN, "cannot save CONF value for element %d", element);
+ }
+ else
+ {
+ int value_int = (CONF_VALUE_BOOLEAN(type) ? *(boolean *)value :
+ *(int *)value);
+
+ chunk_size += SaveLevel_CONF_Value(file, element, type, value_int);
+ }
+ }
+
+ return chunk_size;
+}
+
static void SaveLevelFromFilename(struct LevelInfo *level, char *filename)
{
- int body_chunk_size;
+ int body_chunk_size, conf_chunk_size;
int i, x, y;
FILE *file;
for (i = 0; i < level->num_yamyam_contents; i++)
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
- if (level->yamyam_content[i][x][y] > 255)
+ if (level->yamyam_content[i].e[x][y] > 255)
level->encoding_16bit_yamyam = TRUE;
/* check amoeba content for 16-bit elements */
}
}
+ conf_chunk_size = SaveLevel_CONF(NULL, level); /* get chunk size */
+
+ putFileChunkBE(file, "CONF", conf_chunk_size);
+ SaveLevel_CONF(file, level);
+
fclose(file);
SetFilePermissions(filename, PERMS_PRIVATE);
for (i = 0; i < tape->length; i++)
{
- if (i >= MAX_TAPELEN)
+ if (i >= MAX_TAPE_LEN)
break;
for (j = 0; j < MAX_PLAYERS; j++)
{
tape.no_valid_file = TRUE;
-#if 0
- Error(ERR_WARN, "cannot read tape '%s' -- using empty tape", filename);
-#endif
-
return;
}
InitTapeDirectory(leveldir_current->subdir);
/* if a tape still exists, ask to overwrite it */
- if (access(filename, F_OK) == 0)
+ if (fileExists(filename))
{
new_tape = FALSE;
if (!Request("Replace old tape ?", REQ_ASK))
tape.changed = FALSE;
if (new_tape)
- Request("tape saved !", REQ_CONFIRM);
+ Request("Tape saved !", REQ_CONFIRM);
}
void DumpTape(struct TapeInfo *tape)
{
int i, j;
-#if 1
if (tape->no_valid_file)
{
Error(ERR_WARN, "cannot dump -- no valid tape file found");
return;
}
-#else
- if (TAPE_IS_EMPTY(*tape))
- {
- Error(ERR_WARN, "no tape available for level %d", tape->level_nr);
-
- return;
- }
-#endif
printf_line("-", 79);
printf("Tape of Level %03d (file version %08d, game version %08d)\n",
for (i = 0; i < tape->length; i++)
{
- if (i >= MAX_TAPELEN)
+ if (i >= MAX_TAPE_LEN)
break;
printf("%03d: ", i);
#define SETUP_TOKEN_QUICK_DOORS 10
#define SETUP_TOKEN_TEAM_MODE 11
#define SETUP_TOKEN_HANDICAP 12
-#define SETUP_TOKEN_TIME_LIMIT 13
-#define SETUP_TOKEN_FULLSCREEN 14
-#define SETUP_TOKEN_ASK_ON_ESCAPE 15
-#define SETUP_TOKEN_GRAPHICS_SET 16
-#define SETUP_TOKEN_SOUNDS_SET 17
-#define SETUP_TOKEN_MUSIC_SET 18
-#define SETUP_TOKEN_OVERRIDE_LEVEL_GRAPHICS 19
-#define SETUP_TOKEN_OVERRIDE_LEVEL_SOUNDS 20
-#define SETUP_TOKEN_OVERRIDE_LEVEL_MUSIC 21
-
-#define NUM_GLOBAL_SETUP_TOKENS 22
+#define SETUP_TOKEN_SKIP_LEVELS 13
+#define SETUP_TOKEN_TIME_LIMIT 14
+#define SETUP_TOKEN_FULLSCREEN 15
+#define SETUP_TOKEN_ASK_ON_ESCAPE 16
+#define SETUP_TOKEN_GRAPHICS_SET 17
+#define SETUP_TOKEN_SOUNDS_SET 18
+#define SETUP_TOKEN_MUSIC_SET 19
+#define SETUP_TOKEN_OVERRIDE_LEVEL_GRAPHICS 20
+#define SETUP_TOKEN_OVERRIDE_LEVEL_SOUNDS 21
+#define SETUP_TOKEN_OVERRIDE_LEVEL_MUSIC 22
+
+#define NUM_GLOBAL_SETUP_TOKENS 23
/* 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, &si.quick_doors, "quick_doors" },
{ TYPE_SWITCH, &si.team_mode, "team_mode" },
{ TYPE_SWITCH, &si.handicap, "handicap" },
+ { TYPE_SWITCH, &si.skip_levels, "skip_levels" },
{ TYPE_SWITCH, &si.time_limit, "time_limit" },
{ TYPE_SWITCH, &si.fullscreen, "fullscreen" },
{ TYPE_SWITCH, &si.ask_on_escape, "ask_on_escape" },
{
{ 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->quick_doors = FALSE;
si->team_mode = FALSE;
si->handicap = TRUE;
+ si->skip_levels = TRUE;
si->time_limit = TRUE;
si->fullscreen = FALSE;
si->ask_on_escape = TRUE;
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;
{
char *value = getHashEntry(element_hash, list->token);
- if (value)
+ if (value == NULL) /* try to find obsolete token mapping */
+ {
+ char *mapped_token = get_mapped_token(list->token);
+
+ if (mapped_token != NULL)
+ {
+ value = getHashEntry(element_hash, mapped_token);
+
+ free(mapped_token);
+ }
+ }
+
+ if (value != NULL)
{
(*elements)[(*num_elements)++] = atoi(value);
}
freeSetupFileHash(element_hash);
#if 0
- /* TEST-ONLY */
for (i = 0; i < *num_elements; i++)
printf("editor: element '%s' [%d]\n",
element_info[(*elements)[i]].token_name, (*elements)[i]);
new = &music_file_info;
-#if 0
- printf("::: num_music == %d\n", num_music);
-#endif
-
for (i = 0; i < num_music; i++)
{
music = getMusicListEntry(i);
-#if 0
- printf("::: %d [%08x]\n", i, music->filename);
-#endif
-
if (music->filename == NULL)
continue;
}
#if 0
- /* TEST-ONLY */
for (next = music_file_info; next != NULL; next = next->next)
printf("::: title == '%s'\n", next->title);
#endif
freeSetupFileHash(direction_hash);
#if 0
- /* TEST ONLY */
for (i = 0; i < num_list_entries; i++)
printf("::: %d, %d, %d => %d\n",
helpanim_info[i].element,
}
#if 0
- /* TEST ONLY */
BEGIN_HASH_ITERATION(helptext_info, itr)
{
printf("::: '%s' => '%s'\n",
projects / rocksndiamonds.git / blobdiff