X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ffiles.c;h=ea16938953a6365c12e4a7d7a6a309f027049440;hb=12d0853b94327eae62e9ff35f66c6a71976bbab0;hp=890ca1ce2caad450c89f080b84496e5ed5297514;hpb=b180608242f0190c6c8b31772e4dcfce2e9af47c;p=rocksndiamonds.git diff --git a/src/files.c b/src/files.c index 890ca1ce..ea169389 100644 --- a/src/files.c +++ b/src/files.c @@ -64,24 +64,36 @@ #define CONF_VALUE_INTEGER_2 (CONF_MASK_1_BYTE | 2) #define CONF_VALUE_INTEGER_3 (CONF_MASK_1_BYTE | 3) #define CONF_VALUE_INTEGER_4 (CONF_MASK_1_BYTE | 4) -#define CONF_VALUE_BOOLEAN_1 (CONF_MASK_1_BYTE | 5) -#define CONF_VALUE_BOOLEAN_2 (CONF_MASK_1_BYTE | 6) -#define CONF_VALUE_BOOLEAN_3 (CONF_MASK_1_BYTE | 7) -#define CONF_VALUE_BOOLEAN_4 (CONF_MASK_1_BYTE | 8) +#define CONF_VALUE_INTEGER_5 (CONF_MASK_1_BYTE | 5) +#define CONF_VALUE_INTEGER_6 (CONF_MASK_1_BYTE | 6) +#define CONF_VALUE_INTEGER_7 (CONF_MASK_1_BYTE | 7) +#define CONF_VALUE_INTEGER_8 (CONF_MASK_1_BYTE | 8) +#define CONF_VALUE_BOOLEAN_1 (CONF_MASK_1_BYTE | 9) +#define CONF_VALUE_BOOLEAN_2 (CONF_MASK_1_BYTE | 10) +#define CONF_VALUE_BOOLEAN_3 (CONF_MASK_1_BYTE | 11) +#define CONF_VALUE_BOOLEAN_4 (CONF_MASK_1_BYTE | 12) +#define CONF_VALUE_BOOLEAN_5 (CONF_MASK_1_BYTE | 13) +#define CONF_VALUE_BOOLEAN_6 (CONF_MASK_1_BYTE | 14) +#define CONF_VALUE_BOOLEAN_7 (CONF_MASK_1_BYTE | 15) +#define CONF_VALUE_BOOLEAN_8 (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_ELEMENT_3 (CONF_MASK_2_BYTE | 3) #define CONF_VALUE_ELEMENT_4 (CONF_MASK_2_BYTE | 4) +#define CONF_VALUE_ELEMENT_5 (CONF_MASK_2_BYTE | 5) +#define CONF_VALUE_ELEMENT_6 (CONF_MASK_2_BYTE | 6) +#define CONF_VALUE_ELEMENT_7 (CONF_MASK_2_BYTE | 7) +#define CONF_VALUE_ELEMENT_8 (CONF_MASK_2_BYTE | 8) -#define CONF_VALUE_CONTENT_1 (CONF_MASK_MULTI_BYTES | 1) -#define CONF_VALUE_CONTENT_8 (CONF_MASK_MULTI_BYTES | 2) +#define CONF_VALUE_ELEMENTS (CONF_MASK_MULTI_BYTES | 1) +#define CONF_VALUE_CONTENTS (CONF_MASK_MULTI_BYTES | 2) #define CONF_VALUE_INTEGER(x) ((x) >= CONF_VALUE_INTEGER_1 && \ - (x) <= CONF_VALUE_INTEGER_4) + (x) <= CONF_VALUE_INTEGER_8) #define CONF_VALUE_BOOLEAN(x) ((x) >= CONF_VALUE_BOOLEAN_1 && \ - (x) <= CONF_VALUE_BOOLEAN_4) + (x) <= CONF_VALUE_BOOLEAN_8) #define CONF_VALUE_NUM_BYTES(x) ((x) == CONF_MASK_1_BYTE ? 1 : \ (x) == CONF_MASK_2_BYTE ? 2 : \ @@ -89,24 +101,43 @@ #define CONF_CONTENT_NUM_ELEMENTS (3 * 3) #define CONF_CONTENT_NUM_BYTES (CONF_CONTENT_NUM_ELEMENTS * 2) +#define CONF_ELEMENT_NUM_BYTES (2) + +#define CONF_ENTITY_NUM_BYTES(t) ((t) == CONF_VALUE_ELEMENTS ? \ + CONF_ELEMENT_NUM_BYTES : \ + (t) == CONF_VALUE_CONTENTS ? \ + CONF_CONTENT_NUM_BYTES : 1) + +#define CONF_ELEMENT_BYTE_POS(i) ((i) * CONF_ELEMENT_NUM_BYTES) +#define CONF_ELEMENTS_ELEMENT(b,i) ((b[CONF_ELEMENT_BYTE_POS(i)] << 8) | \ + (b[CONF_ELEMENT_BYTE_POS(i) + 1])) #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])) +#define CONF_CONTENT_BYTE_POS(c,x,y) (CONF_CONTENT_ELEMENT_POS(c,x,y) * \ + CONF_ELEMENT_NUM_BYTES) +#define CONF_CONTENTS_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; - int default_value; + int element; /* element for which data is to be stored */ + int type; /* type of data to be stored */ + + /* (mandatory) */ + void *value; /* variable that holds the data to be stored */ + int default_value; /* initial default value for this variable */ + + /* (optional) */ + void *num_entities; /* number of entities for multi-byte data */ + int default_num_entities; /* default number of entities for this data */ + int max_num_entities; /* maximal number of entities for this data */ } element_conf[] = { /* ---------- 1-byte values ---------------------------------------------- */ + { EL_EMC_ANDROID, CONF_VALUE_INTEGER_1, &li.android_move_time, 10 @@ -115,10 +146,6 @@ static struct EL_EMC_ANDROID, CONF_VALUE_INTEGER_2, &li.android_clone_time, 10 }, - { - EL_EMC_MAGIC_BALL, CONF_VALUE_INTEGER_1, - &li.ball_time, 10 - }, { EL_EMC_LENSES, CONF_VALUE_INTEGER_1, &li.lenses_score, 10 @@ -227,8 +254,57 @@ static struct EL_PLAYER_4, CONF_VALUE_BOOLEAN_2, &li.use_start_element[3], FALSE }, + { + EL_PLAYER_1, CONF_VALUE_BOOLEAN_3, + &li.use_artwork_element[0], FALSE + }, + { + EL_PLAYER_2, CONF_VALUE_BOOLEAN_3, + &li.use_artwork_element[1], FALSE + }, + { + EL_PLAYER_3, CONF_VALUE_BOOLEAN_3, + &li.use_artwork_element[2], FALSE + }, + { + EL_PLAYER_4, CONF_VALUE_BOOLEAN_3, + &li.use_artwork_element[3], FALSE + }, + { + EL_PLAYER_1, CONF_VALUE_BOOLEAN_4, + &li.use_explosion_element[0], FALSE + }, + { + EL_PLAYER_2, CONF_VALUE_BOOLEAN_4, + &li.use_explosion_element[1], FALSE + }, + { + EL_PLAYER_3, CONF_VALUE_BOOLEAN_4, + &li.use_explosion_element[2], FALSE + }, + { + EL_PLAYER_4, CONF_VALUE_BOOLEAN_4, + &li.use_explosion_element[3], FALSE + }, + { + EL_PLAYER_1, CONF_VALUE_INTEGER_1, + &li.initial_player_stepsize, STEPSIZE_NORMAL + }, + { + EL_EMC_MAGIC_BALL, CONF_VALUE_INTEGER_1, + &li.ball_time, 10 + }, + { + EL_EMC_MAGIC_BALL, CONF_VALUE_BOOLEAN_1, + &li.ball_random, FALSE + }, + { + EL_EMC_MAGIC_BALL, CONF_VALUE_BOOLEAN_2, + &li.ball_state_initial, FALSE + }, /* ---------- 2-byte values ---------------------------------------------- */ + { EL_PLAYER_1, CONF_VALUE_ELEMENT_1, &li.start_element[0], EL_PLAYER_1 @@ -245,16 +321,55 @@ static struct EL_PLAYER_4, CONF_VALUE_ELEMENT_1, &li.start_element[3], EL_PLAYER_4 }, + { + EL_PLAYER_1, CONF_VALUE_ELEMENT_2, + &li.artwork_element[0], EL_PLAYER_1 + }, + { + EL_PLAYER_2, CONF_VALUE_ELEMENT_2, + &li.artwork_element[1], EL_PLAYER_2 + }, + { + EL_PLAYER_3, CONF_VALUE_ELEMENT_2, + &li.artwork_element[2], EL_PLAYER_3 + }, + { + EL_PLAYER_4, CONF_VALUE_ELEMENT_2, + &li.artwork_element[3], EL_PLAYER_4 + }, + { + EL_PLAYER_1, CONF_VALUE_ELEMENT_3, + &li.explosion_element[0], EL_PLAYER_1 + }, + { + EL_PLAYER_2, CONF_VALUE_ELEMENT_3, + &li.explosion_element[1], EL_PLAYER_2 + }, + { + EL_PLAYER_3, CONF_VALUE_ELEMENT_3, + &li.explosion_element[2], EL_PLAYER_3 + }, + { + EL_PLAYER_4, CONF_VALUE_ELEMENT_3, + &li.explosion_element[3], EL_PLAYER_4 + }, /* ---------- multi-byte values ------------------------------------------ */ + + { + EL_EMC_MAGIC_BALL, CONF_VALUE_CONTENTS, + &li.ball_content, EL_EMPTY, + &li.num_ball_contents, 4, MAX_ELEMENT_CONTENTS + }, { - EL_EMC_MAGIC_BALL, CONF_VALUE_CONTENT_8, - &li.ball_content, EL_EMPTY + EL_EMC_ANDROID, CONF_VALUE_ELEMENTS, + &li.android_clone_element[0], EL_EMPTY, + &li.num_android_clone_elements, 1, MAX_ANDROID_ELEMENTS }, { -1, -1, - NULL, -1 + NULL, -1, }, }; @@ -292,23 +407,39 @@ static void setLevelInfoToDefaultsFromConfigList(struct LevelInfo *level) int type = element_conf[i].type; int bytes = type & CONF_MASK_BYTES; - if (bytes != CONF_MASK_MULTI_BYTES) + if (bytes == CONF_MASK_MULTI_BYTES) + { + int default_num_entities = element_conf[i].default_num_entities; + int max_num_entities = element_conf[i].max_num_entities; + + *(int *)(element_conf[i].num_entities) = default_num_entities; + + if (type == CONF_VALUE_ELEMENTS) + { + int *element_array = (int *)(element_conf[i].value); + int j; + + for (j = 0; j < max_num_entities; j++) + element_array[j] = default_value; + } + else if (type == CONF_VALUE_CONTENTS) + { + struct Content *content = (struct Content *)(element_conf[i].value); + int c, x, y; + + for (c = 0; c < max_num_entities; c++) + for (y = 0; y < 3; y++) + for (x = 0; x < 3; x++) + content[c].e[x][y] = default_value; + } + } + else /* constant size configuration data (1, 2 or 4 bytes) */ { if (CONF_VALUE_BOOLEAN(type)) *(boolean *)(element_conf[i].value) = default_value; else *(int *) (element_conf[i].value) = default_value; } - else if (type == CONF_VALUE_CONTENT_8) - { - struct Content *content = (struct Content *)(element_conf[i].value); - int c, x, y; - - for (c = 0; c < MAX_ELEMENT_CONTENTS; c++) - for (y = 0; y < 3; y++) - for (x = 0; x < 3; x++) - content[c].e[x][y] = default_value; - } } *level = li; /* copy temporary buffer back to level information */ @@ -379,6 +510,10 @@ static void setLevelInfoToDefaults(struct LevelInfo *level) static boolean clipboard_elements_initialized = FALSE; int i, j, x, y; +#if 1 + InitElementPropertiesStatic(); +#endif + setLevelInfoToDefaultsFromConfigList(level); setLevelInfoToDefaults_EM(); @@ -424,7 +559,9 @@ static void setLevelInfoToDefaults(struct LevelInfo *level) level->biomaze[2] = 3; level->biomaze[3] = 3; +#if 0 level->double_speed = FALSE; +#endif level->initial_gravity = FALSE; level->em_slippery_gems = FALSE; level->instant_relocation = FALSE; @@ -455,17 +592,17 @@ static void setLevelInfoToDefaults(struct LevelInfo *level) level->magnify_time = 10; level->slurp_score = 10; level->wind_direction_initial = MV_NONE; -#endif level->ball_random = FALSE; level->ball_state_initial = FALSE; -#if 0 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; #endif +#if 0 for (i = 0; i < 16; i++) level->android_array[i] = FALSE; +#endif level->use_custom_template = FALSE; @@ -577,9 +714,13 @@ static void setLevelInfoToDefaults(struct LevelInfo *level) ei->current_change_page = 0; +#if 0 + /* !!! now done in InitElementPropertiesStatic() (see above) !!! */ + /* !!! (else properties set there will be overwritten here) !!! */ /* start with no properties at all */ for (j = 0; j < NUM_EP_BITFIELDS; j++) Properties[element][j] = EP_BITMASK_DEFAULT; +#endif /* now set default properties */ SET_PROPERTY(element, EP_CAN_MOVE_INTO_ACID, TRUE); @@ -1038,7 +1179,10 @@ static int LoadLevel_HEAD(FILE *file, int chunk_size, struct LevelInfo *level) level->time_magic_wall = getFile8Bit(file); level->time_wheel = getFile8Bit(file); level->amoeba_content = getMappedElement(getFile8Bit(file)); - level->double_speed = (getFile8Bit(file) == 1 ? TRUE : FALSE); + + level->initial_player_stepsize = (getFile8Bit(file) == 1 ? STEPSIZE_FAST : + STEPSIZE_NORMAL); + 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); @@ -1582,19 +1726,41 @@ static int LoadLevel_CONF(FILE *file, int chunk_size, struct LevelInfo *level) if (element_conf[i].element == element && element_conf[i].type == type) { + int num_entities = num_bytes / CONF_ENTITY_NUM_BYTES(type); + int max_num_entities = element_conf[i].max_num_entities; + + if (num_entities > max_num_entities) + { + Error(ERR_WARN, + "truncating number of entities for element %d from %d to %d", + element, num_entities, max_num_entities); + + num_entities = max_num_entities; + } + + *(int *)(element_conf[i].num_entities) = num_entities; + element_found = TRUE; - if (type == CONF_VALUE_CONTENT_8) + if (type == CONF_VALUE_ELEMENTS) + { + int *element_array = (int *)(element_conf[i].value); + int j; + + for (j = 0; j < num_entities; j++) + element_array[j] = + getMappedElement(CONF_ELEMENTS_ELEMENT(buffer, j)); + } + else if (type == CONF_VALUE_CONTENTS) { 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 (c = 0; c < num_entities; 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)); + getMappedElement(CONF_CONTENTS_ELEMENT(buffer, c, x, y)); } else element_found = FALSE; @@ -1607,7 +1773,7 @@ static int LoadLevel_CONF(FILE *file, int chunk_size, struct LevelInfo *level) real_chunk_size += 2 + num_bytes; } - else + else /* constant size configuration data (1, 2 or 4 bytes) */ { int value = (bytes == CONF_MASK_1_BYTE ? getFile8Bit (file) : bytes == CONF_MASK_2_BYTE ? getFile16BitBE(file) : @@ -2223,10 +2389,17 @@ void CopyNativeLevel_RND_to_EM(struct LevelInfo *level) }; 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; + struct PLAYER **ply = level_em->ply; int i, j, x, y; +#if 0 + printf("::: A\n"); + for (i = 0; i < MAX_ELEMENT_CONTENTS; i++) + for (j = 0; j < 8; j++) + printf("::: ball %d, %d: %d\n", i, j, + level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); +#endif + lev->width = MIN(level->fieldx, EM_MAX_CAVE_WIDTH); lev->height = MIN(level->fieldy, EM_MAX_CAVE_HEIGHT); @@ -2259,6 +2432,7 @@ void CopyNativeLevel_RND_to_EM(struct LevelInfo *level) lev->ball_random = level->ball_random; lev->ball_state_initial = level->ball_state_initial; lev->ball_time = level->ball_time; + lev->num_ball_arrays = level->num_ball_contents; lev->lenses_score = level->lenses_score; lev->magnify_score = level->magnify_score; @@ -2278,8 +2452,19 @@ void CopyNativeLevel_RND_to_EM(struct LevelInfo *level) map_element_RND_to_EM(level-> ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); +#if 0 + for (i = 0; i < MAX_ELEMENT_CONTENTS; i++) + for (j = 0; j < 8; j++) + printf("::: ball %d, %d: %d\n", i, j, + level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); +#endif + + map_android_clone_elements_RND_to_EM(level); + +#if 0 for (i = 0; i < 16; i++) lev->android_array[i] = FALSE; /* !!! YET TO COME !!! */ +#endif /* first fill the complete playfield with the default border element */ for (y = 0; y < EM_MAX_CAVE_HEIGHT; y++) @@ -2297,15 +2482,52 @@ void CopyNativeLevel_RND_to_EM(struct LevelInfo *level) level_em->cave[x + 1][y + 1] = new_element; } +#if 1 + + for (i = 0; i < MAX_PLAYERS; i++) + { + ply[i]->x_initial = 0; + ply[i]->y_initial = 0; + } + +#else + ply1->x_initial = 0; ply1->y_initial = 0; ply2->x_initial = 0; ply2->y_initial = 0; +#endif + /* initialize player positions and delete players from the playfield */ for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++) { + +#if 1 + + if (ELEM_IS_PLAYER(level->field[x][y])) + { + int player_nr = GET_PLAYER_NR(level->field[x][y]); + + ply[player_nr]->x_initial = x + 1; + ply[player_nr]->y_initial = y + 1; + + level_em->cave[x + 1][y + 1] = map_element_RND_to_EM(EL_EMPTY); + } + +#else + +#if 1 + /* !!! CURRENTLY ONLY SUPPORT FOR ONE PLAYER !!! */ + if (ELEM_IS_PLAYER(level->field[x][y])) + { + ply1->x_initial = x + 1; + ply1->y_initial = y + 1; + level_em->cave[x + 1][y + 1] = map_element_RND_to_EM(EL_EMPTY); + } +#else + /* !!! ADD SUPPORT FOR MORE THAN ONE PLAYER !!! */ if (level->field[x][y] == EL_PLAYER_1) { ply1->x_initial = x + 1; @@ -2318,6 +2540,10 @@ void CopyNativeLevel_RND_to_EM(struct LevelInfo *level) ply2->y_initial = y + 1; level_em->cave[x + 1][y + 1] = map_element_RND_to_EM(EL_EMPTY); } +#endif + +#endif + } } @@ -2336,8 +2562,7 @@ void CopyNativeLevel_EM_to_RND(struct LevelInfo *level) }; 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; + struct PLAYER **ply = level_em->ply; int i, j, x, y; level->fieldx = MIN(lev->width, MAX_LEV_FIELDX); @@ -2376,6 +2601,7 @@ void CopyNativeLevel_EM_to_RND(struct LevelInfo *level) level->ball_random = lev->ball_random; level->ball_state_initial = lev->ball_state_initial; level->ball_time = lev->ball_time; + level->num_ball_contents = lev->num_ball_arrays; level->lenses_score = lev->lenses_score; level->magnify_score = lev->magnify_score; @@ -2387,13 +2613,33 @@ void CopyNativeLevel_EM_to_RND(struct LevelInfo *level) level->wind_direction_initial = map_direction_EM_to_RND(lev->wind_direction_initial); +#if 0 + printf("::: foo\n"); + for (i = 0; i < MAX_ELEMENT_CONTENTS; i++) + for (j = 0; j < 8; j++) + printf("::: ball %d, %d: %d\n", i, j, + level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); +#endif + 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]); +#if 0 + printf("::: bar\n"); + for (i = 0; i < MAX_ELEMENT_CONTENTS; i++) + for (j = 0; j < 8; j++) + printf("::: ball %d, %d: %d\n", i, j, + level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); +#endif + + map_android_clone_elements_EM_to_RND(level); + +#if 0 for (i = 0; i < 16; i++) level->android_array[i] = FALSE; /* !!! YET TO COME !!! */ +#endif /* convert the playfield (some elements need special treatment) */ for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++) @@ -2406,13 +2652,50 @@ void CopyNativeLevel_EM_to_RND(struct LevelInfo *level) level->field[x][y] = new_element; } +#if 0 + printf("::: bar 0\n"); + for (i = 0; i < MAX_ELEMENT_CONTENTS; i++) + for (j = 0; j < 8; j++) + printf("::: ball %d, %d: %d\n", i, j, + level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); +#endif + +#if 1 + + for (i = 0; i < MAX_PLAYERS; i++) + { + /* in case of all players set to the same field, use the first player */ + int nr = MAX_PLAYERS - i - 1; + int jx = ply[nr]->x_initial - 1; + int jy = ply[nr]->y_initial - 1; + +#if 0 + printf("::: player %d: %d, %d\n", nr, jx, jy); +#endif + + if (jx != -1 && jy != -1) + level->field[jx][jy] = EL_PLAYER_1 + nr; + } + +#else + /* 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; +#endif + #if 0 printf("::: native Emerald Mine file version: %d\n", level_em->file_version); #endif + +#if 0 + printf("::: bar 2\n"); + for (i = 0; i < MAX_ELEMENT_CONTENTS; i++) + for (j = 0; j < 8; j++) + printf("::: ball %d, %d: %d\n", i, j, + level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); +#endif } static void LoadLevelFromFileInfo_EM(struct LevelInfo *level, @@ -2430,6 +2713,30 @@ void CopyNativeLevel_RND_to_Native(struct LevelInfo *level) void CopyNativeLevel_Native_to_RND(struct LevelInfo *level) { + +#if 0 + { + static int ball_xy[8][2] = + { + { 0, 0 }, + { 1, 0 }, + { 2, 0 }, + { 0, 1 }, + { 2, 1 }, + { 0, 2 }, + { 1, 2 }, + { 2, 2 }, + }; + int i, j; + + printf("::: A6\n"); + for (i = 0; i < MAX_ELEMENT_CONTENTS; i++) + for (j = 0; j < 8; j++) + printf("::: ball %d, %d: %d\n", i, j, + level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]); + } +#endif + if (level->game_engine_type == GAME_ENGINE_TYPE_EM) CopyNativeLevel_EM_to_RND(level); } @@ -2837,6 +3144,15 @@ static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename) if (leveldir_current == NULL) /* only when dumping level */ return; + /* all engine modifications also valid for levels which use latest engine */ +#if 1 + if (level->game_version < VERSION_IDENT(3,2,0,5)) + { + /* time bonus score was given for 10 s instead of 1 s before 3.2.0-5 */ + level->score[SC_TIME_BONUS] /= 10; + } +#endif + if (leveldir_current->latest_engine) { /* ---------- use latest game engine ----------------------------------- */ @@ -2878,7 +3194,7 @@ static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename) /* player was faster than enemies in 1.0.0 and before */ if (level->file_version == FILE_VERSION_1_0) - level->double_speed = TRUE; + level->initial_player_stepsize = STEPSIZE_FAST; /* default behaviour for EM style gems was "slippery" only in 2.0.1 */ if (level->game_version == VERSION_IDENT(2,0,1,0)) @@ -2899,8 +3215,10 @@ static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename) /* extra time score was same value as time left score before 3.2.0-5 */ level->extra_time_score = level->score[SC_TIME_BONUS]; +#if 0 /* time bonus score was given for 10 s instead of 1 s before 3.2.0-5 */ level->score[SC_TIME_BONUS] /= 10; +#endif } /* only few elements were able to actively move into acid before 3.1.0 */ @@ -3167,7 +3485,7 @@ static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level) 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_player_stepsize == STEPSIZE_FAST ? 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)); @@ -3613,9 +3931,39 @@ static int SaveLevel_CONF_Value(FILE *file, int pos) return num_bytes; } -static int SaveLevel_CONF_Content(FILE *file, int pos, int num_contents) +static int SaveLevel_CONF_Elements(FILE *file, int pos) +{ + int *element_array = (int *)(element_conf[pos].value); + int num_elements = *(int *)element_conf[pos].num_entities; + int default_value = element_conf[pos].default_value; + int element = element_conf[pos].element; + int type = element_conf[pos].type; + int num_bytes = 0; + boolean modified = FALSE; + int i; + + /* check if any settings have been modified before saving them */ + for (i = 0; i < num_elements; i++) + if (element_array[i] != default_value) + modified = TRUE; + + if (!modified) /* do not save unmodified default settings */ + return 0; + + num_bytes += putFile16BitBE(file, element); + num_bytes += putFile8Bit(file, type); + num_bytes += putFile16BitBE(file, num_elements * CONF_ELEMENT_NUM_BYTES); + + for (i = 0; i < num_elements; i++) + num_bytes += putFile16BitBE(file, element_array[i]); + + return num_bytes; +} + +static int SaveLevel_CONF_Contents(FILE *file, int pos) { struct Content *content = (struct Content *)(element_conf[pos].value); + int num_contents = *(int *)element_conf[pos].num_entities; int default_value = element_conf[pos].default_value; int element = element_conf[pos].element; int type = element_conf[pos].type; @@ -3659,8 +4007,10 @@ static int SaveLevel_CONF(FILE *file, struct LevelInfo *level) if (bytes != CONF_MASK_MULTI_BYTES) chunk_size += SaveLevel_CONF_Value(file, i); - else if (type == CONF_VALUE_CONTENT_8) - chunk_size += SaveLevel_CONF_Content(file, i, MAX_ELEMENT_CONTENTS); + else if (type == CONF_VALUE_ELEMENTS) + chunk_size += SaveLevel_CONF_Elements(file, i); + else if (type == CONF_VALUE_CONTENTS) + chunk_size += SaveLevel_CONF_Contents(file, i); } return chunk_size; @@ -3835,7 +4185,7 @@ void DumpLevel(struct LevelInfo *level) printf("Amoeba speed: %d\n", level->amoeba_speed); printf("\n"); printf("Initial gravity: %s\n", (level->initial_gravity ? "yes" : "no")); - printf("Double speed movement: %s\n", (level->double_speed ? "yes" : "no")); + printf("Initial player stepsize: %d\n", level->initial_player_stepsize); printf("EM style slippery gems: %s\n", (level->em_slippery_gems ? "yes" : "no")); printf("Player blocks last field: %s\n", (level->block_last_field ? "yes" : "no")); printf("SP player blocks last field: %s\n", (level->sp_block_last_field ? "yes" : "no")); @@ -4467,12 +4817,30 @@ void SaveScore(int nr) #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 SETUP_TOKEN_EDITOR_EL_HEADLINES 10 +#define SETUP_TOKEN_EDITOR_EL_USER_DEFINED 11 +#define SETUP_TOKEN_EDITOR_EL_DYNAMIC 12 #define NUM_EDITOR_SETUP_TOKENS 13 +/* editor cascade setup */ +#define SETUP_TOKEN_EDITOR_CASCADE_BD 0 +#define SETUP_TOKEN_EDITOR_CASCADE_EM 1 +#define SETUP_TOKEN_EDITOR_CASCADE_EMC 2 +#define SETUP_TOKEN_EDITOR_CASCADE_RND 3 +#define SETUP_TOKEN_EDITOR_CASCADE_SB 4 +#define SETUP_TOKEN_EDITOR_CASCADE_SP 5 +#define SETUP_TOKEN_EDITOR_CASCADE_DC 6 +#define SETUP_TOKEN_EDITOR_CASCADE_DX 7 +#define SETUP_TOKEN_EDITOR_CASCADE_TEXT 8 +#define SETUP_TOKEN_EDITOR_CASCADE_CE 9 +#define SETUP_TOKEN_EDITOR_CASCADE_GE 10 +#define SETUP_TOKEN_EDITOR_CASCADE_USER 11 +#define SETUP_TOKEN_EDITOR_CASCADE_GENERIC 12 +#define SETUP_TOKEN_EDITOR_CASCADE_DYNAMIC 13 + +#define NUM_EDITOR_CASCADE_SETUP_TOKENS 14 + /* shortcut setup */ #define SETUP_TOKEN_SHORTCUT_SAVE_GAME 0 #define SETUP_TOKEN_SHORTCUT_LOAD_GAME 1 @@ -4514,6 +4882,7 @@ void SaveScore(int nr) static struct SetupInfo si; static struct SetupEditorInfo sei; +static struct SetupEditorCascadeInfo seci; static struct SetupShortcutInfo ssi; static struct SetupInputInfo sii; static struct SetupSystemInfo syi; @@ -4558,9 +4927,27 @@ static struct TokenInfo editor_setup_tokens[] = { TYPE_SWITCH, &sei.el_dx_boulderdash,"editor.el_dx_boulderdash" }, { TYPE_SWITCH, &sei.el_chars, "editor.el_chars" }, { 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" }, + { TYPE_SWITCH, &sei.el_dynamic, "editor.el_dynamic" }, +}; + +static struct TokenInfo editor_cascade_setup_tokens[] = +{ + { TYPE_SWITCH, &seci.el_bd, "editor.cascade.el_bd" }, + { TYPE_SWITCH, &seci.el_em, "editor.cascade.el_em" }, + { TYPE_SWITCH, &seci.el_emc, "editor.cascade.el_emc" }, + { TYPE_SWITCH, &seci.el_rnd, "editor.cascade.el_rnd" }, + { TYPE_SWITCH, &seci.el_sb, "editor.cascade.el_sb" }, + { TYPE_SWITCH, &seci.el_sp, "editor.cascade.el_sp" }, + { TYPE_SWITCH, &seci.el_dc, "editor.cascade.el_dc" }, + { TYPE_SWITCH, &seci.el_dx, "editor.cascade.el_dx" }, + { TYPE_SWITCH, &seci.el_chars, "editor.cascade.el_chars" }, + { TYPE_SWITCH, &seci.el_ce, "editor.cascade.el_ce" }, + { TYPE_SWITCH, &seci.el_ge, "editor.cascade.el_ge" }, + { TYPE_SWITCH, &seci.el_user, "editor.cascade.el_user" }, + { TYPE_SWITCH, &seci.el_generic, "editor.cascade.el_generic" }, + { TYPE_SWITCH, &seci.el_dynamic, "editor.cascade.el_dynamic" }, }; static struct TokenInfo shortcut_setup_tokens[] = @@ -4658,10 +5045,10 @@ static void setSetupInfoToDefaults(struct SetupInfo *si) 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; + si->editor.el_dynamic = TRUE; si->shortcut.save_game = DEFAULT_KEY_SAVE_GAME; si->shortcut.load_game = DEFAULT_KEY_LOAD_GAME; @@ -4693,6 +5080,25 @@ static void setSetupInfoToDefaults(struct SetupInfo *si) si->options.verbose = FALSE; } +static void setSetupInfoToDefaults_EditorCascade(struct SetupInfo *si) +{ + si->editor_cascade.el_bd = TRUE; + si->editor_cascade.el_em = TRUE; + si->editor_cascade.el_emc = TRUE; + si->editor_cascade.el_rnd = TRUE; + si->editor_cascade.el_sb = TRUE; + si->editor_cascade.el_sp = TRUE; + si->editor_cascade.el_dc = TRUE; + si->editor_cascade.el_dx = TRUE; + + si->editor_cascade.el_chars = FALSE; + si->editor_cascade.el_ce = FALSE; + si->editor_cascade.el_ge = FALSE; + si->editor_cascade.el_user = FALSE; + si->editor_cascade.el_generic = FALSE; + si->editor_cascade.el_dynamic = FALSE; +} + static void decodeSetupFileHash(SetupFileHash *setup_file_hash) { int i, pnr; @@ -4755,6 +5161,22 @@ static void decodeSetupFileHash(SetupFileHash *setup_file_hash) setup.options = soi; } +static void decodeSetupFileHash_EditorCascade(SetupFileHash *setup_file_hash) +{ + int i; + + if (!setup_file_hash) + return; + + /* editor cascade setup */ + seci = setup.editor_cascade; + for (i = 0; i < NUM_EDITOR_CASCADE_SETUP_TOKENS; i++) + setSetupInfo(editor_cascade_setup_tokens, i, + getHashEntry(setup_file_hash, + editor_cascade_setup_tokens[i].text)); + setup.editor_cascade = seci; +} + void LoadSetup() { char *filename = getSetupFilename(); @@ -4785,6 +5207,27 @@ void LoadSetup() Error(ERR_WARN, "using default setup values"); } +void LoadSetup_EditorCascade() +{ + char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME); + SetupFileHash *setup_file_hash = NULL; + + /* always start with reliable default values */ + setSetupInfoToDefaults_EditorCascade(&setup); + + setup_file_hash = loadSetupFileHash(filename); + + if (setup_file_hash) + { + checkSetupFileHashIdentifier(setup_file_hash, getCookie("SETUP")); + decodeSetupFileHash_EditorCascade(setup_file_hash); + + freeSetupFileHash(setup_file_hash); + } + + free(filename); +} + void SaveSetup() { char *filename = getSetupFilename(); @@ -4857,6 +5300,37 @@ void SaveSetup() SetFilePermissions(filename, PERMS_PRIVATE); } +void SaveSetup_EditorCascade() +{ + char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME); + FILE *file; + int i; + + InitUserDataDirectory(); + + if (!(file = fopen(filename, MODE_WRITE))) + { + Error(ERR_WARN, "cannot write editor cascade state file '%s'", filename); + free(filename); + return; + } + + fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER, + getCookie("SETUP"))); + fprintf(file, "\n"); + + seci = setup.editor_cascade; + fprintf(file, "\n"); + for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++) + fprintf(file, "%s\n", getSetupLine(editor_cascade_setup_tokens, "", i)); + + fclose(file); + + SetFilePermissions(filename, PERMS_PRIVATE); + + free(filename); +} + void LoadCustomElementDescriptions() { char *filename = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS); @@ -4958,6 +5432,10 @@ void LoadUserDefinedEditorElementList(int **elements, int *num_elements) /* add space for up to 3 more elements for padding that may be needed */ *num_elements += 3; + /* free memory for old list of elements, if needed */ + checked_free(*elements); + + /* allocate memory for new list of elements */ *elements = checked_malloc(*num_elements * sizeof(int)); *num_elements = 0; @@ -5351,7 +5829,7 @@ void LoadHelpAnimInfo() 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++) + for (i = 0; i < NUM_DIRECTIONS_FULL; i++) setHashEntry(direction_hash, element_direction_info[i].suffix, i_to_a(1 << element_direction_info[i].value));