#include <ctype.h>
#include <sys/stat.h>
+#include <dirent.h>
+#include <math.h>
#include "libgame/libgame.h"
#define LEVEL_HEADER_UNUSED 13 /* 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 LEVEL_CHUNK_CNT3_UNUSED 10 /* unused CNT3 chunk bytes */
#define LEVEL_CPART_CUS3_SIZE 134 /* size of CUS3 chunk part */
#define LEVEL_CPART_CUS3_UNUSED 15 /* unused CUS3 bytes / part */
#define TAPE_HEADER_SIZE 20 /* size of tape file header */
#define TAPE_HEADER_UNUSED 3 /* unused tape header bytes */
-#define LEVEL_CHUNK_CUS3_SIZE(x) (2 + x * LEVEL_CPART_CUS3_SIZE)
+#define LEVEL_CHUNK_CUS3_SIZE(x) (2 + (x) * LEVEL_CPART_CUS3_SIZE)
+#define LEVEL_CHUNK_CUS4_SIZE(x) (48 + 48 + (x) * 48)
/* file identifier strings */
#define LEVEL_COOKIE_TMPL "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_x.x"
change->can_change = FALSE;
change->events = CE_BITMASK_DEFAULT;
+ change->sides = CH_SIDE_ANY;
+
change->target_element = EL_EMPTY_SPACE;
change->delay_fixed = 0;
change->delay_random = 0;
- change->delay_frames = -1; /* later set to reliable default value */
+ change->delay_frames = 1;
change->trigger_element = EL_EMPTY_SPACE;
change->use_content = FALSE;
change->only_complete = FALSE;
change->use_random_change = FALSE;
- change->random = 0;
+ change->random = 100;
change->power = CP_NON_DESTRUCTIVE;
- for(x=0; x<3; x++)
- for(y=0; y<3; y++)
+ for (x = 0; x < 3; x++)
+ for (y = 0; y < 3; y++)
change->content[x][y] = EL_EMPTY_SPACE;
- change->player_action = 0;
- change->collide_action = 0;
+ change->direct_action = 0;
change->other_action = 0;
change->pre_change_function = NULL;
level->fieldx = STD_LEV_FIELDX;
level->fieldy = STD_LEV_FIELDY;
- for(x=0; x<MAX_LEV_FIELDX; x++)
- for(y=0; y<MAX_LEV_FIELDY; y++)
+ for (x = 0; x < MAX_LEV_FIELDX; x++)
+ for (y = 0; y < MAX_LEV_FIELDY; y++)
level->field[x][y] = EL_SAND;
level->time = 100;
level->time_timegate = 10;
level->amoeba_content = EL_DIAMOND;
level->double_speed = FALSE;
- level->gravity = FALSE;
+ level->initial_gravity = FALSE;
level->em_slippery_gems = FALSE;
level->use_custom_template = FALSE;
- for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
+ for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
level->name[i] = '\0';
- for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
+ for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
level->author[i] = '\0';
strcpy(level->name, NAMELESS_LEVEL_NAME);
strcpy(level->author, ANONYMOUS_NAME);
- level->envelope[0] = '\0';
- level->envelope_xsize = MAX_ENVELOPE_XSIZE;
- level->envelope_ysize = MAX_ENVELOPE_YSIZE;
+ for (i = 0; i < 4; i++)
+ {
+ level->envelope_text[i][0] = '\0';
+ level->envelope_xsize[i] = MAX_ENVELOPE_XSIZE;
+ level->envelope_ysize[i] = MAX_ENVELOPE_YSIZE;
+ }
- for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
+ for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
level->score[i] = 10;
level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
- for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
- for(x=0; x<3; x++)
- for(y=0; y<3; y++)
+ 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] =
(i < STD_ELEMENT_CONTENTS ? EL_ROCK : EL_EMPTY);
level->field[0][0] = EL_PLAYER_1;
level->field[STD_LEV_FIELDX - 1][STD_LEV_FIELDY - 1] = EL_EXIT_CLOSED;
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
setElementChangePages(&element_info[i], 1);
setElementChangeInfoToDefaults(element_info[i].change);
}
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
- for(j=0; j < MAX_ELEMENT_NAME_LEN + 1; j++)
+ for (j = 0; j < MAX_ELEMENT_NAME_LEN + 1; j++)
element_info[element].description[j] = '\0';
if (element_info[element].custom_description != NULL)
strncpy(element_info[element].description,
element_info[element].collect_score = 10; /* special default */
element_info[element].collect_count = 1; /* special default */
- element_info[element].push_delay_fixed = 2; /* special default */
- element_info[element].push_delay_random = 8; /* special default */
+ element_info[element].push_delay_fixed = -1; /* initialize later */
+ element_info[element].push_delay_random = -1; /* initialize later */
element_info[element].move_delay_fixed = 0;
element_info[element].move_delay_random = 0;
element_info[element].slippery_type = SLIPPERY_ANY_RANDOM;
- for(x=0; x<3; x++)
- for(y=0; y<3; y++)
+ for (x = 0; x < 3; x++)
+ for (y = 0; y < 3; y++)
element_info[element].content[x][y] = EL_EMPTY_SPACE;
element_info[element].access_type = 0;
element_info[element].current_change_page = 0;
/* start with no properties at all */
- for (j=0; j < NUM_EP_BITFIELDS; j++)
+ for (j = 0; j < NUM_EP_BITFIELDS; j++)
Properties[element][j] = EP_BITMASK_DEFAULT;
element_info[element].modified_settings = FALSE;
strcpy(level->author, PROGRAM_AUTHOR_STRING);
break;
- case LEVELCLASS_CONTRIBUTION:
- strncpy(level->author, leveldir_current->name,MAX_LEVEL_AUTHOR_LEN);
+ case LEVELCLASS_CONTRIB:
+ strncpy(level->author, leveldir_current->name, MAX_LEVEL_AUTHOR_LEN);
level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
break;
- case LEVELCLASS_USER:
+ case LEVELCLASS_PRIVATE:
strncpy(level->author, getRealName(), MAX_LEVEL_AUTHOR_LEN);
level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
break;
static int checkLevelElement(int element)
{
+ /* map some (historic, now obsolete) elements */
+
+#if 1
+ switch (element)
+ {
+ case EL_PLAYER_OBSOLETE:
+ element = EL_PLAYER_1;
+ break;
+
+ case EL_KEY_OBSOLETE:
+ element = EL_KEY_1;
+
+ case EL_EM_KEY_1_FILE_OBSOLETE:
+ element = EL_EM_KEY_1;
+ break;
+
+ case EL_EM_KEY_2_FILE_OBSOLETE:
+ element = EL_EM_KEY_2;
+ break;
+
+ case EL_EM_KEY_3_FILE_OBSOLETE:
+ element = EL_EM_KEY_3;
+ break;
+
+ case EL_EM_KEY_4_FILE_OBSOLETE:
+ element = EL_EM_KEY_4;
+ break;
+
+ case EL_ENVELOPE_OBSOLETE:
+ element = EL_ENVELOPE_1;
+ break;
+
+ case EL_SP_EMPTY:
+ element = EL_EMPTY;
+ break;
+
+ default:
+ if (element >= NUM_FILE_ELEMENTS)
+ {
+ Error(ERR_WARN, "invalid level element %d", element);
+
+ element = EL_CHAR_QUESTION;
+ }
+ break;
+ }
+#else
if (element >= NUM_FILE_ELEMENTS)
{
Error(ERR_WARN, "invalid level element %d", element);
+
element = EL_CHAR_QUESTION;
}
else if (element == EL_PLAYER_OBSOLETE)
element = EL_PLAYER_1;
else if (element == EL_KEY_OBSOLETE)
element = EL_KEY_1;
+#endif
return element;
}
level->time = getFile16BitBE(file);
level->gems_needed = getFile16BitBE(file);
- for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
+ for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
level->name[i] = getFile8Bit(file);
level->name[MAX_LEVEL_NAME_LEN] = 0;
- for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
+ for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
level->score[i] = getFile8Bit(file);
level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
- for(i=0; i<STD_ELEMENT_CONTENTS; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ 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] = checkLevelElement(getFile8Bit(file));
level->amoeba_speed = getFile8Bit(file);
level->time_wheel = getFile8Bit(file);
level->amoeba_content = checkLevelElement(getFile8Bit(file));
level->double_speed = (getFile8Bit(file) == 1 ? TRUE : FALSE);
- level->gravity = (getFile8Bit(file) == 1 ? TRUE : FALSE);
+ level->initial_gravity = (getFile8Bit(file) == 1 ? TRUE : FALSE);
level->encoding_16bit_field = (getFile8Bit(file) == 1 ? TRUE : FALSE);
level->em_slippery_gems = (getFile8Bit(file) == 1 ? TRUE : FALSE);
{
int i;
- for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
+ for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
level->author[i] = getFile8Bit(file);
level->author[MAX_LEVEL_NAME_LEN] = 0;
return chunk_size_expected;
}
- for(y=0; y<level->fieldy; y++)
- for(x=0; x<level->fieldx; x++)
+ for (y = 0; y < level->fieldy; y++)
+ for (x = 0; x < level->fieldx; x++)
level->field[x][y] =
checkLevelElement(level->encoding_16bit_field ? getFile16BitBE(file) :
getFile8Bit(file));
level->num_yamyam_contents > MAX_ELEMENT_CONTENTS)
level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
- for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ 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] =
checkLevelElement(level->encoding_16bit_field ?
getFile16BitBE(file) : getFile8Bit(file));
num_contents = getFile8Bit(file);
content_xsize = getFile8Bit(file);
content_ysize = getFile8Bit(file);
+
ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT2_UNUSED);
- for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ 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] = checkLevelElement(getFile16BitBE(file));
/* correct invalid number of content fields -- should never happen */
{
level->num_yamyam_contents = num_contents;
- for(i=0; i<num_contents; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ 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];
}
else if (element == EL_BD_AMOEBA)
return chunk_size;
}
+static int LoadLevel_CNT3(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ int i;
+ int element;
+ int envelope_nr;
+ int envelope_len;
+ int chunk_size_expected;
+
+ element = checkLevelElement(getFile16BitBE(file));
+ if (!IS_ENVELOPE(element))
+ element = EL_ENVELOPE_1;
+
+ envelope_nr = element - EL_ENVELOPE_1;
+
+ envelope_len = getFile16BitBE(file);
+
+ level->envelope_xsize[envelope_nr] = getFile8Bit(file);
+ level->envelope_ysize[envelope_nr] = getFile8Bit(file);
+
+ ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT3_UNUSED);
+
+ chunk_size_expected = LEVEL_CHUNK_CNT3_HEADER + envelope_len;
+
+ if (chunk_size_expected != chunk_size)
+ {
+ ReadUnusedBytesFromFile(file, chunk_size - LEVEL_CHUNK_CNT3_HEADER);
+ return chunk_size_expected;
+ }
+
+ for (i = 0; i < envelope_len; i++)
+ level->envelope_text[envelope_nr][i] = getFile8Bit(file);
+
+ return chunk_size;
+}
+
static int LoadLevel_CUS1(FILE *file, int chunk_size, struct LevelInfo *level)
{
int num_changed_custom_elements = getFile16BitBE(file);
return chunk_size_expected;
}
- for (i=0; i < num_changed_custom_elements; i++)
+ for (i = 0; i < num_changed_custom_elements; i++)
{
int element = getFile16BitBE(file);
int properties = getFile32BitBE(file);
return chunk_size_expected;
}
- for (i=0; i < num_changed_custom_elements; i++)
+ for (i = 0; i < num_changed_custom_elements; i++)
{
int element = getFile16BitBE(file);
int custom_target_element = getFile16BitBE(file);
return chunk_size_expected;
}
- for (i=0; i < num_changed_custom_elements; i++)
+ for (i = 0; i < num_changed_custom_elements; i++)
{
int element = getFile16BitBE(file);
{
Error(ERR_WARN, "invalid custom element number %d", element);
- element = EL_DEFAULT; /* dummy element used for artwork config */
+ element = EL_DUMMY;
}
- for(j=0; j<MAX_ELEMENT_NAME_LEN; j++)
+ for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
element_info[element].description[j] = getFile8Bit(file);
element_info[element].description[MAX_ELEMENT_NAME_LEN] = 0;
element_info[element].move_direction_initial = getFile8Bit(file);
element_info[element].move_stepsize = getFile8Bit(file);
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
element_info[element].content[x][y] =
checkLevelElement(getFile16BitBE(file));
element_info[element].change->random = getFile8Bit(file);
element_info[element].change->power = getFile8Bit(file);
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
element_info[element].change->content[x][y] =
checkLevelElement(getFile16BitBE(file));
return chunk_size;
}
+static int LoadLevel_CUS4(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ struct ElementInfo *ei;
+ int chunk_size_expected;
+ int element;
+ int i, x, y;
+
+ element = getFile16BitBE(file);
+
+ if (!IS_CUSTOM_ELEMENT(element))
+ {
+ Error(ERR_WARN, "invalid custom element number %d", element);
+
+ element = EL_DUMMY;
+ }
+
+ ei = &element_info[element];
+
+ for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
+ ei->description[i] = getFile8Bit(file);
+ ei->description[MAX_ELEMENT_NAME_LEN] = 0;
+
+ Properties[element][EP_BITFIELD_BASE] = getFile32BitBE(file);
+ ReadUnusedBytesFromFile(file, 4); /* reserved for more base properties */
+
+ ei->num_change_pages = getFile8Bit(file);
+
+ /* some free bytes for future base property values and padding */
+ ReadUnusedBytesFromFile(file, 5);
+
+ chunk_size_expected = LEVEL_CHUNK_CUS4_SIZE(ei->num_change_pages);
+ if (chunk_size_expected != chunk_size)
+ {
+ ReadUnusedBytesFromFile(file, chunk_size - 48);
+ return chunk_size_expected;
+ }
+
+ /* read custom property values */
+
+ ei->use_gfx_element = getFile8Bit(file);
+ ei->gfx_element = checkLevelElement(getFile16BitBE(file));
+
+ ei->collect_score = getFile8Bit(file);
+ ei->collect_count = getFile8Bit(file);
+
+ ei->push_delay_fixed = getFile16BitBE(file);
+ ei->push_delay_random = getFile16BitBE(file);
+ ei->move_delay_fixed = getFile16BitBE(file);
+ ei->move_delay_random = getFile16BitBE(file);
+
+ ei->move_pattern = getFile16BitBE(file);
+ ei->move_direction_initial = getFile8Bit(file);
+ ei->move_stepsize = getFile8Bit(file);
+
+ ei->slippery_type = getFile8Bit(file);
+
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ ei->content[x][y] = checkLevelElement(getFile16BitBE(file));
+
+ /* some free bytes for future custom property values and padding */
+ ReadUnusedBytesFromFile(file, 12);
+
+ /* read change property values */
+
+ setElementChangePages(ei, ei->num_change_pages);
+
+ for (i = 0; i < ei->num_change_pages; i++)
+ {
+ struct ElementChangeInfo *change = &ei->change_page[i];
+
+ /* always start with reliable default values */
+ setElementChangeInfoToDefaults(change);
+
+ change->events = getFile32BitBE(file);
+
+ change->target_element = checkLevelElement(getFile16BitBE(file));
+
+ change->delay_fixed = getFile16BitBE(file);
+ change->delay_random = getFile16BitBE(file);
+ change->delay_frames = getFile16BitBE(file);
+
+ change->trigger_element = checkLevelElement(getFile16BitBE(file));
+
+ change->explode = getFile8Bit(file);
+ change->use_content = getFile8Bit(file);
+ change->only_complete = getFile8Bit(file);
+ change->use_random_change = getFile8Bit(file);
+
+ change->random = getFile8Bit(file);
+ change->power = getFile8Bit(file);
+
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ change->content[x][y] = checkLevelElement(getFile16BitBE(file));
+
+ change->can_change = getFile8Bit(file);
+
+ change->sides = getFile8Bit(file);
+
+ if (change->sides == CH_SIDE_NONE) /* correct empty sides field */
+ change->sides = CH_SIDE_ANY;
+
+ /* some free bytes for future change property values and padding */
+ ReadUnusedBytesFromFile(file, 8);
+ }
+
+ /* mark this custom element as modified */
+ ei->modified_settings = TRUE;
+
+ return chunk_size;
+}
+
void LoadLevelFromFilename(struct LevelInfo *level, char *filename)
{
char cookie[MAX_LINE_LEN];
{ "BODY", -1, LoadLevel_BODY },
{ "CONT", -1, LoadLevel_CONT },
{ "CNT2", LEVEL_CHUNK_CNT2_SIZE, LoadLevel_CNT2 },
+ { "CNT3", -1, LoadLevel_CNT3 },
{ "CUS1", -1, LoadLevel_CUS1 },
{ "CUS2", -1, LoadLevel_CUS2 },
{ "CUS3", -1, LoadLevel_CUS3 },
+ { "CUS4", -1, LoadLevel_CUS4 },
{ NULL, 0, NULL }
};
fclose(file);
}
-#if 1
-
static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
{
if (leveldir_current == NULL) /* only when dumping level */
return;
+#if 0
+ printf("::: sort_priority: %d\n", leveldir_current->sort_priority);
+#endif
+
/* determine correct game engine version of current level */
- if (IS_LEVELCLASS_CONTRIBUTION(leveldir_current) ||
- IS_LEVELCLASS_USER(leveldir_current))
+#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
- /* For user contributed and private levels, use the version of
- the game engine the levels were created for.
+#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.
+
Since 2.0.1, the game engine version is now directly stored
in the level file (chunk "VERS"), so there is no need anymore
to set the game version from the file version (except for old,
/* 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, "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 */
}
/* Default behaviour for EM style gems was "slippery" only in 2.0.1 */
- if (level->game_version == VERSION_IDENT(2,0,1))
+ if (level->game_version == VERSION_IDENT(2,0,1,0))
level->em_slippery_gems = TRUE;
}
else
leveldir_current->sort_priority, filename);
#endif
- /* Always use the latest version of the game engine for all but
- user contributed and private levels; this allows for actual
- corrections in the game engine to take effect for existing,
- converted levels (from "classic" or other existing games) to
- make the game emulation more accurate, while (hopefully) not
- breaking existing levels created from other players. */
+#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
+ corrections in the game engine to take effect for existing, converted
+ levels (from "classic" or other existing games) to make the emulation
+ 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;
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;
/* map custom element change events that have changed in newer versions
- (these following values have accidentally changed in version 3.0.1) */
- if (level->game_version <= VERSION_IDENT(3,0,0))
+ (these following values were accidentally changed in version 3.0.1) */
+ if (level->game_version <= VERSION_IDENT(3,0,0,0))
{
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
- /* order of checking events to be mapped is important */
- for (j=CE_BY_OTHER; j >= CE_BY_PLAYER; j--)
+ /* order of checking and copying events to be mapped is important */
+ for (j = CE_BY_OTHER_ACTION; j >= CE_BY_PLAYER_OBSOLETE; j--)
{
if (HAS_CHANGE_EVENT(element, j - 2))
{
}
}
- /* order of checking events to be mapped is important */
- for (j=CE_OTHER_GETS_COLLECTED; j >= CE_COLLISION; j--)
+ /* order of checking and copying events to be mapped is important */
+ for (j = CE_OTHER_GETS_COLLECTED; j >= CE_COLLISION_ACTIVE; 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))
+ if (level->game_version <= VERSION_IDENT(3,0,2,0))
{
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
}
}
+#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
+
/* initialize element properties for level editor etc. */
InitElementPropertiesEngine(level->game_version);
}
int x, y;
/* map elements that have changed in newer versions */
- for(y=0; y<level->fieldy; y++)
+ for (y = 0; y < level->fieldy; y++)
{
- for(x=0; x<level->fieldx; x++)
+ for (x = 0; x < level->fieldx; x++)
{
int element = level->field[x][y];
- if (level->game_version <= VERSION_IDENT(2,2,0))
+ 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_COPYRIGHT : element);
}
- if (level->game_version < VERSION_IDENT(3,0,0))
+ 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 :
}
/* copy elements to runtime playfield array */
- for(x=0; x<MAX_LEV_FIELDX; x++)
- for(y=0; y<MAX_LEV_FIELDY; y++)
+ for (x = 0; x < MAX_LEV_FIELDX; x++)
+ for (y = 0; y < MAX_LEV_FIELDY; y++)
Feld[x][y] = level->field[x][y];
/* initialize level size variables for faster access */
SetBorderElement();
}
-#else
-
-static void LoadLevel_InitLevel(struct LevelInfo *level, char *filename)
+void LoadLevelTemplate(int level_nr)
{
- int i, j, x, y;
+ char *filename = getLevelFilename(level_nr);
- if (leveldir_current == NULL) /* only when dumping level */
- return;
+ LoadLevelFromFilename(&level_template, filename);
- /* determine correct game engine version of current level */
- if (IS_LEVELCLASS_CONTRIBUTION(leveldir_current) ||
- IS_LEVELCLASS_USER(leveldir_current))
- {
-#if 0
- printf("\n::: This level is private or contributed: '%s'\n", filename);
-#endif
+ LoadLevel_InitVersion(&level, filename);
+ LoadLevel_InitElements(&level, filename);
- /* For user contributed and private levels, use the version of
- the game engine the levels were created for.
- Since 2.0.1, the game engine version is now directly stored
- in the level file (chunk "VERS"), so there is no need anymore
- to set the game version from the file version (except for old,
- pre-2.0 levels, where the game version is still taken from the
- file format version used to store the level -- see above). */
+ ActivateLevelTemplate();
+}
- /* 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");
+void LoadLevel(int level_nr)
+{
+ char *filename = getLevelFilename(level_nr);
- /* player was faster than monsters in (pre-)1.0 levels */
- level->double_speed = TRUE;
- }
+ LoadLevelFromFilename(&level, filename);
- /* Default behaviour for EM style gems was "slippery" only in 2.0.1 */
- if (level->game_version == VERSION_IDENT(2,0,1))
- level->em_slippery_gems = TRUE;
- }
- else
- {
-#if 0
- printf("\n::: ALWAYS USE LATEST ENGINE FOR THIS LEVEL: [%d] '%s'\n",
- leveldir_current->sort_priority, filename);
+ 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
+}
- /* Always use the latest version of the game engine for all but
- user contributed and private levels; this allows for actual
- corrections in the game engine to take effect for existing,
- converted levels (from "classic" or other existing games) to
- make the game emulation more accurate, while (hopefully) not
- breaking existing levels created from other players. */
+static void SaveLevel_VERS(FILE *file, struct LevelInfo *level)
+{
+ putFileVersion(file, level->file_version);
+ putFileVersion(file, level->game_version);
+}
- level->game_version = GAME_VERSION_ACTUAL;
+static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
+{
+ int i, x, y;
- /* Set special EM style gems behaviour: EM style gems slip down from
- normal, steel and growing wall. As this is a more fundamental change,
- it seems better to set the default behaviour to "off" (as it is more
- natural) and make it configurable in the level editor (as a property
- of gem style elements). Already existing converted levels (neither
- private nor contributed levels) are changed to the new behaviour. */
+ putFile8Bit(file, level->fieldx);
+ putFile8Bit(file, level->fieldy);
- if (level->file_version < FILE_VERSION_2_0)
- level->em_slippery_gems = TRUE;
- }
+ putFile16BitBE(file, level->time);
+ putFile16BitBE(file, level->gems_needed);
- /* 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];
+ for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
+ putFile8Bit(file, level->name[i]);
- if (level->game_version <= VERSION_IDENT(2,2,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);
- }
+ for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
+ putFile8Bit(file, level->score[i]);
- if (level->game_version < VERSION_IDENT(3,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);
- }
+ for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
+ 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]));
+ putFile8Bit(file, level->amoeba_speed);
+ putFile8Bit(file, level->time_magic_wall);
+ putFile8Bit(file, level->time_wheel);
+ putFile8Bit(file, (level->encoding_16bit_amoeba ? EL_EMPTY :
+ level->amoeba_content));
+ putFile8Bit(file, (level->double_speed ? 1 : 0));
+ putFile8Bit(file, (level->initial_gravity ? 1 : 0));
+ putFile8Bit(file, (level->encoding_16bit_field ? 1 : 0));
+ putFile8Bit(file, (level->em_slippery_gems ? 1 : 0));
- level->field[x][y] = element;
- }
- }
+ putFile8Bit(file, (level->use_custom_template ? 1 : 0));
- /* map custom element change events that have changed in newer versions
- (these following values have accidentally changed in version 3.0.1) */
- if (level->game_version <= VERSION_IDENT(3,0,0))
- {
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
- {
- int element = EL_CUSTOM_START + i;
-
- /* order of checking events to be mapped is important */
- for (j=CE_BY_OTHER; j >= CE_BY_PLAYER; j--)
- {
- if (HAS_CHANGE_EVENT(element, j - 2))
- {
- SET_CHANGE_EVENT(element, j - 2, FALSE);
- SET_CHANGE_EVENT(element, j, TRUE);
- }
- }
-
- /* order of checking events to be mapped is important */
- for (j=CE_OTHER_GETS_COLLECTED; j >= CE_COLLISION; j--)
- {
- if (HAS_CHANGE_EVENT(element, j - 1))
- {
- SET_CHANGE_EVENT(element, j - 1, FALSE);
- SET_CHANGE_EVENT(element, j, TRUE);
- }
- }
- }
- }
-
- /* initialize "can_change" field for old levels with only one change page */
- if (level->game_version <= VERSION_IDENT(3,0,2))
- {
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
- {
- int element = EL_CUSTOM_START + i;
-
- if (CAN_CHANGE(element))
- element_info[element].change->can_change = TRUE;
- }
- }
-
- /* copy elements to runtime playfield array */
- for(x=0; x<MAX_LEV_FIELDX; x++)
- for(y=0; y<MAX_LEV_FIELDY; y++)
- Feld[x][y] = level->field[x][y];
-
- /* initialize level size variables for faster access */
- lev_fieldx = level->fieldx;
- lev_fieldy = level->fieldy;
-
- /* determine border element for this level */
- SetBorderElement();
-
- /* initialize element properties for level editor etc. */
- InitElementPropertiesEngine(level->game_version);
-}
-
-#endif
-
-void LoadLevelTemplate(int level_nr)
-{
- char *filename = getLevelFilename(level_nr);
-
- LoadLevelFromFilename(&level_template, filename);
-
- LoadLevel_InitVersion(&level, filename);
- LoadLevel_InitElements(&level, filename);
-
- ActivateLevelTemplate();
-}
-
-void LoadLevel(int level_nr)
-{
- char *filename = getLevelFilename(level_nr);
-
- LoadLevelFromFilename(&level, filename);
-
- 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)
-{
- putFileVersion(file, level->file_version);
- putFileVersion(file, level->game_version);
-}
-
-static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
-{
- int i, x, y;
-
- putFile8Bit(file, level->fieldx);
- putFile8Bit(file, level->fieldy);
-
- putFile16BitBE(file, level->time);
- putFile16BitBE(file, level->gems_needed);
-
- for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
- putFile8Bit(file, level->name[i]);
-
- for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
- putFile8Bit(file, level->score[i]);
-
- for(i=0; i<STD_ELEMENT_CONTENTS; i++)
- 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]));
- putFile8Bit(file, level->amoeba_speed);
- putFile8Bit(file, level->time_magic_wall);
- putFile8Bit(file, level->time_wheel);
- putFile8Bit(file, (level->encoding_16bit_amoeba ? EL_EMPTY :
- level->amoeba_content));
- putFile8Bit(file, (level->double_speed ? 1 : 0));
- putFile8Bit(file, (level->gravity ? 1 : 0));
- putFile8Bit(file, (level->encoding_16bit_field ? 1 : 0));
- putFile8Bit(file, (level->em_slippery_gems ? 1 : 0));
-
- putFile8Bit(file, (level->use_custom_template ? 1 : 0));
-
- WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
-}
+ WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
+}
static void SaveLevel_AUTH(FILE *file, struct LevelInfo *level)
{
int i;
- for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
+ for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
putFile8Bit(file, level->author[i]);
}
{
int x, y;
- for(y=0; y<level->fieldy; y++)
- for(x=0; x<level->fieldx; x++)
+ for (y = 0; y < level->fieldy; y++)
+ for (x = 0; x < level->fieldx; x++)
if (level->encoding_16bit_field)
putFile16BitBE(file, level->field[x][y]);
else
putFile8Bit(file, 0);
putFile8Bit(file, 0);
- for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
+ 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]);
else
content_xsize = 3;
content_ysize = 3;
- for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ 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];
}
else if (element == EL_BD_AMOEBA)
content_xsize = 1;
content_ysize = 1;
- for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ 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] = EL_EMPTY;
content_array[0][0][0] = level->amoeba_content;
}
WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_UNUSED);
- for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
putFile16BitBE(file, content_array[i][x][y]);
}
+static void SaveLevel_CNT3(FILE *file, struct LevelInfo *level, int element)
+{
+ int i;
+ int envelope_nr = element - EL_ENVELOPE_1;
+ int envelope_len = strlen(level->envelope_text[envelope_nr]) + 1;
+
+ putFile16BitBE(file, element);
+ putFile16BitBE(file, envelope_len);
+ putFile8Bit(file, level->envelope_xsize[envelope_nr]);
+ putFile8Bit(file, level->envelope_ysize[envelope_nr]);
+
+ WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT3_UNUSED);
+
+ for (i = 0; i < envelope_len; i++)
+ putFile8Bit(file, level->envelope_text[envelope_nr][i]);
+}
+
#if 0
static void SaveLevel_CUS1(FILE *file, struct LevelInfo *level,
int num_changed_custom_elements)
putFile16BitBE(file, num_changed_custom_elements);
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
putFile16BitBE(file, num_changed_custom_elements);
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
}
#endif
+#if 0
static void SaveLevel_CUS3(FILE *file, struct LevelInfo *level,
int num_changed_custom_elements)
{
putFile16BitBE(file, num_changed_custom_elements);
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
{
putFile16BitBE(file, element);
- for(j=0; j<MAX_ELEMENT_NAME_LEN; j++)
+ for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
putFile8Bit(file, element_info[element].description[j]);
putFile32BitBE(file, Properties[element][EP_BITFIELD_BASE]);
putFile8Bit(file, element_info[element].move_direction_initial);
putFile8Bit(file, element_info[element].move_stepsize);
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
putFile16BitBE(file, element_info[element].content[x][y]);
putFile32BitBE(file, element_info[element].change->events);
putFile8Bit(file, element_info[element].change->random);
putFile8Bit(file, element_info[element].change->power);
- for(y=0; y<3; y++)
- for(x=0; x<3; x++)
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
putFile16BitBE(file, element_info[element].change->content[x][y]);
putFile8Bit(file, element_info[element].slippery_type);
if (check != num_changed_custom_elements) /* should not happen */
Error(ERR_WARN, "inconsistent number of custom element properties");
}
+#endif
+
+static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
+{
+ struct ElementInfo *ei = &element_info[element];
+ int i, x, y;
+
+ putFile16BitBE(file, element);
+
+ for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
+ putFile8Bit(file, ei->description[i]);
+
+ putFile32BitBE(file, Properties[element][EP_BITFIELD_BASE]);
+ WriteUnusedBytesToFile(file, 4); /* reserved for more base properties */
+
+ putFile8Bit(file, ei->num_change_pages);
+
+ /* some free bytes for future base property values and padding */
+ WriteUnusedBytesToFile(file, 5);
+
+ /* write custom property values */
+
+ putFile8Bit(file, ei->use_gfx_element);
+ putFile16BitBE(file, ei->gfx_element);
+
+ putFile8Bit(file, ei->collect_score);
+ putFile8Bit(file, ei->collect_count);
+
+ putFile16BitBE(file, ei->push_delay_fixed);
+ putFile16BitBE(file, ei->push_delay_random);
+ putFile16BitBE(file, ei->move_delay_fixed);
+ putFile16BitBE(file, ei->move_delay_random);
+
+ putFile16BitBE(file, ei->move_pattern);
+ putFile8Bit(file, ei->move_direction_initial);
+ putFile8Bit(file, ei->move_stepsize);
+
+ putFile8Bit(file, ei->slippery_type);
+
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ putFile16BitBE(file, ei->content[x][y]);
+
+ /* some free bytes for future custom property values and padding */
+ WriteUnusedBytesToFile(file, 12);
+
+ /* write change property values */
+
+ for (i = 0; i < ei->num_change_pages; i++)
+ {
+ struct ElementChangeInfo *change = &ei->change_page[i];
+
+ putFile32BitBE(file, change->events);
+
+ putFile16BitBE(file, change->target_element);
+
+ putFile16BitBE(file, change->delay_fixed);
+ putFile16BitBE(file, change->delay_random);
+ putFile16BitBE(file, change->delay_frames);
+
+ putFile16BitBE(file, change->trigger_element);
+
+ putFile8Bit(file, change->explode);
+ putFile8Bit(file, change->use_content);
+ putFile8Bit(file, change->only_complete);
+ putFile8Bit(file, change->use_random_change);
+
+ putFile8Bit(file, change->random);
+ putFile8Bit(file, change->power);
+
+ for (y = 0; y < 3; y++)
+ for (x = 0; x < 3; x++)
+ putFile16BitBE(file, change->content[x][y]);
+
+ putFile8Bit(file, change->can_change);
+
+ putFile8Bit(file, change->sides);
+
+ /* some free bytes for future change property values and padding */
+ WriteUnusedBytesToFile(file, 8);
+ }
+}
static void SaveLevelFromFilename(struct LevelInfo *level, char *filename)
{
int body_chunk_size;
- int num_changed_custom_elements = 0;
- int level_chunk_CUS3_size;
int i, x, y;
FILE *file;
/* check level field for 16-bit elements */
level->encoding_16bit_field = FALSE;
- for(y=0; y<level->fieldy; y++)
- for(x=0; x<level->fieldx; x++)
+ for (y = 0; y < level->fieldy; y++)
+ for (x = 0; x < level->fieldx; x++)
if (level->field[x][y] > 255)
level->encoding_16bit_field = TRUE;
/* check yamyam content for 16-bit elements */
level->encoding_16bit_yamyam = FALSE;
- 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++)
if (level->yamyam_content[i][x][y] > 255)
level->encoding_16bit_yamyam = TRUE;
body_chunk_size =
level->fieldx * level->fieldy * (level->encoding_16bit_field ? 2 : 1);
- /* check for non-standard custom elements and calculate "CUS3" chunk size */
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
- if (element_info[EL_CUSTOM_START + i].modified_settings)
- num_changed_custom_elements++;
- level_chunk_CUS3_size = LEVEL_CHUNK_CUS3_SIZE(num_changed_custom_elements);
-
putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
putFileChunkBE(file, "CAVE", CHUNK_SIZE_NONE);
SaveLevel_CNT2(file, level, EL_BD_AMOEBA);
}
- if (num_changed_custom_elements > 0 && !level->use_custom_template)
+ /* check for envelope content */
+ for (i = 0; i < 4; i++)
{
- putFileChunkBE(file, "CUS3", level_chunk_CUS3_size);
- SaveLevel_CUS3(file, level, num_changed_custom_elements);
+ if (strlen(level->envelope_text[i]) > 0)
+ {
+ int envelope_len = strlen(level->envelope_text[i]) + 1;
+
+ putFileChunkBE(file, "CNT3", LEVEL_CHUNK_CNT3_HEADER + envelope_len);
+ SaveLevel_CNT3(file, level, EL_ENVELOPE_1 + i);
+ }
+ }
+
+ /* check for non-default custom elements (unless using template level) */
+ if (!level->use_custom_template)
+ {
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ int element = EL_CUSTOM_START + i;
+
+ if (element_info[element].modified_settings)
+ {
+ int num_change_pages = element_info[element].num_change_pages;
+
+ putFileChunkBE(file, "CUS4", LEVEL_CHUNK_CUS4_SIZE(num_change_pages));
+ SaveLevel_CUS4(file, level, element);
+ }
+ }
}
fclose(file);
printf("\n");
printf("Amoeba Speed: %d\n", level->amoeba_speed);
printf("\n");
- printf("Gravity: %s\n", (level->gravity ? "yes" : "no"));
+ printf("Gravity: %s\n", (level->initial_gravity ? "yes" : "no"));
printf("Double Speed Movement: %s\n", (level->double_speed ? "yes" : "no"));
printf("EM style slippery gems: %s\n", (level->em_slippery_gems ? "yes" : "no"));
/* default values (also for pre-1.2 tapes) with only the first player */
tape.player_participates[0] = TRUE;
- for(i=1; i<MAX_PLAYERS; i++)
+ for (i = 1; i < MAX_PLAYERS; i++)
tape.player_participates[i] = FALSE;
/* at least one (default: the first) player participates in every tape */
/* since version 1.2, tapes store which players participate in the tape */
tape->num_participating_players = 0;
- for(i=0; i<MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_PLAYERS; i++)
{
tape->player_participates[i] = FALSE;
tape->level_identifier =
checked_realloc(tape->level_identifier, level_identifier_size);
- for(i=0; i < level_identifier_size; i++)
+ for (i = 0; i < level_identifier_size; i++)
tape->level_identifier[i] = getFile8Bit(file);
tape->level_nr = getFile16BitBE(file);
return chunk_size_expected;
}
- for(i=0; i<tape->length; i++)
+ for (i = 0; i < tape->length; i++)
{
if (i >= MAX_TAPELEN)
break;
- for(j=0; j<MAX_PLAYERS; j++)
+ for (j = 0; j < MAX_PLAYERS; j++)
{
tape->pos[i].action[j] = MV_NO_MOVING;
byte action = tape->pos[i].action[0];
int k, num_moves = 0;
- for (k=0; k<4; k++)
+ for (k = 0; k<4; k++)
{
if (action & joy_dir[k])
{
tape->pos[i + 1].delay = 1;
/* delay part */
- for(j=0; j<MAX_PLAYERS; j++)
+ for (j = 0; j < MAX_PLAYERS; j++)
tape->pos[i].action[j] = MV_NO_MOVING;
tape->pos[i].delay--;
tape.length_seconds = GetTapeLength();
#if 0
- printf("tape game version: %d\n", tape.game_version);
- printf("tape engine version: %d\n", tape.engine_version);
+ printf("::: tape game version: %d\n", tape.game_version);
+ printf("::: tape engine version: %d\n", tape.engine_version);
#endif
}
LoadTapeFromFilename(filename);
}
+void LoadSolutionTape(int level_nr)
+{
+ char *filename = getSolutionTapeFilename(level_nr);
+
+ LoadTapeFromFilename(filename);
+}
+
static void SaveTape_VERS(FILE *file, struct TapeInfo *tape)
{
putFileVersion(file, tape->file_version);
byte store_participating_players = 0;
/* set bits for participating players for compact storage */
- for(i=0; i<MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_PLAYERS; i++)
if (tape->player_participates[i])
store_participating_players |= (1 << i);
putFile16BitBE(file, level_identifier_size);
- for(i=0; i < level_identifier_size; i++)
+ for (i = 0; i < level_identifier_size; i++)
putFile8Bit(file, tape->level_identifier[i]);
putFile16BitBE(file, tape->level_nr);
{
int i, j;
- for(i=0; i<tape->length; i++)
+ for (i = 0; i < tape->length; i++)
{
- for(j=0; j<MAX_PLAYERS; j++)
+ for (j = 0; j < MAX_PLAYERS; j++)
if (tape->player_participates[j])
putFile8Bit(file, tape->pos[i].action[j]);
tape.game_version = GAME_VERSION_ACTUAL;
/* count number of participating players */
- for(i=0; i<MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_PLAYERS; i++)
if (tape.player_participates[i])
num_participating_players++;
printf("Level series identifier: '%s'\n", tape->level_identifier);
printf_line("-", 79);
- for(i=0; i<tape->length; i++)
+ for (i = 0; i < tape->length; i++)
{
if (i >= MAX_TAPELEN)
break;
printf("%03d: ", i);
- for(j=0; j<MAX_PLAYERS; j++)
+ for (j = 0; j < MAX_PLAYERS; j++)
{
if (tape->player_participates[j])
{
FILE *file;
/* always start with reliable default values */
- for(i=0; i<MAX_SCORE_ENTRIES; i++)
+ for (i = 0; i < MAX_SCORE_ENTRIES; i++)
{
strcpy(highscore[i].Name, EMPTY_PLAYER_NAME);
highscore[i].Score = 0;
return;
}
- for(i=0; i<MAX_SCORE_ENTRIES; i++)
+ for (i = 0; i < MAX_SCORE_ENTRIES; i++)
{
fscanf(file, "%d", &highscore[i].Score);
fgets(line, MAX_LINE_LEN, file);
fprintf(file, "%s\n\n", SCORE_COOKIE);
- for(i=0; i<MAX_SCORE_ENTRIES; i++)
+ for (i = 0; i < MAX_SCORE_ENTRIES; i++)
fprintf(file, "%d %s\n", highscore[i].Score, highscore[i].Name);
fclose(file);
#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_HEADLINES 9
+#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 10
+#define NUM_EDITOR_SETUP_TOKENS 12
/* shortcut setup */
#define SETUP_TOKEN_SHORTCUT_SAVE_GAME 0
{ TYPE_SWITCH, &sei.el_custom, "editor.el_custom" },
{ TYPE_SWITCH, &sei.el_custom_more, "editor.el_custom_more" },
{ TYPE_SWITCH, &sei.el_headlines, "editor.el_headlines" },
+ { TYPE_SWITCH, &sei.el_user_defined, "editor.el_user_defined" },
};
static struct TokenInfo shortcut_setup_tokens[] =
si->editor.el_custom_more = FALSE;
si->editor.el_headlines = TRUE;
+ si->editor.el_user_defined = FALSE;
si->shortcut.save_game = DEFAULT_KEY_SAVE_GAME;
si->shortcut.load_game = DEFAULT_KEY_LOAD_GAME;
si->shortcut.toggle_pause = DEFAULT_KEY_TOGGLE_PAUSE;
- for (i=0; i<MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_PLAYERS; i++)
{
si->input[i].use_joystick = FALSE;
si->input[i].joy.device_name=getStringCopy(getDeviceNameFromJoystickNr(i));
/* global setup */
si = setup;
- for (i=0; i<NUM_GLOBAL_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
setSetupInfo(global_setup_tokens, i,
getHashEntry(setup_file_hash, global_setup_tokens[i].text));
setup = si;
/* editor setup */
sei = setup.editor;
- for (i=0; i<NUM_EDITOR_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
setSetupInfo(editor_setup_tokens, i,
getHashEntry(setup_file_hash,editor_setup_tokens[i].text));
setup.editor = sei;
/* shortcut setup */
ssi = setup.shortcut;
- for (i=0; i<NUM_SHORTCUT_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
setSetupInfo(shortcut_setup_tokens, i,
getHashEntry(setup_file_hash,shortcut_setup_tokens[i].text));
setup.shortcut = ssi;
/* player setup */
- for (pnr=0; pnr<MAX_PLAYERS; pnr++)
+ for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
{
char prefix[30];
sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
sii = setup.input[pnr];
- for (i=0; i<NUM_PLAYER_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
{
char full_token[100];
/* system setup */
syi = setup.system;
- for (i=0; i<NUM_SYSTEM_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
setSetupInfo(system_setup_tokens, i,
getHashEntry(setup_file_hash, system_setup_tokens[i].text));
setup.system = syi;
/* options setup */
soi = setup.options;
- for (i=0; i<NUM_OPTIONS_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
setSetupInfo(options_setup_tokens, i,
getHashEntry(setup_file_hash, options_setup_tokens[i].text));
setup.options = soi;
/* global setup */
si = setup;
- for (i=0; i<NUM_GLOBAL_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
{
/* just to make things nicer :) */
if (i == SETUP_TOKEN_PLAYER_NAME + 1 ||
/* editor setup */
sei = setup.editor;
fprintf(file, "\n");
- for (i=0; i<NUM_EDITOR_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
fprintf(file, "%s\n", getSetupLine(editor_setup_tokens, "", i));
/* shortcut setup */
ssi = setup.shortcut;
fprintf(file, "\n");
- for (i=0; i<NUM_SHORTCUT_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
fprintf(file, "%s\n", getSetupLine(shortcut_setup_tokens, "", i));
/* player setup */
- for (pnr=0; pnr<MAX_PLAYERS; pnr++)
+ for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
{
char prefix[30];
fprintf(file, "\n");
sii = setup.input[pnr];
- for (i=0; i<NUM_PLAYER_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
fprintf(file, "%s\n", getSetupLine(player_setup_tokens, prefix, i));
}
/* system setup */
syi = setup.system;
fprintf(file, "\n");
- for (i=0; i<NUM_SYSTEM_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
fprintf(file, "%s\n", getSetupLine(system_setup_tokens, "", i));
/* options setup */
soi = setup.options;
fprintf(file, "\n");
- for (i=0; i<NUM_OPTIONS_SETUP_TOKENS; i++)
+ for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
fprintf(file, "%s\n", getSetupLine(options_setup_tokens, "", i));
fclose(file);
SetupFileHash *setup_file_hash;
int i;
- for (i=0; i<NUM_FILE_ELEMENTS; i++)
+ for (i = 0; i < NUM_FILE_ELEMENTS; i++)
{
if (element_info[i].custom_description != NULL)
{
if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
return;
- for (i=0; i<NUM_FILE_ELEMENTS; i++)
+ for (i = 0; i < NUM_FILE_ELEMENTS; i++)
{
char *token = getStringCat2(element_info[i].token_name, ".name");
char *value = getHashEntry(setup_file_hash, token);
int i, j;
/* always start with reliable default values from default config */
- for (i=0; image_config_vars[i].token != NULL; i++)
- for (j=0; image_config[j].token != NULL; j++)
+ for (i = 0; image_config_vars[i].token != NULL; i++)
+ for (j = 0; image_config[j].token != NULL; j++)
if (strcmp(image_config_vars[i].token, image_config[j].token) == 0)
*image_config_vars[i].value =
- get_integer_from_string(image_config[j].value);
+ get_auto_parameter_value(image_config_vars[i].token,
+ image_config[j].value);
if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
return;
/* special case: initialize with default values that may be overwritten */
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
{
char *value_x = getHashEntry(setup_file_hash, "menu.draw_xoffset");
char *value_y = getHashEntry(setup_file_hash, "menu.draw_yoffset");
}
/* read (and overwrite with) values that may be specified in config file */
- for (i=0; image_config_vars[i].token != NULL; i++)
+ for (i = 0; image_config_vars[i].token != NULL; i++)
{
char *value = getHashEntry(setup_file_hash, image_config_vars[i].token);
if (value != NULL)
- *image_config_vars[i].value = get_integer_from_string(value);
+ *image_config_vars[i].value =
+ get_auto_parameter_value(image_config_vars[i].token, value);
}
freeSetupFileHash(setup_file_hash);
}
+
+void LoadUserDefinedEditorElementList(int **elements, int *num_elements)
+{
+ char *filename = getEditorSetupFilename();
+ SetupFileList *setup_file_list, *list;
+ SetupFileHash *element_hash;
+ int num_unknown_tokens = 0;
+ int i;
+
+ if ((setup_file_list = loadSetupFileList(filename)) == NULL)
+ return;
+
+ element_hash = newSetupFileHash();
+
+ for (i = 0; i < NUM_FILE_ELEMENTS; i++)
+ setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
+
+ /* determined size may be larger than needed (due to unknown elements) */
+ *num_elements = 0;
+ for (list = setup_file_list; list != NULL; list = list->next)
+ (*num_elements)++;
+
+ /* add space for up to 3 more elements for padding that may be needed */
+ *num_elements += 3;
+
+ *elements = checked_malloc(*num_elements * sizeof(int));
+
+ *num_elements = 0;
+ for (list = setup_file_list; list != NULL; list = list->next)
+ {
+ char *value = getHashEntry(element_hash, list->token);
+
+ if (value)
+ {
+ (*elements)[(*num_elements)++] = atoi(value);
+ }
+ else
+ {
+ if (num_unknown_tokens == 0)
+ {
+ Error(ERR_RETURN_LINE, "-");
+ Error(ERR_RETURN, "warning: unknown token(s) found in config file:");
+ Error(ERR_RETURN, "- config file: '%s'", filename);
+
+ num_unknown_tokens++;
+ }
+
+ Error(ERR_RETURN, "- token: '%s'", list->token);
+ }
+ }
+
+ if (num_unknown_tokens > 0)
+ Error(ERR_RETURN_LINE, "-");
+
+ while (*num_elements % 4) /* pad with empty elements, if needed */
+ (*elements)[(*num_elements)++] = EL_EMPTY;
+
+ freeSetupFileList(setup_file_list);
+ 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]);
+#endif
+}
+
+static struct MusicFileInfo *get_music_file_info_ext(char *basename, int music,
+ boolean is_sound)
+{
+ SetupFileHash *setup_file_hash = NULL;
+ struct MusicFileInfo tmp_music_file_info, *new_music_file_info;
+ char *filename_music, *filename_prefix, *filename_info;
+ struct
+ {
+ char *token;
+ char **value_ptr;
+ }
+ token_to_value_ptr[] =
+ {
+ { "title_header", &tmp_music_file_info.title_header },
+ { "artist_header", &tmp_music_file_info.artist_header },
+ { "album_header", &tmp_music_file_info.album_header },
+ { "year_header", &tmp_music_file_info.year_header },
+
+ { "title", &tmp_music_file_info.title },
+ { "artist", &tmp_music_file_info.artist },
+ { "album", &tmp_music_file_info.album },
+ { "year", &tmp_music_file_info.year },
+
+ { NULL, NULL },
+ };
+ int i;
+
+ filename_music = (is_sound ? getCustomSoundFilename(basename) :
+ getCustomMusicFilename(basename));
+
+ if (filename_music == NULL)
+ return NULL;
+
+ /* ---------- try to replace file extension ---------- */
+
+ filename_prefix = getStringCopy(filename_music);
+ if (strrchr(filename_prefix, '.') != NULL)
+ *strrchr(filename_prefix, '.') = '\0';
+ filename_info = getStringCat2(filename_prefix, ".txt");
+
+#if 0
+ printf("trying to load file '%s'...\n", filename_info);
+#endif
+
+ if (fileExists(filename_info))
+ setup_file_hash = loadSetupFileHash(filename_info);
+
+ free(filename_prefix);
+ free(filename_info);
+
+ if (setup_file_hash == NULL)
+ {
+ /* ---------- try to add file extension ---------- */
+
+ filename_prefix = getStringCopy(filename_music);
+ filename_info = getStringCat2(filename_prefix, ".txt");
+
+#if 0
+ printf("trying to load file '%s'...\n", filename_info);
+#endif
+
+ if (fileExists(filename_info))
+ setup_file_hash = loadSetupFileHash(filename_info);
+
+ free(filename_prefix);
+ free(filename_info);
+ }
+
+ if (setup_file_hash == NULL)
+ return NULL;
+
+ /* ---------- music file info found ---------- */
+
+ memset(&tmp_music_file_info, 0, sizeof(struct MusicFileInfo));
+
+ for (i = 0; token_to_value_ptr[i].token != NULL; i++)
+ {
+ char *value = getHashEntry(setup_file_hash, token_to_value_ptr[i].token);
+
+ *token_to_value_ptr[i].value_ptr =
+ getStringCopy(value != NULL && *value != '\0' ? value : UNKNOWN_NAME);
+ }
+
+ tmp_music_file_info.basename = getStringCopy(basename);
+ tmp_music_file_info.music = music;
+ tmp_music_file_info.is_sound = is_sound;
+
+ new_music_file_info = checked_malloc(sizeof(struct MusicFileInfo));
+ *new_music_file_info = tmp_music_file_info;
+
+ return new_music_file_info;
+}
+
+static struct MusicFileInfo *get_music_file_info(char *basename, int music)
+{
+ return get_music_file_info_ext(basename, music, FALSE);
+}
+
+static struct MusicFileInfo *get_sound_file_info(char *basename, int sound)
+{
+ return get_music_file_info_ext(basename, sound, TRUE);
+}
+
+static boolean music_info_listed_ext(struct MusicFileInfo *list,
+ char *basename, boolean is_sound)
+{
+ for (; list != NULL; list = list->next)
+ if (list->is_sound == is_sound && strcmp(list->basename, basename) == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+static boolean music_info_listed(struct MusicFileInfo *list, char *basename)
+{
+ return music_info_listed_ext(list, basename, FALSE);
+}
+
+static boolean sound_info_listed(struct MusicFileInfo *list, char *basename)
+{
+ return music_info_listed_ext(list, basename, TRUE);
+}
+
+void LoadMusicInfo()
+{
+ char *music_directory = getCustomMusicDirectory();
+ int num_music = getMusicListSize();
+ int num_music_noconf = 0;
+ int num_sounds = getSoundListSize();
+ DIR *dir;
+ struct dirent *dir_entry;
+ struct FileInfo *music, *sound;
+ struct MusicFileInfo *next, **new;
+ int i;
+
+ while (music_file_info != NULL)
+ {
+ next = music_file_info->next;
+
+ checked_free(music_file_info->basename);
+
+ checked_free(music_file_info->title_header);
+ checked_free(music_file_info->artist_header);
+ checked_free(music_file_info->album_header);
+ checked_free(music_file_info->year_header);
+
+ checked_free(music_file_info->title);
+ checked_free(music_file_info->artist);
+ checked_free(music_file_info->album);
+ checked_free(music_file_info->year);
+
+ free(music_file_info);
+
+ music_file_info = next;
+ }
+
+ 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 (strcmp(music->filename, UNDEFINED_FILENAME) == 0)
+ continue;
+
+ /* a configured file may be not recognized as music */
+ if (!FileIsMusic(music->filename))
+ continue;
+
+#if 0
+ printf("::: -> '%s' (configured)\n", music->filename);
+#endif
+
+ if (!music_info_listed(music_file_info, music->filename))
+ {
+ *new = get_music_file_info(music->filename, i);
+ if (*new != NULL)
+ new = &(*new)->next;
+ }
+ }
+
+ if ((dir = opendir(music_directory)) == NULL)
+ {
+ Error(ERR_WARN, "cannot read music directory '%s'", music_directory);
+ return;
+ }
+
+ while ((dir_entry = readdir(dir)) != NULL) /* loop until last dir entry */
+ {
+ char *basename = dir_entry->d_name;
+ boolean music_already_used = FALSE;
+ int i;
+
+ for (i = 0; i < num_music; i++)
+ {
+ music = getMusicListEntry(i);
+
+ if (music->filename == NULL)
+ continue;
+
+ if (strcmp(basename, music->filename) == 0)
+ {
+ music_already_used = TRUE;
+ break;
+ }
+ }
+
+ if (music_already_used)
+ continue;
+
+ if (!FileIsMusic(basename))
+ continue;
+
+#if 0
+ printf("::: -> '%s' (found in directory)\n", basename);
+#endif
+
+ if (!music_info_listed(music_file_info, basename))
+ {
+ *new = get_music_file_info(basename, MAP_NOCONF_MUSIC(num_music_noconf));
+ if (*new != NULL)
+ new = &(*new)->next;
+ }
+
+ num_music_noconf++;
+ }
+
+ closedir(dir);
+
+ for (i = 0; i < num_sounds; i++)
+ {
+ sound = getSoundListEntry(i);
+
+ if (sound->filename == NULL)
+ continue;
+
+ if (strcmp(sound->filename, UNDEFINED_FILENAME) == 0)
+ continue;
+
+ /* a configured file may be not recognized as sound */
+ if (!FileIsSound(sound->filename))
+ continue;
+
+#if 0
+ printf("::: -> '%s' (configured)\n", sound->filename);
+#endif
+
+ if (!sound_info_listed(music_file_info, sound->filename))
+ {
+ *new = get_sound_file_info(sound->filename, i);
+ if (*new != NULL)
+ new = &(*new)->next;
+ }
+ }
+
+#if 0
+ /* TEST-ONLY */
+ for (next = music_file_info; next != NULL; next = next->next)
+ printf("::: title == '%s'\n", next->title);
+#endif
+}
+
+void add_helpanim_entry(int element, int action, int direction, int delay,
+ int *num_list_entries)
+{
+ struct HelpAnimInfo *new_list_entry;
+ (*num_list_entries)++;
+
+ helpanim_info =
+ checked_realloc(helpanim_info,
+ *num_list_entries * sizeof(struct HelpAnimInfo));
+ new_list_entry = &helpanim_info[*num_list_entries - 1];
+
+ new_list_entry->element = element;
+ new_list_entry->action = action;
+ new_list_entry->direction = direction;
+ new_list_entry->delay = delay;
+}
+
+void print_unknown_token(char *filename, char *token, int token_nr)
+{
+ if (token_nr == 0)
+ {
+ Error(ERR_RETURN_LINE, "-");
+ Error(ERR_RETURN, "warning: unknown token(s) found in config file:");
+ Error(ERR_RETURN, "- config file: '%s'", filename);
+ }
+
+ Error(ERR_RETURN, "- token: '%s'", token);
+}
+
+void print_unknown_token_end(int token_nr)
+{
+ if (token_nr > 0)
+ Error(ERR_RETURN_LINE, "-");
+}
+
+void LoadHelpAnimInfo()
+{
+ char *filename = getHelpAnimFilename();
+ SetupFileList *setup_file_list = NULL, *list;
+ SetupFileHash *element_hash, *action_hash, *direction_hash;
+ int num_list_entries = 0;
+ int num_unknown_tokens = 0;
+ int i;
+
+ if (fileExists(filename))
+ setup_file_list = loadSetupFileList(filename);
+
+ if (setup_file_list == NULL)
+ {
+ /* use reliable default values from static configuration */
+ SetupFileList *insert_ptr;
+
+ insert_ptr = setup_file_list =
+ newSetupFileList(helpanim_config[0].token,
+ helpanim_config[0].value);
+
+ for (i = 1; helpanim_config[i].token; i++)
+ insert_ptr = addListEntry(insert_ptr,
+ helpanim_config[i].token,
+ helpanim_config[i].value);
+ }
+
+ element_hash = newSetupFileHash();
+ action_hash = newSetupFileHash();
+ direction_hash = newSetupFileHash();
+
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
+
+ for (i = 0; i < NUM_ACTIONS; i++)
+ setHashEntry(action_hash, element_action_info[i].suffix,
+ i_to_a(element_action_info[i].value));
+
+ /* do not store direction index (bit) here, but direction value! */
+ for (i = 0; i < NUM_DIRECTIONS; i++)
+ setHashEntry(direction_hash, element_direction_info[i].suffix,
+ i_to_a(1 << element_direction_info[i].value));
+
+ for (list = setup_file_list; list != NULL; list = list->next)
+ {
+ char *element_token, *action_token, *direction_token;
+ char *element_value, *action_value, *direction_value;
+ int delay = atoi(list->value);
+
+ if (strcmp(list->token, "end") == 0)
+ {
+ add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
+
+ continue;
+ }
+
+ /* first try to break element into element/action/direction parts;
+ if this does not work, also accept combined "element[.act][.dir]"
+ elements (like "dynamite.active"), which are unique elements */
+
+ if (strchr(list->token, '.') == NULL) /* token contains no '.' */
+ {
+ element_value = getHashEntry(element_hash, list->token);
+ if (element_value != NULL) /* element found */
+ add_helpanim_entry(atoi(element_value), -1, -1, delay,
+ &num_list_entries);
+ else
+ {
+ /* no further suffixes found -- this is not an element */
+ print_unknown_token(filename, list->token, num_unknown_tokens++);
+ }
+
+ continue;
+ }
+
+ /* token has format "<prefix>.<something>" */
+
+ action_token = strchr(list->token, '.'); /* suffix may be action ... */
+ direction_token = action_token; /* ... or direction */
+
+ element_token = getStringCopy(list->token);
+ *strchr(element_token, '.') = '\0';
+
+ element_value = getHashEntry(element_hash, element_token);
+
+ if (element_value == NULL) /* this is no element */
+ {
+ element_value = getHashEntry(element_hash, list->token);
+ if (element_value != NULL) /* combined element found */
+ add_helpanim_entry(atoi(element_value), -1, -1, delay,
+ &num_list_entries);
+ else
+ print_unknown_token(filename, list->token, num_unknown_tokens++);
+
+ free(element_token);
+
+ continue;
+ }
+
+ action_value = getHashEntry(action_hash, action_token);
+
+ if (action_value != NULL) /* action found */
+ {
+ add_helpanim_entry(atoi(element_value), atoi(action_value), -1, delay,
+ &num_list_entries);
+
+ free(element_token);
+
+ continue;
+ }
+
+ direction_value = getHashEntry(direction_hash, direction_token);
+
+ if (direction_value != NULL) /* direction found */
+ {
+ add_helpanim_entry(atoi(element_value), -1, atoi(direction_value), delay,
+ &num_list_entries);
+
+ free(element_token);
+
+ continue;
+ }
+
+ if (strchr(action_token + 1, '.') == NULL)
+ {
+ /* no further suffixes found -- this is not an action nor direction */
+
+ element_value = getHashEntry(element_hash, list->token);
+ if (element_value != NULL) /* combined element found */
+ add_helpanim_entry(atoi(element_value), -1, -1, delay,
+ &num_list_entries);
+ else
+ print_unknown_token(filename, list->token, num_unknown_tokens++);
+
+ free(element_token);
+
+ continue;
+ }
+
+ /* token has format "<prefix>.<suffix>.<something>" */
+
+ direction_token = strchr(action_token + 1, '.');
+
+ action_token = getStringCopy(action_token);
+ *strchr(action_token + 1, '.') = '\0';
+
+ action_value = getHashEntry(action_hash, action_token);
+
+ if (action_value == NULL) /* this is no action */
+ {
+ element_value = getHashEntry(element_hash, list->token);
+ if (element_value != NULL) /* combined element found */
+ add_helpanim_entry(atoi(element_value), -1, -1, delay,
+ &num_list_entries);
+ else
+ print_unknown_token(filename, list->token, num_unknown_tokens++);
+
+ free(element_token);
+ free(action_token);
+
+ continue;
+ }
+
+ direction_value = getHashEntry(direction_hash, direction_token);
+
+ if (direction_value != NULL) /* direction found */
+ {
+ add_helpanim_entry(atoi(element_value), atoi(action_value),
+ atoi(direction_value), delay, &num_list_entries);
+
+ free(element_token);
+ free(action_token);
+
+ continue;
+ }
+
+ /* this is no direction */
+
+ element_value = getHashEntry(element_hash, list->token);
+ if (element_value != NULL) /* combined element found */
+ add_helpanim_entry(atoi(element_value), -1, -1, delay,
+ &num_list_entries);
+ else
+ print_unknown_token(filename, list->token, num_unknown_tokens++);
+
+ free(element_token);
+ free(action_token);
+ }
+
+ print_unknown_token_end(num_unknown_tokens);
+
+ add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
+ add_helpanim_entry(HELPANIM_LIST_END, -1, -1, -1, &num_list_entries);
+
+ freeSetupFileList(setup_file_list);
+ freeSetupFileHash(element_hash);
+ freeSetupFileHash(action_hash);
+ 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,
+ helpanim_info[i].action,
+ helpanim_info[i].direction,
+ helpanim_info[i].delay);
+#endif
+}
+
+void LoadHelpTextInfo()
+{
+ char *filename = getHelpTextFilename();
+ int i;
+
+ if (helptext_info != NULL)
+ {
+ freeSetupFileHash(helptext_info);
+ helptext_info = NULL;
+ }
+
+ if (fileExists(filename))
+ helptext_info = loadSetupFileHash(filename);
+
+ if (helptext_info == NULL)
+ {
+ /* use reliable default values from static configuration */
+ helptext_info = newSetupFileHash();
+
+ for (i = 0; helptext_config[i].token; i++)
+ setHashEntry(helptext_info,
+ helptext_config[i].token,
+ helptext_config[i].value);
+ }
+
+#if 0
+ /* TEST ONLY */
+ BEGIN_HASH_ITERATION(helptext_info, itr)
+ {
+ printf("::: '%s' => '%s'\n",
+ HASH_ITERATION_TOKEN(itr), HASH_ITERATION_VALUE(itr));
+ }
+ END_HASH_ITERATION(hash, itr)
+#endif
+}
projects / rocksndiamonds.git / blobdiff