src/files.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * files.c                                                  *
  12 ***********************************************************/
  13
  14 #include <ctype.h>
  15 #include <sys/stat.h>
  16 #include <dirent.h>
  17 #include <math.h>
  18
  19 #include "libgame/libgame.h"
  20
  21 #include "files.h"
  22 #include "init.h"
  23 #include "tools.h"
  24 #include "tape.h"
  25
  26
  27 #define CHUNK_ID_LEN            4       /* IFF style chunk id length  */
  28 #define CHUNK_SIZE_UNDEFINED    0       /* undefined chunk size == 0  */
  29 #define CHUNK_SIZE_NONE         -1      /* do not write chunk size    */
  30 #define FILE_VERS_CHUNK_SIZE    8       /* size of file version chunk */
  31 #define LEVEL_HEADER_SIZE       80      /* size of level file header  */
  32 #define LEVEL_HEADER_UNUSED     2       /* unused level header bytes  */
  33 #define LEVEL_CHUNK_CNT2_SIZE   160     /* size of level CNT2 chunk   */
  34 #define LEVEL_CHUNK_CNT2_UNUSED 11      /* unused CNT2 chunk bytes    */
  35 #define LEVEL_CHUNK_CNT3_HEADER 16      /* size of level CNT3 header  */
  36 #define LEVEL_CHUNK_CNT3_UNUSED 10      /* unused CNT3 chunk bytes    */
  37 #define LEVEL_CPART_CUS3_SIZE   134     /* size of CUS3 chunk part    */
  38 #define LEVEL_CPART_CUS3_UNUSED 15      /* unused CUS3 bytes / part   */
  39 #define LEVEL_CHUNK_GRP1_SIZE   74      /* size of level GRP1 chunk   */
  40 #define TAPE_HEADER_SIZE        20      /* size of tape file header   */
  41 #define TAPE_HEADER_UNUSED      3       /* unused tape header bytes   */
  42
  43 #define LEVEL_CHUNK_CNT3_SIZE(x) (LEVEL_CHUNK_CNT3_HEADER + (x))
  44 #define LEVEL_CHUNK_CUS3_SIZE(x) (2 + (x) * LEVEL_CPART_CUS3_SIZE)
  45 #define LEVEL_CHUNK_CUS4_SIZE(x) (48 + 48 + (x) * 48)
  46
  47 /* file identifier strings */
  48 #define LEVEL_COOKIE_TMPL       "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_x.x"
  49 #define TAPE_COOKIE_TMPL        "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
  50 #define SCORE_COOKIE            "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
  51
  52 /* values for level file type identifier */
  53 #define LEVEL_FILE_TYPE_UNKNOWN         0
  54 #define LEVEL_FILE_TYPE_RND             1
  55 #define LEVEL_FILE_TYPE_BD              2
  56 #define LEVEL_FILE_TYPE_EM              3
  57 #define LEVEL_FILE_TYPE_SP              4
  58 #define LEVEL_FILE_TYPE_DX              5
  59 #define LEVEL_FILE_TYPE_SB              6
  60 #define LEVEL_FILE_TYPE_DC              7
  61
  62 #define LEVEL_FILE_TYPE_RND_PACKED      (10 + LEVEL_FILE_TYPE_RND)
  63 #define LEVEL_FILE_TYPE_EM_PACKED       (10 + LEVEL_FILE_TYPE_EM)
  64
  65 #define IS_SINGLE_LEVEL_FILE(x)         (x < 10)
  66 #define IS_PACKED_LEVEL_FILE(x)         (x > 10)
  67
  68
  69 /* ========================================================================= */
  70 /* level file functions                                                      */
  71 /* ========================================================================= */
  72
  73 void setElementChangePages(struct ElementInfo *ei, int change_pages)
  74 {
  75   int change_page_size = sizeof(struct ElementChangeInfo);
  76
  77   ei->num_change_pages = MAX(1, change_pages);
  78
  79   ei->change_page =
  80     checked_realloc(ei->change_page, ei->num_change_pages * change_page_size);
  81
  82   if (ei->current_change_page >= ei->num_change_pages)
  83     ei->current_change_page = ei->num_change_pages - 1;
  84
  85   ei->change = &ei->change_page[ei->current_change_page];
  86 }
  87
  88 void setElementChangeInfoToDefaults(struct ElementChangeInfo *change)
  89 {
  90   int x, y;
  91
  92   change->can_change = FALSE;
  93
  94   change->events = CE_BITMASK_DEFAULT;
  95
  96   change->trigger_player = CH_PLAYER_ANY;
  97   change->trigger_side = CH_SIDE_ANY;
  98   change->trigger_page = CH_PAGE_ANY;
  99
 100   change->target_element = EL_EMPTY_SPACE;
 101
 102   change->delay_fixed = 0;
 103   change->delay_random = 0;
 104   change->delay_frames = 1;
 105
 106   change->trigger_element = EL_EMPTY_SPACE;
 107
 108   change->explode = FALSE;
 109   change->use_target_content = FALSE;
 110   change->only_if_complete = FALSE;
 111   change->use_random_replace = FALSE;
 112   change->random_percentage = 100;
 113   change->replace_when = CP_WHEN_EMPTY;
 114
 115   for (x = 0; x < 3; x++)
 116     for (y = 0; y < 3; y++)
 117       change->target_content[x][y] = EL_EMPTY_SPACE;
 118
 119   change->direct_action = 0;
 120   change->other_action = 0;
 121
 122   change->pre_change_function = NULL;
 123   change->change_function = NULL;
 124   change->post_change_function = NULL;
 125 }
 126
 127 static void setLevelInfoToDefaults(struct LevelInfo *level)
 128 {
 129   static boolean clipboard_elements_initialized = FALSE;
 130
 131   int i, j, x, y;
 132
 133   level->file_version = FILE_VERSION_ACTUAL;
 134   level->game_version = GAME_VERSION_ACTUAL;
 135
 136   level->encoding_16bit_field  = FALSE; /* default: only 8-bit elements */
 137   level->encoding_16bit_yamyam = FALSE; /* default: only 8-bit elements */
 138   level->encoding_16bit_amoeba = FALSE; /* default: only 8-bit elements */
 139
 140   level->fieldx = STD_LEV_FIELDX;
 141   level->fieldy = STD_LEV_FIELDY;
 142
 143   for (x = 0; x < MAX_LEV_FIELDX; x++)
 144     for (y = 0; y < MAX_LEV_FIELDY; y++)
 145       level->field[x][y] = EL_SAND;
 146
 147   level->time = 100;
 148   level->gems_needed = 0;
 149
 150   level->amoeba_speed = 10;
 151
 152   level->time_magic_wall = 10;
 153   level->time_wheel = 10;
 154   level->time_light = 10;
 155   level->time_timegate = 10;
 156
 157   level->amoeba_content = EL_DIAMOND;
 158
 159   level->double_speed = FALSE;
 160   level->initial_gravity = FALSE;
 161   level->em_slippery_gems = FALSE;
 162   level->block_last_field = FALSE;
 163   level->sp_block_last_field = TRUE;
 164   level->instant_relocation = FALSE;
 165   level->can_pass_to_walkable = FALSE;
 166
 167   level->can_move_into_acid_bits = ~0;  /* everything can move into acid */
 168   level->dont_collide_with_bits = ~0;   /* always deadly when colliding  */
 169
 170   level->use_spring_bug = FALSE;
 171   level->use_step_counter = FALSE;
 172
 173   level->use_custom_template = FALSE;
 174
 175   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
 176     level->name[i] = '\0';
 177   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
 178     level->author[i] = '\0';
 179
 180   strcpy(level->name, NAMELESS_LEVEL_NAME);
 181   strcpy(level->author, ANONYMOUS_NAME);
 182
 183   for (i = 0; i < 4; i++)
 184   {
 185     level->envelope_text[i][0] = '\0';
 186     level->envelope_xsize[i] = MAX_ENVELOPE_XSIZE;
 187     level->envelope_ysize[i] = MAX_ENVELOPE_YSIZE;
 188   }
 189
 190   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
 191     level->score[i] = 10;
 192
 193   level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
 194   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
 195     for (x = 0; x < 3; x++)
 196       for (y = 0; y < 3; y++)
 197         level->yamyam_content[i][x][y] =
 198           (i < STD_ELEMENT_CONTENTS ? EL_ROCK : EL_EMPTY);
 199
 200   level->field[0][0] = EL_PLAYER_1;
 201   level->field[STD_LEV_FIELDX - 1][STD_LEV_FIELDY - 1] = EL_EXIT_CLOSED;
 202
 203   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
 204   {
 205     int element = i;
 206
 207     /* never initialize clipboard elements after the very first time */
 208     if (IS_CLIPBOARD_ELEMENT(element) && clipboard_elements_initialized)
 209       continue;
 210
 211     setElementChangePages(&element_info[element], 1);
 212     setElementChangeInfoToDefaults(element_info[element].change);
 213
 214     if (IS_CUSTOM_ELEMENT(element) ||
 215         IS_GROUP_ELEMENT(element) ||
 216         IS_INTERNAL_ELEMENT(element))
 217     {
 218       for (j = 0; j < MAX_ELEMENT_NAME_LEN + 1; j++)
 219         element_info[element].description[j] = '\0';
 220
 221       if (element_info[element].custom_description != NULL)
 222         strncpy(element_info[element].description,
 223                 element_info[element].custom_description,MAX_ELEMENT_NAME_LEN);
 224       else
 225         strcpy(element_info[element].description,
 226                element_info[element].editor_description);
 227
 228       element_info[element].use_gfx_element = FALSE;
 229       element_info[element].gfx_element = EL_EMPTY_SPACE;
 230     }
 231
 232     if (IS_CUSTOM_ELEMENT(element) ||
 233         IS_INTERNAL_ELEMENT(element))
 234     {
 235       element_info[element].access_direction = MV_ALL_DIRECTIONS;
 236
 237       element_info[element].collect_score = 10;         /* special default */
 238       element_info[element].collect_count = 1;          /* special default */
 239
 240       element_info[element].push_delay_fixed = -1;      /* initialize later */
 241       element_info[element].push_delay_random = -1;     /* initialize later */
 242       element_info[element].drop_delay_fixed = 0;
 243       element_info[element].drop_delay_random = 0;
 244       element_info[element].move_delay_fixed = 0;
 245       element_info[element].move_delay_random = 0;
 246
 247       element_info[element].move_pattern = MV_ALL_DIRECTIONS;
 248       element_info[element].move_direction_initial = MV_START_AUTOMATIC;
 249       element_info[element].move_stepsize = TILEX / 8;
 250       element_info[element].move_enter_element = EL_EMPTY_SPACE;
 251       element_info[element].move_leave_element = EL_EMPTY_SPACE;
 252       element_info[element].move_leave_type = LEAVE_TYPE_UNLIMITED;
 253
 254       element_info[element].slippery_type = SLIPPERY_ANY_RANDOM;
 255
 256       element_info[element].explosion_delay = 16;
 257       element_info[element].ignition_delay = 8;
 258
 259       for (x = 0; x < 3; x++)
 260         for (y = 0; y < 3; y++)
 261           element_info[element].content[x][y] = EL_EMPTY_SPACE;
 262
 263       element_info[element].access_type = 0;
 264       element_info[element].access_layer = 0;
 265       element_info[element].access_protected = 0;
 266       element_info[element].walk_to_action = 0;
 267       element_info[element].smash_targets = 0;
 268       element_info[element].deadliness = 0;
 269       element_info[element].consistency = 0;
 270
 271       element_info[element].can_explode_by_fire = FALSE;
 272       element_info[element].can_explode_smashed = FALSE;
 273       element_info[element].can_explode_impact = FALSE;
 274
 275       element_info[element].current_change_page = 0;
 276
 277       /* start with no properties at all */
 278       for (j = 0; j < NUM_EP_BITFIELDS; j++)
 279         Properties[element][j] = EP_BITMASK_DEFAULT;
 280
 281       /* now set default properties */
 282       SET_PROPERTY(element, EP_CAN_MOVE_INTO_ACID, TRUE);
 283
 284       element_info[element].modified_settings = FALSE;
 285     }
 286
 287     if (IS_GROUP_ELEMENT(element) ||
 288         IS_INTERNAL_ELEMENT(element))
 289     {
 290       /* initialize memory for list of elements in group */
 291       if (element_info[element].group == NULL)
 292         element_info[element].group =
 293           checked_malloc(sizeof(struct ElementGroupInfo));
 294
 295       for (j = 0; j < MAX_ELEMENTS_IN_GROUP; j++)
 296         element_info[element].group->element[j] = EL_EMPTY_SPACE;
 297
 298       /* default: only one element in group */
 299       element_info[element].group->num_elements = 1;
 300
 301       element_info[element].group->choice_mode = ANIM_RANDOM;
 302     }
 303   }
 304
 305   clipboard_elements_initialized = TRUE;
 306
 307   BorderElement = EL_STEELWALL;
 308
 309   level->no_valid_file = FALSE;
 310
 311   if (leveldir_current == NULL)         /* only when dumping level */
 312     return;
 313
 314   /* try to determine better author name than 'anonymous' */
 315   if (strcmp(leveldir_current->author, ANONYMOUS_NAME) != 0)
 316   {
 317     strncpy(level->author, leveldir_current->author, MAX_LEVEL_AUTHOR_LEN);
 318     level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 319   }
 320   else
 321   {
 322     switch (LEVELCLASS(leveldir_current))
 323     {
 324       case LEVELCLASS_TUTORIAL:
 325         strcpy(level->author, PROGRAM_AUTHOR_STRING);
 326         break;
 327
 328       case LEVELCLASS_CONTRIB:
 329         strncpy(level->author, leveldir_current->name, MAX_LEVEL_AUTHOR_LEN);
 330         level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 331         break;
 332
 333       case LEVELCLASS_PRIVATE:
 334         strncpy(level->author, getRealName(), MAX_LEVEL_AUTHOR_LEN);
 335         level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 336         break;
 337
 338       default:
 339         /* keep default value */
 340         break;
 341     }
 342   }
 343 }
 344
 345 static void setFileInfoToDefaults(struct LevelFileInfo *level_file_info)
 346 {
 347   level_file_info->nr = 0;
 348   level_file_info->type = LEVEL_FILE_TYPE_UNKNOWN;
 349   level_file_info->packed = FALSE;
 350   level_file_info->basename = NULL;
 351   level_file_info->filename = NULL;
 352 }
 353
 354 static void ActivateLevelTemplate()
 355 {
 356   /* Currently there is no special action needed to activate the template
 357      data, because 'element_info' and 'Properties' overwrite the original
 358      level data, while all other variables do not change. */
 359 }
 360
 361 static char *getLevelFilenameFromBasename(char *basename)
 362 {
 363   static char *filename = NULL;
 364
 365   checked_free(filename);
 366
 367   filename = getPath2(getCurrentLevelDir(), basename);
 368
 369   return filename;
 370 }
 371
 372 static int getFileTypeFromBasename(char *basename)
 373 {
 374   static char *filename = NULL;
 375   struct stat file_status;
 376
 377   /* ---------- try to determine file type from filename ---------- */
 378
 379   /* check for typical filename of a Supaplex level package file */
 380   if (strlen(basename) == 10 && (strncmp(basename, "levels.d", 8) == 0 ||
 381                                  strncmp(basename, "LEVELS.D", 8) == 0))
 382     return LEVEL_FILE_TYPE_SP;
 383
 384   /* ---------- try to determine file type from filesize ---------- */
 385
 386   checked_free(filename);
 387   filename = getPath2(getCurrentLevelDir(), basename);
 388
 389   if (stat(filename, &file_status) == 0)
 390   {
 391     /* check for typical filesize of a Supaplex level package file */
 392     if (file_status.st_size == 170496)
 393       return LEVEL_FILE_TYPE_SP;
 394   }
 395
 396   return LEVEL_FILE_TYPE_UNKNOWN;
 397 }
 398
 399 static char *getSingleLevelBasename(int nr, int type)
 400 {
 401   static char basename[MAX_FILENAME_LEN];
 402   char *level_filename = getStringCopy(leveldir_current->level_filename);
 403
 404   if (level_filename == NULL)
 405     level_filename = getStringCat2("%03d.", LEVELFILE_EXTENSION);
 406
 407   switch (type)
 408   {
 409     case LEVEL_FILE_TYPE_RND:
 410       if (nr < 0)
 411         sprintf(basename, "template.%s", LEVELFILE_EXTENSION);
 412       else
 413         sprintf(basename, "%03d.%s", nr, LEVELFILE_EXTENSION);
 414       break;
 415
 416     case LEVEL_FILE_TYPE_EM:
 417       sprintf(basename, "%d", nr);
 418       break;
 419
 420     case LEVEL_FILE_TYPE_UNKNOWN:
 421     default:
 422       sprintf(basename, level_filename, nr);
 423       break;
 424   }
 425
 426   free(level_filename);
 427
 428   return basename;
 429 }
 430
 431 static char *getPackedLevelBasename(int type)
 432 {
 433   static char basename[MAX_FILENAME_LEN];
 434   char *directory = getCurrentLevelDir();
 435   DIR *dir;
 436   struct dirent *dir_entry;
 437
 438   strcpy(basename, UNDEFINED_FILENAME);         /* default: undefined file */
 439
 440   if ((dir = opendir(directory)) == NULL)
 441   {
 442     Error(ERR_WARN, "cannot read current level directory '%s'", directory);
 443
 444     return basename;
 445   }
 446
 447   while ((dir_entry = readdir(dir)) != NULL)    /* loop until last dir entry */
 448   {
 449     char *entry_basename = dir_entry->d_name;
 450     int entry_type = getFileTypeFromBasename(entry_basename);
 451
 452     if (entry_type != LEVEL_FILE_TYPE_UNKNOWN)  /* found valid level package */
 453     {
 454       if (type == LEVEL_FILE_TYPE_UNKNOWN ||
 455           type == entry_type)
 456       {
 457         strcpy(basename, entry_basename);
 458
 459         break;
 460       }
 461     }
 462   }
 463
 464   closedir(dir);
 465
 466   return basename;
 467 }
 468
 469 static char *getSingleLevelFilename(int nr, int type)
 470 {
 471   return getLevelFilenameFromBasename(getSingleLevelBasename(nr, type));
 472 }
 473
 474 #if 0
 475 static char *getPackedLevelFilename(int type)
 476 {
 477   return getLevelFilenameFromBasename(getPackedLevelBasename(type));
 478 }
 479 #endif
 480
 481 char *getDefaultLevelFilename(int nr)
 482 {
 483   return getSingleLevelFilename(nr, LEVEL_FILE_TYPE_RND);
 484 }
 485
 486 static void setLevelFileInfo_SingleLevelFilename(struct LevelFileInfo *lfi,
 487                                                  int type)
 488 {
 489   lfi->type = type;
 490   lfi->packed = FALSE;
 491   lfi->basename = getSingleLevelBasename(lfi->nr, lfi->type);
 492   lfi->filename = getLevelFilenameFromBasename(lfi->basename);
 493 }
 494
 495 static void setLevelFileInfo_PackedLevelFilename(struct LevelFileInfo *lfi,
 496                                                  int type)
 497 {
 498   lfi->type = type;
 499   lfi->packed = TRUE;
 500   lfi->basename = getPackedLevelBasename(lfi->type);
 501   lfi->filename = getLevelFilenameFromBasename(lfi->basename);
 502 }
 503
 504 static void determineLevelFileInfo_Filename(struct LevelFileInfo *lfi)
 505 {
 506   /* special case: level number is negative => check for level template file */
 507   if (lfi->nr < 0)
 508   {
 509     setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_RND);
 510
 511     return;
 512   }
 513
 514   if (leveldir_current->level_filename != NULL)
 515   {
 516     /* check for file name/pattern specified in "levelinfo.conf" */
 517     setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
 518     if (fileExists(lfi->filename))
 519       return;
 520   }
 521
 522   /* check for native Rocks'n'Diamonds level file */
 523   setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_RND);
 524   if (fileExists(lfi->filename))
 525     return;
 526
 527   /* check for classic Emerald Mine level file */
 528   setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_EM);
 529   if (fileExists(lfi->filename))
 530     return;
 531
 532   /* check for various packed level file formats */
 533   setLevelFileInfo_PackedLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
 534   if (fileExists(lfi->filename))
 535     return;
 536
 537   /* no known level file found -- try to use default values */
 538   setLevelFileInfo_SingleLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
 539 }
 540
 541 static void determineLevelFileInfo_Filetype(struct LevelFileInfo *lfi)
 542 {
 543   if (lfi->type == LEVEL_FILE_TYPE_UNKNOWN)
 544     lfi->type = getFileTypeFromBasename(lfi->basename);
 545 }
 546
 547 static struct LevelFileInfo *getLevelFileInfo(int nr)
 548 {
 549   static struct LevelFileInfo level_file_info;
 550
 551   /* always start with reliable default values */
 552   setFileInfoToDefaults(&level_file_info);
 553
 554   level_file_info.nr = nr;      /* set requested level number */
 555
 556   determineLevelFileInfo_Filename(&level_file_info);
 557   determineLevelFileInfo_Filetype(&level_file_info);
 558
 559   return &level_file_info;
 560 }
 561
 562
 563 /* ------------------------------------------------------------------------- */
 564 /* functions for loading R'n'D level                                         */
 565 /* ------------------------------------------------------------------------- */
 566
 567 int getMappedElement(int element)
 568 {
 569   /* remap some (historic, now obsolete) elements */
 570
 571 #if 1
 572   switch (element)
 573   {
 574     case EL_PLAYER_OBSOLETE:
 575       element = EL_PLAYER_1;
 576       break;
 577
 578     case EL_KEY_OBSOLETE:
 579       element = EL_KEY_1;
 580
 581     case EL_EM_KEY_1_FILE_OBSOLETE:
 582       element = EL_EM_KEY_1;
 583       break;
 584
 585     case EL_EM_KEY_2_FILE_OBSOLETE:
 586       element = EL_EM_KEY_2;
 587       break;
 588
 589     case EL_EM_KEY_3_FILE_OBSOLETE:
 590       element = EL_EM_KEY_3;
 591       break;
 592
 593     case EL_EM_KEY_4_FILE_OBSOLETE:
 594       element = EL_EM_KEY_4;
 595       break;
 596
 597     case EL_ENVELOPE_OBSOLETE:
 598       element = EL_ENVELOPE_1;
 599       break;
 600
 601     case EL_SP_EMPTY:
 602       element = EL_EMPTY;
 603       break;
 604
 605     default:
 606       if (element >= NUM_FILE_ELEMENTS)
 607       {
 608         Error(ERR_WARN, "invalid level element %d", element);
 609
 610         element = EL_UNKNOWN;
 611       }
 612       break;
 613   }
 614 #else
 615   if (element >= NUM_FILE_ELEMENTS)
 616   {
 617     Error(ERR_WARN, "invalid level element %d", element);
 618
 619     element = EL_UNKNOWN;
 620   }
 621   else if (element == EL_PLAYER_OBSOLETE)
 622     element = EL_PLAYER_1;
 623   else if (element == EL_KEY_OBSOLETE)
 624     element = EL_KEY_1;
 625 #endif
 626
 627   return element;
 628 }
 629
 630 int getMappedElementByVersion(int element, int game_version)
 631 {
 632   /* remap some elements due to certain game version */
 633
 634   if (game_version <= VERSION_IDENT(2,2,0,0))
 635   {
 636     /* map game font elements */
 637     element = (element == EL_CHAR('[')  ? EL_CHAR_AUMLAUT :
 638                element == EL_CHAR('\\') ? EL_CHAR_OUMLAUT :
 639                element == EL_CHAR(']')  ? EL_CHAR_UUMLAUT :
 640                element == EL_CHAR('^')  ? EL_CHAR_COPYRIGHT : element);
 641   }
 642
 643   if (game_version < VERSION_IDENT(3,0,0,0))
 644   {
 645     /* map Supaplex gravity tube elements */
 646     element = (element == EL_SP_GRAVITY_PORT_LEFT  ? EL_SP_PORT_LEFT  :
 647                element == EL_SP_GRAVITY_PORT_RIGHT ? EL_SP_PORT_RIGHT :
 648                element == EL_SP_GRAVITY_PORT_UP    ? EL_SP_PORT_UP    :
 649                element == EL_SP_GRAVITY_PORT_DOWN  ? EL_SP_PORT_DOWN  :
 650                element);
 651   }
 652
 653   return element;
 654 }
 655
 656 static int LoadLevel_VERS(FILE *file, int chunk_size, struct LevelInfo *level)
 657 {
 658   level->file_version = getFileVersion(file);
 659   level->game_version = getFileVersion(file);
 660
 661   return chunk_size;
 662 }
 663
 664 static int LoadLevel_HEAD(FILE *file, int chunk_size, struct LevelInfo *level)
 665 {
 666   int i, x, y;
 667
 668   level->fieldx = getFile8Bit(file);
 669   level->fieldy = getFile8Bit(file);
 670
 671   level->time           = getFile16BitBE(file);
 672   level->gems_needed    = getFile16BitBE(file);
 673
 674   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
 675     level->name[i] = getFile8Bit(file);
 676   level->name[MAX_LEVEL_NAME_LEN] = 0;
 677
 678   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
 679     level->score[i] = getFile8Bit(file);
 680
 681   level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
 682   for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
 683     for (y = 0; y < 3; y++)
 684       for (x = 0; x < 3; x++)
 685         level->yamyam_content[i][x][y] = getMappedElement(getFile8Bit(file));
 686
 687   level->amoeba_speed           = getFile8Bit(file);
 688   level->time_magic_wall        = getFile8Bit(file);
 689   level->time_wheel             = getFile8Bit(file);
 690   level->amoeba_content         = getMappedElement(getFile8Bit(file));
 691   level->double_speed           = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 692   level->initial_gravity        = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 693   level->encoding_16bit_field   = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 694   level->em_slippery_gems       = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 695
 696   level->use_custom_template    = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 697
 698   level->block_last_field       = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 699   level->sp_block_last_field    = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 700   level->can_move_into_acid_bits = getFile32BitBE(file);
 701   level->dont_collide_with_bits = getFile8Bit(file);
 702
 703   level->use_spring_bug         = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 704   level->use_step_counter       = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 705
 706   level->instant_relocation     = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 707   level->can_pass_to_walkable   = (getFile8Bit(file) == 1 ? TRUE : FALSE);
 708
 709   ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
 710
 711   return chunk_size;
 712 }
 713
 714 static int LoadLevel_AUTH(FILE *file, int chunk_size, struct LevelInfo *level)
 715 {
 716   int i;
 717
 718   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
 719     level->author[i] = getFile8Bit(file);
 720   level->author[MAX_LEVEL_NAME_LEN] = 0;
 721
 722   return chunk_size;
 723 }
 724
 725 static int LoadLevel_BODY(FILE *file, int chunk_size, struct LevelInfo *level)
 726 {
 727   int x, y;
 728   int chunk_size_expected = level->fieldx * level->fieldy;
 729
 730   /* Note: "chunk_size" was wrong before version 2.0 when elements are
 731      stored with 16-bit encoding (and should be twice as big then).
 732      Even worse, playfield data was stored 16-bit when only yamyam content
 733      contained 16-bit elements and vice versa. */
 734
 735   if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
 736     chunk_size_expected *= 2;
 737
 738   if (chunk_size_expected != chunk_size)
 739   {
 740     ReadUnusedBytesFromFile(file, chunk_size);
 741     return chunk_size_expected;
 742   }
 743
 744   for (y = 0; y < level->fieldy; y++)
 745     for (x = 0; x < level->fieldx; x++)
 746       level->field[x][y] =
 747         getMappedElement(level->encoding_16bit_field ? getFile16BitBE(file) :
 748                          getFile8Bit(file));
 749   return chunk_size;
 750 }
 751
 752 static int LoadLevel_CONT(FILE *file, int chunk_size, struct LevelInfo *level)
 753 {
 754   int i, x, y;
 755   int header_size = 4;
 756   int content_size = MAX_ELEMENT_CONTENTS * 3 * 3;
 757   int chunk_size_expected = header_size + content_size;
 758
 759   /* Note: "chunk_size" was wrong before version 2.0 when elements are
 760      stored with 16-bit encoding (and should be twice as big then).
 761      Even worse, playfield data was stored 16-bit when only yamyam content
 762      contained 16-bit elements and vice versa. */
 763
 764   if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
 765     chunk_size_expected += content_size;
 766
 767   if (chunk_size_expected != chunk_size)
 768   {
 769     ReadUnusedBytesFromFile(file, chunk_size);
 770     return chunk_size_expected;
 771   }
 772
 773   getFile8Bit(file);
 774   level->num_yamyam_contents = getFile8Bit(file);
 775   getFile8Bit(file);
 776   getFile8Bit(file);
 777
 778   /* correct invalid number of content fields -- should never happen */
 779   if (level->num_yamyam_contents < 1 ||
 780       level->num_yamyam_contents > MAX_ELEMENT_CONTENTS)
 781     level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
 782
 783   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
 784     for (y = 0; y < 3; y++)
 785       for (x = 0; x < 3; x++)
 786         level->yamyam_content[i][x][y] =
 787           getMappedElement(level->encoding_16bit_field ?
 788                            getFile16BitBE(file) : getFile8Bit(file));
 789   return chunk_size;
 790 }
 791
 792 static int LoadLevel_CNT2(FILE *file, int chunk_size, struct LevelInfo *level)
 793 {
 794   int i, x, y;
 795   int element;
 796   int num_contents, content_xsize, content_ysize;
 797   int content_array[MAX_ELEMENT_CONTENTS][3][3];
 798
 799   element = getMappedElement(getFile16BitBE(file));
 800   num_contents = getFile8Bit(file);
 801   content_xsize = getFile8Bit(file);
 802   content_ysize = getFile8Bit(file);
 803
 804   ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT2_UNUSED);
 805
 806   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
 807     for (y = 0; y < 3; y++)
 808       for (x = 0; x < 3; x++)
 809         content_array[i][x][y] = getMappedElement(getFile16BitBE(file));
 810
 811   /* correct invalid number of content fields -- should never happen */
 812   if (num_contents < 1 || num_contents > MAX_ELEMENT_CONTENTS)
 813     num_contents = STD_ELEMENT_CONTENTS;
 814
 815   if (element == EL_YAMYAM)
 816   {
 817     level->num_yamyam_contents = num_contents;
 818
 819     for (i = 0; i < num_contents; i++)
 820       for (y = 0; y < 3; y++)
 821         for (x = 0; x < 3; x++)
 822           level->yamyam_content[i][x][y] = content_array[i][x][y];
 823   }
 824   else if (element == EL_BD_AMOEBA)
 825   {
 826     level->amoeba_content = content_array[0][0][0];
 827   }
 828   else
 829   {
 830     Error(ERR_WARN, "cannot load content for element '%d'", element);
 831   }
 832
 833   return chunk_size;
 834 }
 835
 836 static int LoadLevel_CNT3(FILE *file, int chunk_size, struct LevelInfo *level)
 837 {
 838   int i;
 839   int element;
 840   int envelope_nr;
 841   int envelope_len;
 842   int chunk_size_expected;
 843
 844   element = getMappedElement(getFile16BitBE(file));
 845   if (!IS_ENVELOPE(element))
 846     element = EL_ENVELOPE_1;
 847
 848   envelope_nr = element - EL_ENVELOPE_1;
 849
 850   envelope_len = getFile16BitBE(file);
 851
 852   level->envelope_xsize[envelope_nr] = getFile8Bit(file);
 853   level->envelope_ysize[envelope_nr] = getFile8Bit(file);
 854
 855   ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT3_UNUSED);
 856
 857   chunk_size_expected = LEVEL_CHUNK_CNT3_SIZE(envelope_len);
 858   if (chunk_size_expected != chunk_size)
 859   {
 860     ReadUnusedBytesFromFile(file, chunk_size - LEVEL_CHUNK_CNT3_HEADER);
 861     return chunk_size_expected;
 862   }
 863
 864   for (i = 0; i < envelope_len; i++)
 865     level->envelope_text[envelope_nr][i] = getFile8Bit(file);
 866
 867   return chunk_size;
 868 }
 869
 870 static int LoadLevel_CUS1(FILE *file, int chunk_size, struct LevelInfo *level)
 871 {
 872   int num_changed_custom_elements = getFile16BitBE(file);
 873   int chunk_size_expected = 2 + num_changed_custom_elements * 6;
 874   int i;
 875
 876   if (chunk_size_expected != chunk_size)
 877   {
 878     ReadUnusedBytesFromFile(file, chunk_size - 2);
 879     return chunk_size_expected;
 880   }
 881
 882   for (i = 0; i < num_changed_custom_elements; i++)
 883   {
 884     int element = getFile16BitBE(file);
 885     int properties = getFile32BitBE(file);
 886
 887     if (IS_CUSTOM_ELEMENT(element))
 888       Properties[element][EP_BITFIELD_BASE] = properties;
 889     else
 890       Error(ERR_WARN, "invalid custom element number %d", element);
 891   }
 892
 893   return chunk_size;
 894 }
 895
 896 static int LoadLevel_CUS2(FILE *file, int chunk_size, struct LevelInfo *level)
 897 {
 898   int num_changed_custom_elements = getFile16BitBE(file);
 899   int chunk_size_expected = 2 + num_changed_custom_elements * 4;
 900   int i;
 901
 902   if (chunk_size_expected != chunk_size)
 903   {
 904     ReadUnusedBytesFromFile(file, chunk_size - 2);
 905     return chunk_size_expected;
 906   }
 907
 908   for (i = 0; i < num_changed_custom_elements; i++)
 909   {
 910     int element = getFile16BitBE(file);
 911     int custom_target_element = getFile16BitBE(file);
 912
 913     if (IS_CUSTOM_ELEMENT(element))
 914       element_info[element].change->target_element = custom_target_element;
 915     else
 916       Error(ERR_WARN, "invalid custom element number %d", element);
 917   }
 918
 919   return chunk_size;
 920 }
 921
 922 static int LoadLevel_CUS3(FILE *file, int chunk_size, struct LevelInfo *level)
 923 {
 924   int num_changed_custom_elements = getFile16BitBE(file);
 925   int chunk_size_expected = LEVEL_CHUNK_CUS3_SIZE(num_changed_custom_elements);
 926   int i, j, x, y;
 927
 928   if (chunk_size_expected != chunk_size)
 929   {
 930     ReadUnusedBytesFromFile(file, chunk_size - 2);
 931     return chunk_size_expected;
 932   }
 933
 934   for (i = 0; i < num_changed_custom_elements; i++)
 935   {
 936     int element = getFile16BitBE(file);
 937
 938     if (!IS_CUSTOM_ELEMENT(element))
 939     {
 940       Error(ERR_WARN, "invalid custom element number %d", element);
 941
 942       element = EL_INTERNAL_DUMMY;
 943     }
 944
 945     for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
 946       element_info[element].description[j] = getFile8Bit(file);
 947     element_info[element].description[MAX_ELEMENT_NAME_LEN] = 0;
 948
 949     Properties[element][EP_BITFIELD_BASE] = getFile32BitBE(file);
 950
 951     /* some free bytes for future properties and padding */
 952     ReadUnusedBytesFromFile(file, 7);
 953
 954     element_info[element].use_gfx_element = getFile8Bit(file);
 955     element_info[element].gfx_element =
 956       getMappedElement(getFile16BitBE(file));
 957
 958     element_info[element].collect_score = getFile8Bit(file);
 959     element_info[element].collect_count = getFile8Bit(file);
 960
 961     element_info[element].push_delay_fixed = getFile16BitBE(file);
 962     element_info[element].push_delay_random = getFile16BitBE(file);
 963     element_info[element].move_delay_fixed = getFile16BitBE(file);
 964     element_info[element].move_delay_random = getFile16BitBE(file);
 965
 966     element_info[element].move_pattern = getFile16BitBE(file);
 967     element_info[element].move_direction_initial = getFile8Bit(file);
 968     element_info[element].move_stepsize = getFile8Bit(file);
 969
 970     for (y = 0; y < 3; y++)
 971       for (x = 0; x < 3; x++)
 972         element_info[element].content[x][y] =
 973           getMappedElement(getFile16BitBE(file));
 974
 975     element_info[element].change->events = getFile32BitBE(file);
 976
 977     element_info[element].change->target_element =
 978       getMappedElement(getFile16BitBE(file));
 979
 980     element_info[element].change->delay_fixed = getFile16BitBE(file);
 981     element_info[element].change->delay_random = getFile16BitBE(file);
 982     element_info[element].change->delay_frames = getFile16BitBE(file);
 983
 984     element_info[element].change->trigger_element =
 985       getMappedElement(getFile16BitBE(file));
 986
 987     element_info[element].change->explode = getFile8Bit(file);
 988     element_info[element].change->use_target_content = getFile8Bit(file);
 989     element_info[element].change->only_if_complete = getFile8Bit(file);
 990     element_info[element].change->use_random_replace = getFile8Bit(file);
 991
 992     element_info[element].change->random_percentage = getFile8Bit(file);
 993     element_info[element].change->replace_when = getFile8Bit(file);
 994
 995     for (y = 0; y < 3; y++)
 996       for (x = 0; x < 3; x++)
 997         element_info[element].change->target_content[x][y] =
 998           getMappedElement(getFile16BitBE(file));
 999
1000     element_info[element].slippery_type = getFile8Bit(file);
1001
1002     /* some free bytes for future properties and padding */
1003     ReadUnusedBytesFromFile(file, LEVEL_CPART_CUS3_UNUSED);
1004
1005     /* mark that this custom element has been modified */
1006     element_info[element].modified_settings = TRUE;
1007   }
1008
1009   return chunk_size;
1010 }
1011
1012 static int LoadLevel_CUS4(FILE *file, int chunk_size, struct LevelInfo *level)
1013 {
1014   struct ElementInfo *ei;
1015   int chunk_size_expected;
1016   int element;
1017   int i, x, y;
1018
1019   element = getFile16BitBE(file);
1020
1021   if (!IS_CUSTOM_ELEMENT(element))
1022   {
1023     Error(ERR_WARN, "invalid custom element number %d", element);
1024
1025     ReadUnusedBytesFromFile(file, chunk_size - 2);
1026     return chunk_size;
1027   }
1028
1029   ei = &element_info[element];
1030
1031   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
1032     ei->description[i] = getFile8Bit(file);
1033   ei->description[MAX_ELEMENT_NAME_LEN] = 0;
1034
1035   Properties[element][EP_BITFIELD_BASE] = getFile32BitBE(file);
1036   ReadUnusedBytesFromFile(file, 4);     /* reserved for more base properties */
1037
1038   ei->num_change_pages = getFile8Bit(file);
1039
1040   /* some free bytes for future base property values and padding */
1041   ReadUnusedBytesFromFile(file, 5);
1042
1043   chunk_size_expected = LEVEL_CHUNK_CUS4_SIZE(ei->num_change_pages);
1044   if (chunk_size_expected != chunk_size)
1045   {
1046     ReadUnusedBytesFromFile(file, chunk_size - 48);
1047     return chunk_size_expected;
1048   }
1049
1050   /* read custom property values */
1051
1052   ei->use_gfx_element = getFile8Bit(file);
1053   ei->gfx_element = getMappedElement(getFile16BitBE(file));
1054
1055   ei->collect_score = getFile8Bit(file);
1056   ei->collect_count = getFile8Bit(file);
1057
1058   ei->drop_delay_fixed = getFile8Bit(file);
1059   ei->push_delay_fixed = getFile8Bit(file);
1060   ei->drop_delay_random = getFile8Bit(file);
1061   ei->push_delay_random = getFile8Bit(file);
1062   ei->move_delay_fixed = getFile16BitBE(file);
1063   ei->move_delay_random = getFile16BitBE(file);
1064
1065   /* bits 0 - 15 of "move_pattern" ... */
1066   ei->move_pattern = getFile16BitBE(file);
1067   ei->move_direction_initial = getFile8Bit(file);
1068   ei->move_stepsize = getFile8Bit(file);
1069
1070   ei->slippery_type = getFile8Bit(file);
1071
1072   for (y = 0; y < 3; y++)
1073     for (x = 0; x < 3; x++)
1074       ei->content[x][y] = getMappedElement(getFile16BitBE(file));
1075
1076   ei->move_enter_element = getMappedElement(getFile16BitBE(file));
1077   ei->move_leave_element = getMappedElement(getFile16BitBE(file));
1078   ei->move_leave_type = getFile8Bit(file);
1079
1080   /* ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible) */
1081   ei->move_pattern |= (getFile16BitBE(file) << 16);
1082
1083   ei->access_direction = getFile8Bit(file);
1084
1085   ei->explosion_delay = getFile8Bit(file);
1086   ei->ignition_delay = getFile8Bit(file);
1087
1088   /* some free bytes for future custom property values and padding */
1089   ReadUnusedBytesFromFile(file, 2);
1090
1091   /* read change property values */
1092
1093   setElementChangePages(ei, ei->num_change_pages);
1094
1095   for (i = 0; i < ei->num_change_pages; i++)
1096   {
1097     struct ElementChangeInfo *change = &ei->change_page[i];
1098
1099     /* always start with reliable default values */
1100     setElementChangeInfoToDefaults(change);
1101
1102     change->events = getFile32BitBE(file);
1103
1104     change->target_element = getMappedElement(getFile16BitBE(file));
1105
1106     change->delay_fixed = getFile16BitBE(file);
1107     change->delay_random = getFile16BitBE(file);
1108     change->delay_frames = getFile16BitBE(file);
1109
1110     change->trigger_element = getMappedElement(getFile16BitBE(file));
1111
1112     change->explode = getFile8Bit(file);
1113     change->use_target_content = getFile8Bit(file);
1114     change->only_if_complete = getFile8Bit(file);
1115     change->use_random_replace = getFile8Bit(file);
1116
1117     change->random_percentage = getFile8Bit(file);
1118     change->replace_when = getFile8Bit(file);
1119
1120     for (y = 0; y < 3; y++)
1121       for (x = 0; x < 3; x++)
1122         change->target_content[x][y] = getMappedElement(getFile16BitBE(file));
1123
1124     change->can_change = getFile8Bit(file);
1125
1126     change->trigger_side = getFile8Bit(file);
1127
1128 #if 1
1129     change->trigger_player = getFile8Bit(file);
1130     change->trigger_page = getFile8Bit(file);
1131
1132     change->trigger_page = (change->trigger_page == CH_PAGE_ANY_FILE ?
1133                             CH_PAGE_ANY : (1 << change->trigger_page));
1134
1135     /* some free bytes for future change property values and padding */
1136     ReadUnusedBytesFromFile(file, 6);
1137
1138 #else
1139
1140     /* some free bytes for future change property values and padding */
1141     ReadUnusedBytesFromFile(file, 8);
1142 #endif
1143   }
1144
1145   /* mark this custom element as modified */
1146   ei->modified_settings = TRUE;
1147
1148   return chunk_size;
1149 }
1150
1151 static int LoadLevel_GRP1(FILE *file, int chunk_size, struct LevelInfo *level)
1152 {
1153   struct ElementInfo *ei;
1154   struct ElementGroupInfo *group;
1155   int element;
1156   int i;
1157
1158   element = getFile16BitBE(file);
1159
1160   if (!IS_GROUP_ELEMENT(element))
1161   {
1162     Error(ERR_WARN, "invalid group element number %d", element);
1163
1164     ReadUnusedBytesFromFile(file, chunk_size - 2);
1165     return chunk_size;
1166   }
1167
1168   ei = &element_info[element];
1169
1170   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
1171     ei->description[i] = getFile8Bit(file);
1172   ei->description[MAX_ELEMENT_NAME_LEN] = 0;
1173
1174   group = element_info[element].group;
1175
1176   group->num_elements = getFile8Bit(file);
1177
1178   ei->use_gfx_element = getFile8Bit(file);
1179   ei->gfx_element = getMappedElement(getFile16BitBE(file));
1180
1181   group->choice_mode = getFile8Bit(file);
1182
1183   /* some free bytes for future values and padding */
1184   ReadUnusedBytesFromFile(file, 3);
1185
1186   for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
1187     group->element[i] = getMappedElement(getFile16BitBE(file));
1188
1189   /* mark this group element as modified */
1190   element_info[element].modified_settings = TRUE;
1191
1192   return chunk_size;
1193 }
1194
1195 static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
1196                                       struct LevelFileInfo *level_file_info)
1197 {
1198   char *filename = level_file_info->filename;
1199   char cookie[MAX_LINE_LEN];
1200   char chunk_name[CHUNK_ID_LEN + 1];
1201   int chunk_size;
1202   FILE *file;
1203
1204   if (!(file = fopen(filename, MODE_READ)))
1205   {
1206     level->no_valid_file = TRUE;
1207
1208     if (level != &level_template)
1209       Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
1210
1211     return;
1212   }
1213
1214   getFileChunkBE(file, chunk_name, NULL);
1215   if (strcmp(chunk_name, "RND1") == 0)
1216   {
1217     getFile32BitBE(file);               /* not used */
1218
1219     getFileChunkBE(file, chunk_name, NULL);
1220     if (strcmp(chunk_name, "CAVE") != 0)
1221     {
1222       level->no_valid_file = TRUE;
1223
1224       Error(ERR_WARN, "unknown format of level file '%s'", filename);
1225       fclose(file);
1226       return;
1227     }
1228   }
1229   else  /* check for pre-2.0 file format with cookie string */
1230   {
1231     strcpy(cookie, chunk_name);
1232     fgets(&cookie[4], MAX_LINE_LEN - 4, file);
1233     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
1234       cookie[strlen(cookie) - 1] = '\0';
1235
1236     if (!checkCookieString(cookie, LEVEL_COOKIE_TMPL))
1237     {
1238       level->no_valid_file = TRUE;
1239
1240       Error(ERR_WARN, "unknown format of level file '%s'", filename);
1241       fclose(file);
1242       return;
1243     }
1244
1245     if ((level->file_version = getFileVersionFromCookieString(cookie)) == -1)
1246     {
1247       level->no_valid_file = TRUE;
1248
1249       Error(ERR_WARN, "unsupported version of level file '%s'", filename);
1250       fclose(file);
1251       return;
1252     }
1253
1254     /* pre-2.0 level files have no game version, so use file version here */
1255     level->game_version = level->file_version;
1256   }
1257
1258   if (level->file_version < FILE_VERSION_1_2)
1259   {
1260     /* level files from versions before 1.2.0 without chunk structure */
1261     LoadLevel_HEAD(file, LEVEL_HEADER_SIZE,             level);
1262     LoadLevel_BODY(file, level->fieldx * level->fieldy, level);
1263   }
1264   else
1265   {
1266     static struct
1267     {
1268       char *name;
1269       int size;
1270       int (*loader)(FILE *, int, struct LevelInfo *);
1271     }
1272     chunk_info[] =
1273     {
1274       { "VERS", FILE_VERS_CHUNK_SIZE,   LoadLevel_VERS },
1275       { "HEAD", LEVEL_HEADER_SIZE,      LoadLevel_HEAD },
1276       { "AUTH", MAX_LEVEL_AUTHOR_LEN,   LoadLevel_AUTH },
1277       { "BODY", -1,                     LoadLevel_BODY },
1278       { "CONT", -1,                     LoadLevel_CONT },
1279       { "CNT2", LEVEL_CHUNK_CNT2_SIZE,  LoadLevel_CNT2 },
1280       { "CNT3", -1,                     LoadLevel_CNT3 },
1281       { "CUS1", -1,                     LoadLevel_CUS1 },
1282       { "CUS2", -1,                     LoadLevel_CUS2 },
1283       { "CUS3", -1,                     LoadLevel_CUS3 },
1284       { "CUS4", -1,                     LoadLevel_CUS4 },
1285       { "GRP1", -1,                     LoadLevel_GRP1 },
1286       {  NULL,  0,                      NULL }
1287     };
1288
1289     while (getFileChunkBE(file, chunk_name, &chunk_size))
1290     {
1291       int i = 0;
1292
1293       while (chunk_info[i].name != NULL &&
1294              strcmp(chunk_name, chunk_info[i].name) != 0)
1295         i++;
1296
1297       if (chunk_info[i].name == NULL)
1298       {
1299         Error(ERR_WARN, "unknown chunk '%s' in level file '%s'",
1300               chunk_name, filename);
1301         ReadUnusedBytesFromFile(file, chunk_size);
1302       }
1303       else if (chunk_info[i].size != -1 &&
1304                chunk_info[i].size != chunk_size)
1305       {
1306         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
1307               chunk_size, chunk_name, filename);
1308         ReadUnusedBytesFromFile(file, chunk_size);
1309       }
1310       else
1311       {
1312         /* call function to load this level chunk */
1313         int chunk_size_expected =
1314           (chunk_info[i].loader)(file, chunk_size, level);
1315
1316         /* the size of some chunks cannot be checked before reading other
1317            chunks first (like "HEAD" and "BODY") that contain some header
1318            information, so check them here */
1319         if (chunk_size_expected != chunk_size)
1320         {
1321           Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
1322                 chunk_size, chunk_name, filename);
1323         }
1324       }
1325     }
1326   }
1327
1328   fclose(file);
1329 }
1330
1331 /* ------------------------------------------------------------------------- */
1332 /* functions for loading EM level                                            */
1333 /* ------------------------------------------------------------------------- */
1334
1335 static int map_em_element_yam(int element)
1336 {
1337   switch (element)
1338   {
1339     case 0x00:  return EL_EMPTY;
1340     case 0x01:  return EL_EMERALD;
1341     case 0x02:  return EL_DIAMOND;
1342     case 0x03:  return EL_ROCK;
1343     case 0x04:  return EL_ROBOT;
1344     case 0x05:  return EL_SPACESHIP_UP;
1345     case 0x06:  return EL_BOMB;
1346     case 0x07:  return EL_BUG_UP;
1347     case 0x08:  return EL_AMOEBA_DROP;
1348     case 0x09:  return EL_NUT;
1349     case 0x0a:  return EL_YAMYAM;
1350     case 0x0b:  return EL_QUICKSAND_FULL;
1351     case 0x0c:  return EL_SAND;
1352     case 0x0d:  return EL_WALL_SLIPPERY;
1353     case 0x0e:  return EL_STEELWALL;
1354     case 0x0f:  return EL_WALL;
1355     case 0x10:  return EL_EM_KEY_1;
1356     case 0x11:  return EL_EM_KEY_2;
1357     case 0x12:  return EL_EM_KEY_4;
1358     case 0x13:  return EL_EM_KEY_3;
1359     case 0x14:  return EL_MAGIC_WALL;
1360     case 0x15:  return EL_ROBOT_WHEEL;
1361     case 0x16:  return EL_DYNAMITE;
1362
1363     case 0x17:  return EL_EM_KEY_1;                     /* EMC */
1364     case 0x18:  return EL_BUG_UP;                       /* EMC */
1365     case 0x1a:  return EL_DIAMOND;                      /* EMC */
1366     case 0x1b:  return EL_EMERALD;                      /* EMC */
1367     case 0x25:  return EL_NUT;                          /* EMC */
1368     case 0x80:  return EL_EMPTY;                        /* EMC */
1369     case 0x85:  return EL_EM_KEY_1;                     /* EMC */
1370     case 0x86:  return EL_EM_KEY_2;                     /* EMC */
1371     case 0x87:  return EL_EM_KEY_4;                     /* EMC */
1372     case 0x88:  return EL_EM_KEY_3;                     /* EMC */
1373     case 0x94:  return EL_QUICKSAND_EMPTY;              /* EMC */
1374     case 0x9a:  return EL_AMOEBA_WET;                   /* EMC */
1375     case 0xaf:  return EL_DYNAMITE;                     /* EMC */
1376     case 0xbd:  return EL_SAND;                         /* EMC */
1377
1378     default:
1379       Error(ERR_WARN, "invalid level element %d", element);
1380       return EL_UNKNOWN;
1381   }
1382 }
1383
1384 static int map_em_element_field(int element)
1385 {
1386   if (element >= 0xc8 && element <= 0xe1)
1387     return EL_CHAR_A + (element - 0xc8);
1388   else if (element >= 0xe2 && element <= 0xeb)
1389     return EL_CHAR_0 + (element - 0xe2);
1390
1391   switch (element)
1392   {
1393     case 0x00:  return EL_ROCK;
1394     case 0x01:  return EL_ROCK;                         /* EMC */
1395     case 0x02:  return EL_DIAMOND;
1396     case 0x03:  return EL_DIAMOND;
1397     case 0x04:  return EL_ROBOT;
1398     case 0x05:  return EL_ROBOT;                        /* EMC */
1399     case 0x06:  return EL_EMPTY_SPACE;                  /* EMC */
1400     case 0x07:  return EL_EMPTY_SPACE;                  /* EMC */
1401     case 0x08:  return EL_SPACESHIP_UP;
1402     case 0x09:  return EL_SPACESHIP_RIGHT;
1403     case 0x0a:  return EL_SPACESHIP_DOWN;
1404     case 0x0b:  return EL_SPACESHIP_LEFT;
1405     case 0x0c:  return EL_SPACESHIP_UP;
1406     case 0x0d:  return EL_SPACESHIP_RIGHT;
1407     case 0x0e:  return EL_SPACESHIP_DOWN;
1408     case 0x0f:  return EL_SPACESHIP_LEFT;
1409
1410     case 0x10:  return EL_BOMB;
1411     case 0x11:  return EL_BOMB;                         /* EMC */
1412     case 0x12:  return EL_EMERALD;
1413     case 0x13:  return EL_EMERALD;
1414     case 0x14:  return EL_BUG_UP;
1415     case 0x15:  return EL_BUG_RIGHT;
1416     case 0x16:  return EL_BUG_DOWN;
1417     case 0x17:  return EL_BUG_LEFT;
1418     case 0x18:  return EL_BUG_UP;
1419     case 0x19:  return EL_BUG_RIGHT;
1420     case 0x1a:  return EL_BUG_DOWN;
1421     case 0x1b:  return EL_BUG_LEFT;
1422     case 0x1c:  return EL_AMOEBA_DROP;
1423     case 0x1d:  return EL_AMOEBA_DROP;                  /* EMC */
1424     case 0x1e:  return EL_AMOEBA_DROP;                  /* EMC */
1425     case 0x1f:  return EL_AMOEBA_DROP;                  /* EMC */
1426
1427     case 0x20:  return EL_ROCK;
1428     case 0x21:  return EL_BOMB;                         /* EMC */
1429     case 0x22:  return EL_DIAMOND;                      /* EMC */
1430     case 0x23:  return EL_EMERALD;                      /* EMC */
1431     case 0x24:  return EL_MAGIC_WALL;
1432     case 0x25:  return EL_NUT;
1433     case 0x26:  return EL_NUT;                          /* EMC */
1434     case 0x27:  return EL_NUT;                          /* EMC */
1435
1436       /* looks like magic wheel, but is _always_ activated */
1437     case 0x28:  return EL_ROBOT_WHEEL;                  /* EMC */
1438
1439     case 0x29:  return EL_YAMYAM;       /* up */
1440     case 0x2a:  return EL_YAMYAM;       /* down */
1441     case 0x2b:  return EL_YAMYAM;       /* left */      /* EMC */
1442     case 0x2c:  return EL_YAMYAM;       /* right */     /* EMC */
1443     case 0x2d:  return EL_QUICKSAND_FULL;
1444     case 0x2e:  return EL_EMPTY_SPACE;                  /* EMC */
1445     case 0x2f:  return EL_EMPTY_SPACE;                  /* EMC */
1446
1447     case 0x30:  return EL_EMPTY_SPACE;                  /* EMC */
1448     case 0x31:  return EL_SAND;                         /* EMC */
1449     case 0x32:  return EL_SAND;                         /* EMC */
1450     case 0x33:  return EL_SAND;                         /* EMC */
1451     case 0x34:  return EL_QUICKSAND_FULL;               /* EMC */
1452     case 0x35:  return EL_QUICKSAND_FULL;               /* EMC */
1453     case 0x36:  return EL_QUICKSAND_FULL;               /* EMC */
1454     case 0x37:  return EL_SAND;                         /* EMC */
1455     case 0x38:  return EL_ROCK;                         /* EMC */
1456     case 0x39:  return EL_EXPANDABLE_WALL_HORIZONTAL;   /* EMC */
1457     case 0x3a:  return EL_EXPANDABLE_WALL_VERTICAL;     /* EMC */
1458     case 0x3b:  return EL_DYNAMITE_ACTIVE;      /* 1 */
1459     case 0x3c:  return EL_DYNAMITE_ACTIVE;      /* 2 */
1460     case 0x3d:  return EL_DYNAMITE_ACTIVE;      /* 3 */
1461     case 0x3e:  return EL_DYNAMITE_ACTIVE;      /* 4 */
1462     case 0x3f:  return EL_ACID_POOL_BOTTOM;
1463
1464     case 0x40:  return EL_EXIT_OPEN;    /* 1 */
1465     case 0x41:  return EL_EXIT_OPEN;    /* 2 */
1466     case 0x42:  return EL_EXIT_OPEN;    /* 3 */
1467     case 0x43:  return EL_BALLOON;                      /* EMC */
1468     case 0x44:  return EL_UNKNOWN;                      /* EMC ("plant") */
1469     case 0x45:  return EL_SPRING;                       /* EMC */
1470     case 0x46:  return EL_SPRING;       /* falling */   /* EMC */
1471     case 0x47:  return EL_SPRING;       /* left */      /* EMC */
1472     case 0x48:  return EL_SPRING;       /* right */     /* EMC */
1473     case 0x49:  return EL_UNKNOWN;                      /* EMC ("ball 1") */
1474     case 0x4a:  return EL_UNKNOWN;                      /* EMC ("ball 2") */
1475     case 0x4b:  return EL_UNKNOWN;                      /* EMC ("android") */
1476     case 0x4c:  return EL_EMPTY_SPACE;                  /* EMC */
1477     case 0x4d:  return EL_UNKNOWN;                      /* EMC ("android") */
1478     case 0x4e:  return EL_INVISIBLE_WALL;               /* EMC (? "android") */
1479     case 0x4f:  return EL_UNKNOWN;                      /* EMC ("android") */
1480
1481     case 0x50:  return EL_UNKNOWN;                      /* EMC ("android") */
1482     case 0x51:  return EL_UNKNOWN;                      /* EMC ("android") */
1483     case 0x52:  return EL_UNKNOWN;                      /* EMC ("android") */
1484     case 0x53:  return EL_UNKNOWN;                      /* EMC ("android") */
1485     case 0x54:  return EL_UNKNOWN;                      /* EMC ("android") */
1486     case 0x55:  return EL_EMPTY_SPACE;                  /* EMC */
1487     case 0x56:  return EL_EMPTY_SPACE;                  /* EMC */
1488     case 0x57:  return EL_EMPTY_SPACE;                  /* EMC */
1489     case 0x58:  return EL_EMPTY_SPACE;                  /* EMC */
1490     case 0x59:  return EL_EMPTY_SPACE;                  /* EMC */
1491     case 0x5a:  return EL_EMPTY_SPACE;                  /* EMC */
1492     case 0x5b:  return EL_EMPTY_SPACE;                  /* EMC */
1493     case 0x5c:  return EL_EMPTY_SPACE;                  /* EMC */
1494     case 0x5d:  return EL_EMPTY_SPACE;                  /* EMC */
1495     case 0x5e:  return EL_EMPTY_SPACE;                  /* EMC */
1496     case 0x5f:  return EL_EMPTY_SPACE;                  /* EMC */
1497
1498     case 0x60:  return EL_EMPTY_SPACE;                  /* EMC */
1499     case 0x61:  return EL_EMPTY_SPACE;                  /* EMC */
1500     case 0x62:  return EL_EMPTY_SPACE;                  /* EMC */
1501     case 0x63:  return EL_SPRING;       /* left */      /* EMC */
1502     case 0x64:  return EL_SPRING;       /* right */     /* EMC */
1503     case 0x65:  return EL_ACID;         /* 1 */         /* EMC */
1504     case 0x66:  return EL_ACID;         /* 2 */         /* EMC */
1505     case 0x67:  return EL_ACID;         /* 3 */         /* EMC */
1506     case 0x68:  return EL_ACID;         /* 4 */         /* EMC */
1507     case 0x69:  return EL_ACID;         /* 5 */         /* EMC */
1508     case 0x6a:  return EL_ACID;         /* 6 */         /* EMC */
1509     case 0x6b:  return EL_ACID;         /* 7 */         /* EMC */
1510     case 0x6c:  return EL_ACID;         /* 8 */         /* EMC */
1511     case 0x6d:  return EL_EMPTY_SPACE;                  /* EMC */
1512     case 0x6e:  return EL_EMPTY_SPACE;                  /* EMC */
1513     case 0x6f:  return EL_EMPTY_SPACE;                  /* EMC */
1514
1515     case 0x70:  return EL_EMPTY_SPACE;                  /* EMC */
1516     case 0x71:  return EL_EMPTY_SPACE;                  /* EMC */
1517     case 0x72:  return EL_NUT;          /* left */      /* EMC */
1518     case 0x73:  return EL_SAND;                         /* EMC (? "nut") */
1519     case 0x74:  return EL_STEELWALL;
1520     case 0x75:  return EL_EMPTY_SPACE;                  /* EMC */
1521     case 0x76:  return EL_EMPTY_SPACE;                  /* EMC */
1522     case 0x77:  return EL_BOMB;         /* left */      /* EMC */
1523     case 0x78:  return EL_BOMB;         /* right */     /* EMC */
1524     case 0x79:  return EL_ROCK;         /* left */      /* EMC */
1525     case 0x7a:  return EL_ROCK;         /* right */     /* EMC */
1526     case 0x7b:  return EL_ACID;                         /* (? EMC "blank") */
1527     case 0x7c:  return EL_EMPTY_SPACE;                  /* EMC */
1528     case 0x7d:  return EL_EMPTY_SPACE;                  /* EMC */
1529     case 0x7e:  return EL_EMPTY_SPACE;                  /* EMC */
1530     case 0x7f:  return EL_EMPTY_SPACE;                  /* EMC */
1531
1532     case 0x80:  return EL_EMPTY;
1533     case 0x81:  return EL_WALL_SLIPPERY;
1534     case 0x82:  return EL_SAND;
1535     case 0x83:  return EL_STEELWALL;
1536     case 0x84:  return EL_WALL;
1537     case 0x85:  return EL_EM_KEY_1;
1538     case 0x86:  return EL_EM_KEY_2;
1539     case 0x87:  return EL_EM_KEY_4;
1540     case 0x88:  return EL_EM_KEY_3;
1541     case 0x89:  return EL_EM_GATE_1;
1542     case 0x8a:  return EL_EM_GATE_2;
1543     case 0x8b:  return EL_EM_GATE_4;
1544     case 0x8c:  return EL_EM_GATE_3;
1545     case 0x8d:  return EL_INVISIBLE_WALL;               /* EMC (? "dripper") */
1546     case 0x8e:  return EL_EM_GATE_1_GRAY;
1547     case 0x8f:  return EL_EM_GATE_2_GRAY;
1548
1549     case 0x90:  return EL_EM_GATE_4_GRAY;
1550     case 0x91:  return EL_EM_GATE_3_GRAY;
1551     case 0x92:  return EL_MAGIC_WALL;
1552     case 0x93:  return EL_ROBOT_WHEEL;
1553     case 0x94:  return EL_QUICKSAND_EMPTY;              /* (? EMC "sand") */
1554     case 0x95:  return EL_ACID_POOL_TOPLEFT;
1555     case 0x96:  return EL_ACID_POOL_TOPRIGHT;
1556     case 0x97:  return EL_ACID_POOL_BOTTOMLEFT;
1557     case 0x98:  return EL_ACID_POOL_BOTTOMRIGHT;
1558     case 0x99:  return EL_ACID;                 /* (? EMC "fake blank") */
1559     case 0x9a:  return EL_AMOEBA_DEAD;          /* 1 */
1560     case 0x9b:  return EL_AMOEBA_DEAD;          /* 2 */
1561     case 0x9c:  return EL_AMOEBA_DEAD;          /* 3 */
1562     case 0x9d:  return EL_AMOEBA_DEAD;          /* 4 */
1563     case 0x9e:  return EL_EXIT_CLOSED;
1564     case 0x9f:  return EL_CHAR_LESS;            /* arrow left */
1565
1566       /* looks like normal sand, but behaves like wall */
1567     case 0xa0:  return EL_UNKNOWN;              /* EMC ("fake grass") */
1568     case 0xa1:  return EL_UNKNOWN;              /* EMC ("lenses") */
1569     case 0xa2:  return EL_UNKNOWN;              /* EMC ("magnify") */
1570     case 0xa3:  return EL_UNKNOWN;              /* EMC ("fake blank") */
1571     case 0xa4:  return EL_UNKNOWN;              /* EMC ("fake grass") */
1572     case 0xa5:  return EL_UNKNOWN;              /* EMC ("switch") */
1573     case 0xa6:  return EL_UNKNOWN;              /* EMC ("switch") */
1574     case 0xa7:  return EL_EMPTY_SPACE;                  /* EMC */
1575     case 0xa8:  return EL_EMC_WALL_1;                   /* EMC ("decor 8") */
1576     case 0xa9:  return EL_EMC_WALL_2;                   /* EMC ("decor 9") */
1577     case 0xaa:  return EL_EMC_WALL_3;                   /* EMC ("decor 10") */
1578     case 0xab:  return EL_EMC_WALL_7;                   /* EMC ("decor 5") */
1579     case 0xac:  return EL_CHAR_COMMA;                   /* EMC */
1580     case 0xad:  return EL_CHAR_QUOTEDBL;                /* EMC */
1581     case 0xae:  return EL_CHAR_MINUS;                   /* EMC */
1582     case 0xaf:  return EL_DYNAMITE;
1583
1584     case 0xb0:  return EL_EMC_STEELWALL_1;              /* EMC ("steel 3") */
1585     case 0xb1:  return EL_EMC_WALL_8;                   /* EMC ("decor 6") */
1586     case 0xb2:  return EL_UNKNOWN;                      /* EMC ("decor 7") */
1587     case 0xb3:  return EL_STEELWALL;            /* 2 */ /* EMC */
1588     case 0xb4:  return EL_WALL_SLIPPERY;        /* 2 */ /* EMC */
1589     case 0xb5:  return EL_EMC_WALL_6;                   /* EMC ("decor 2") */
1590     case 0xb6:  return EL_EMC_WALL_5;                   /* EMC ("decor 4") */
1591     case 0xb7:  return EL_EMC_WALL_4;                   /* EMC ("decor 3") */
1592     case 0xb8:  return EL_BALLOON_SWITCH_ANY;           /* EMC */
1593     case 0xb9:  return EL_BALLOON_SWITCH_RIGHT;         /* EMC */
1594     case 0xba:  return EL_BALLOON_SWITCH_DOWN;          /* EMC */
1595     case 0xbb:  return EL_BALLOON_SWITCH_LEFT;          /* EMC */
1596     case 0xbc:  return EL_BALLOON_SWITCH_UP;            /* EMC */
1597     case 0xbd:  return EL_SAND;                         /* EMC ("dirt") */
1598     case 0xbe:  return EL_UNKNOWN;                      /* EMC ("plant") */
1599     case 0xbf:  return EL_UNKNOWN;                      /* EMC ("key 5") */
1600
1601     case 0xc0:  return EL_UNKNOWN;                      /* EMC ("key 6") */
1602     case 0xc1:  return EL_UNKNOWN;                      /* EMC ("key 7") */
1603     case 0xc2:  return EL_UNKNOWN;                      /* EMC ("key 8") */
1604     case 0xc3:  return EL_UNKNOWN;                      /* EMC ("door 5") */
1605     case 0xc4:  return EL_UNKNOWN;                      /* EMC ("door 6") */
1606     case 0xc5:  return EL_UNKNOWN;                      /* EMC ("door 7") */
1607     case 0xc6:  return EL_UNKNOWN;                      /* EMC ("door 8") */
1608     case 0xc7:  return EL_UNKNOWN;                      /* EMC ("bumper") */
1609
1610       /* characters: see above */
1611
1612     case 0xec:  return EL_CHAR_PERIOD;
1613     case 0xed:  return EL_CHAR_EXCLAM;
1614     case 0xee:  return EL_CHAR_COLON;
1615     case 0xef:  return EL_CHAR_QUESTION;
1616
1617     case 0xf0:  return EL_CHAR_GREATER;                 /* arrow right */
1618     case 0xf1:  return EL_CHAR_COPYRIGHT;               /* EMC: "decor 1" */
1619     case 0xf2:  return EL_UNKNOWN;              /* EMC ("fake door 5") */
1620     case 0xf3:  return EL_UNKNOWN;              /* EMC ("fake door 6") */
1621     case 0xf4:  return EL_UNKNOWN;              /* EMC ("fake door 7") */
1622     case 0xf5:  return EL_UNKNOWN;              /* EMC ("fake door 8") */
1623     case 0xf6:  return EL_EMPTY_SPACE;                  /* EMC */
1624     case 0xf7:  return EL_EMPTY_SPACE;                  /* EMC */
1625
1626     case 0xf8:  return EL_EMPTY_SPACE;                  /* EMC */
1627     case 0xf9:  return EL_EMPTY_SPACE;                  /* EMC */
1628     case 0xfa:  return EL_EMPTY_SPACE;                  /* EMC */
1629     case 0xfb:  return EL_EMPTY_SPACE;                  /* EMC */
1630     case 0xfc:  return EL_EMPTY_SPACE;                  /* EMC */
1631     case 0xfd:  return EL_EMPTY_SPACE;                  /* EMC */
1632
1633     case 0xfe:  return EL_PLAYER_1;                     /* EMC: "blank" */
1634     case 0xff:  return EL_PLAYER_2;                     /* EMC: "blank" */
1635
1636     default:
1637       /* should never happen (all 8-bit value cases should be handled) */
1638       Error(ERR_WARN, "invalid level element %d", element);
1639       return EL_UNKNOWN;
1640   }
1641 }
1642
1643 #define EM_LEVEL_SIZE                   2106
1644 #define EM_LEVEL_XSIZE                  64
1645 #define EM_LEVEL_YSIZE                  32
1646
1647 static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
1648                                      struct LevelFileInfo *level_file_info)
1649 {
1650   char *filename = level_file_info->filename;
1651   FILE *file;
1652   unsigned char leveldata[EM_LEVEL_SIZE];
1653   unsigned char *header = &leveldata[EM_LEVEL_XSIZE * EM_LEVEL_YSIZE];
1654   unsigned char code0 = 0x65;
1655   unsigned char code1 = 0x11;
1656   boolean level_is_crypted = FALSE;
1657   int nr = level_file_info->nr;
1658   int i, x, y;
1659
1660   if (!(file = fopen(filename, MODE_READ)))
1661   {
1662     level->no_valid_file = TRUE;
1663
1664     Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
1665
1666     return;
1667   }
1668
1669   for(i = 0; i < EM_LEVEL_SIZE; i++)
1670     leveldata[i] = fgetc(file);
1671
1672   fclose(file);
1673
1674   /* check if level data is crypted by testing against known starting bytes
1675      of the few existing crypted level files (from Emerald Mine 1 + 2) */
1676
1677   if ((leveldata[0] == 0xf1 ||
1678        leveldata[0] == 0xf5) && leveldata[2] == 0xe7 && leveldata[3] == 0xee)
1679   {
1680     level_is_crypted = TRUE;
1681
1682     if (leveldata[0] == 0xf5)   /* error in crypted Emerald Mine 2 levels */
1683       leveldata[0] = 0xf1;
1684   }
1685
1686   if (level_is_crypted)         /* decode crypted level data */
1687   {
1688     for(i = 0; i < EM_LEVEL_SIZE; i++)
1689     {
1690       leveldata[i] ^= code0;
1691       leveldata[i] -= code1;
1692
1693       code0  = (code0 + 7) & 0xff;
1694     }
1695   }
1696
1697   level->fieldx = EM_LEVEL_XSIZE;
1698   level->fieldy = EM_LEVEL_YSIZE;
1699
1700   level->time           = header[46] * 10;
1701   level->gems_needed    = header[47];
1702
1703   /* The original Emerald Mine levels have their level number stored
1704      at the second byte of the level file...
1705      Do not trust this information at other level files, e.g. EMC,
1706      but correct it anyway (normally the first row is completely
1707      steel wall, so the correction does not hurt anyway). */
1708
1709   if (leveldata[1] == nr)
1710     leveldata[1] = leveldata[2];        /* correct level number field */
1711
1712   sprintf(level->name, "Level %d", nr);         /* set level name */
1713
1714   level->score[SC_EMERALD]      = header[36];
1715   level->score[SC_DIAMOND]      = header[37];
1716   level->score[SC_ROBOT]        = header[38];
1717   level->score[SC_SPACESHIP]    = header[39];
1718   level->score[SC_BUG]          = header[40];
1719   level->score[SC_YAMYAM]       = header[41];
1720   level->score[SC_NUT]          = header[42];
1721   level->score[SC_DYNAMITE]     = header[43];
1722   level->score[SC_TIME_BONUS]   = header[44];
1723
1724   level->num_yamyam_contents = 4;
1725
1726   for(i = 0; i < level->num_yamyam_contents; i++)
1727     for(y = 0; y < 3; y++)
1728       for(x = 0; x < 3; x++)
1729         level->yamyam_content[i][x][y] =
1730           map_em_element_yam(header[i * 9 + y * 3 + x]);
1731
1732   level->amoeba_speed           = (header[52] * 256 + header[53]) % 256;
1733   level->time_magic_wall        = (header[54] * 256 + header[55]) * 16 / 100;
1734   level->time_wheel             = (header[56] * 256 + header[57]) * 16 / 100;
1735   level->amoeba_content         = EL_DIAMOND;
1736
1737   for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
1738   {
1739     int new_element = map_em_element_field(leveldata[y * EM_LEVEL_XSIZE + x]);
1740
1741     if (new_element == EL_AMOEBA_DEAD && level->amoeba_speed)
1742       new_element = EL_AMOEBA_WET;
1743
1744     level->field[x][y] = new_element;
1745   }
1746
1747   x = (header[48] * 256 + header[49]) % EM_LEVEL_XSIZE;
1748   y = (header[48] * 256 + header[49]) / EM_LEVEL_XSIZE;
1749   level->field[x][y] = EL_PLAYER_1;
1750
1751   x = (header[50] * 256 + header[51]) % EM_LEVEL_XSIZE;
1752   y = (header[50] * 256 + header[51]) / EM_LEVEL_XSIZE;
1753   level->field[x][y] = EL_PLAYER_2;
1754 }
1755
1756 /* ------------------------------------------------------------------------- */
1757 /* functions for loading SP level                                            */
1758 /* ------------------------------------------------------------------------- */
1759
1760 #define NUM_SUPAPLEX_LEVELS_PER_PACKAGE 111
1761 #define SP_LEVEL_SIZE                   1536
1762 #define SP_LEVEL_XSIZE                  60
1763 #define SP_LEVEL_YSIZE                  24
1764 #define SP_LEVEL_NAME_LEN               23
1765
1766 static void LoadLevelFromFileStream_SP(FILE *file, struct LevelInfo *level,
1767                                        int nr)
1768 {
1769   int i, x, y;
1770
1771   /* read level body (width * height == 60 * 24 tiles == 1440 bytes) */
1772   for (y = 0; y < SP_LEVEL_YSIZE; y++)
1773   {
1774     for (x = 0; x < SP_LEVEL_XSIZE; x++)
1775     {
1776       int element_old = fgetc(file);
1777       int element_new;
1778
1779       if (element_old <= 0x27)
1780         element_new = getMappedElement(EL_SP_START + element_old);
1781       else if (element_old == 0x28)
1782         element_new = EL_INVISIBLE_WALL;
1783       else
1784       {
1785         Error(ERR_WARN, "in level %d, at position %d, %d:", nr, x, y);
1786         Error(ERR_WARN, "invalid level element %d", element_old);
1787
1788         element_new = EL_UNKNOWN;
1789       }
1790
1791       level->field[x][y] = element_new;
1792     }
1793   }
1794
1795   ReadUnusedBytesFromFile(file, 4);
1796
1797   /* Initial gravitation: 1 == "on", anything else (0) == "off" */
1798   level->initial_gravity = (fgetc(file) == 1 ? TRUE : FALSE);
1799
1800   ReadUnusedBytesFromFile(file, 1);
1801
1802   /* level title in uppercase letters, padded with dashes ("-") (23 bytes) */
1803   for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
1804     level->name[i] = fgetc(file);
1805   level->name[SP_LEVEL_NAME_LEN] = '\0';
1806
1807   /* initial "freeze zonks": 2 == "on", anything else (0) == "off" */
1808   ReadUnusedBytesFromFile(file, 1);     /* !!! NOT SUPPORTED YET !!! */
1809
1810   /* number of infotrons needed; 0 means that Supaplex will count the total
1811      amount of infotrons in the level and use the low byte of that number.
1812      (a multiple of 256 infotrons will result in "0 infotrons needed"!) */
1813   level->gems_needed = fgetc(file);
1814
1815   /* information about special gravity port entries */
1816   ReadUnusedBytesFromFile(file, 65);    /* !!! NOT SUPPORTED YET !!! */
1817
1818   level->fieldx = SP_LEVEL_XSIZE;
1819   level->fieldy = SP_LEVEL_YSIZE;
1820
1821   level->time = 0;                      /* no time limit */
1822   level->amoeba_speed = 0;
1823   level->time_magic_wall = 0;
1824   level->time_wheel = 0;
1825   level->amoeba_content = EL_EMPTY;
1826
1827   for(i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
1828     level->score[i] = 0;                /* !!! CORRECT THIS !!! */
1829
1830   /* there are no yamyams in supaplex levels */
1831   for(i = 0; i < level->num_yamyam_contents; i++)
1832     for(y = 0; y < 3; y++)
1833       for(x = 0; x < 3; x++)
1834         level->yamyam_content[i][x][y] = EL_EMPTY;
1835 }
1836
1837 static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
1838                                      struct LevelFileInfo *level_file_info)
1839 {
1840   char *filename = level_file_info->filename;
1841   FILE *file;
1842   int nr = level_file_info->nr - leveldir_current->first_level;
1843   int i, l, x, y;
1844   char name_first, name_last;
1845   struct LevelInfo multipart_level;
1846   int multipart_xpos, multipart_ypos;
1847   boolean is_multipart_level;
1848   boolean is_first_part;
1849   boolean reading_multipart_level = FALSE;
1850   boolean use_empty_level = FALSE;
1851
1852   if (!(file = fopen(filename, MODE_READ)))
1853   {
1854     level->no_valid_file = TRUE;
1855
1856     Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
1857
1858     return;
1859   }
1860
1861   /* position file stream to the requested level inside the level package */
1862   if (fseek(file, nr * SP_LEVEL_SIZE, SEEK_SET) != 0)
1863   {
1864     level->no_valid_file = TRUE;
1865
1866     Error(ERR_WARN, "cannot fseek level '%s' -- using empty level", filename);
1867
1868     return;
1869   }
1870
1871   /* there exist Supaplex level package files with multi-part levels which
1872      can be detected as follows: instead of leading and trailing dashes ('-')
1873      to pad the level name, they have leading and trailing numbers which are
1874      the x and y coordinations of the current part of the multi-part level;
1875      if there are '?' characters instead of numbers on the left or right side
1876      of the level name, the multi-part level consists of only horizontal or
1877      vertical parts */
1878
1879   for (l = nr; l < NUM_SUPAPLEX_LEVELS_PER_PACKAGE; l++)
1880   {
1881     LoadLevelFromFileStream_SP(file, level, l);
1882
1883     /* check if this level is a part of a bigger multi-part level */
1884
1885     name_first = level->name[0];
1886     name_last  = level->name[SP_LEVEL_NAME_LEN - 1];
1887
1888     is_multipart_level =
1889       ((name_first == '?' || (name_first >= '0' && name_first <= '9')) &&
1890        (name_last  == '?' || (name_last  >= '0' && name_last  <= '9')));
1891
1892     is_first_part =
1893       ((name_first == '?' || name_first == '1') &&
1894        (name_last  == '?' || name_last  == '1'));
1895
1896     /* correct leading multipart level meta information in level name */
1897     for (i = 0; i < SP_LEVEL_NAME_LEN && level->name[i] == name_first; i++)
1898       level->name[i] = '-';
1899
1900     /* correct trailing multipart level meta information in level name */
1901     for (i = SP_LEVEL_NAME_LEN - 1; i>=0 && level->name[i] == name_last; i--)
1902       level->name[i] = '-';
1903
1904     /* ---------- check for normal single level ---------- */
1905
1906     if (!reading_multipart_level && !is_multipart_level)
1907     {
1908       /* the current level is simply a normal single-part level, and we are
1909          not reading a multi-part level yet, so return the level as it is */
1910
1911       break;
1912     }
1913
1914     /* ---------- check for empty level (unused multi-part) ---------- */
1915
1916     if (!reading_multipart_level && is_multipart_level && !is_first_part)
1917     {
1918       /* this is a part of a multi-part level, but not the first part
1919          (and we are not already reading parts of a multi-part level);
1920          in this case, use an empty level instead of the single part */
1921
1922       use_empty_level = TRUE;
1923
1924       break;
1925     }
1926
1927     /* ---------- check for finished multi-part level ---------- */
1928
1929     if (reading_multipart_level &&
1930         (!is_multipart_level ||
1931          strcmp(level->name, multipart_level.name) != 0))
1932     {
1933       /* we are already reading parts of a multi-part level, but this level is
1934          either not a multi-part level, or a part of a different multi-part
1935          level; in both cases, the multi-part level seems to be complete */
1936
1937       break;
1938     }
1939
1940     /* ---------- here we have one part of a multi-part level ---------- */
1941
1942     reading_multipart_level = TRUE;
1943
1944     if (is_first_part)  /* start with first part of new multi-part level */
1945     {
1946       /* copy level info structure from first part */
1947       multipart_level = *level;
1948
1949       /* clear playfield of new multi-part level */
1950       for (y = 0; y < MAX_LEV_FIELDY; y++)
1951         for (x = 0; x < MAX_LEV_FIELDX; x++)
1952           multipart_level.field[x][y] = EL_EMPTY;
1953     }
1954
1955     if (name_first == '?')
1956       name_first = '1';
1957     if (name_last == '?')
1958       name_last = '1';
1959
1960     multipart_xpos = (int)(name_first - '0');
1961     multipart_ypos = (int)(name_last  - '0');
1962
1963 #if 0
1964     printf("----------> part (%d/%d) of multi-part level '%s'\n",
1965            multipart_xpos, multipart_ypos, multipart_level.name);
1966 #endif
1967
1968     if (multipart_xpos * SP_LEVEL_XSIZE > MAX_LEV_FIELDX ||
1969         multipart_ypos * SP_LEVEL_YSIZE > MAX_LEV_FIELDY)
1970     {
1971       Error(ERR_WARN, "multi-part level is too big -- ignoring part of it");
1972
1973       break;
1974     }
1975
1976     multipart_level.fieldx = MAX(multipart_level.fieldx,
1977                                  multipart_xpos * SP_LEVEL_XSIZE);
1978     multipart_level.fieldy = MAX(multipart_level.fieldy,
1979                                  multipart_ypos * SP_LEVEL_YSIZE);
1980
1981     /* copy level part at the right position of multi-part level */
1982     for (y = 0; y < SP_LEVEL_YSIZE; y++)
1983     {
1984       for (x = 0; x < SP_LEVEL_XSIZE; x++)
1985       {
1986         int start_x = (multipart_xpos - 1) * SP_LEVEL_XSIZE;
1987         int start_y = (multipart_ypos - 1) * SP_LEVEL_YSIZE;
1988
1989         multipart_level.field[start_x + x][start_y + y] = level->field[x][y];
1990       }
1991     }
1992   }
1993
1994   fclose(file);
1995
1996   if (use_empty_level)
1997   {
1998     setLevelInfoToDefaults(level);
1999
2000     level->fieldx = SP_LEVEL_XSIZE;
2001     level->fieldy = SP_LEVEL_YSIZE;
2002
2003     for (y = 0; y < SP_LEVEL_YSIZE; y++)
2004       for (x = 0; x < SP_LEVEL_XSIZE; x++)
2005         level->field[x][y] = EL_EMPTY;
2006
2007     strcpy(level->name, "-------- EMPTY --------");
2008
2009     Error(ERR_WARN, "single part of multi-part level -- using empty level");
2010   }
2011
2012   if (reading_multipart_level)
2013     *level = multipart_level;
2014 }
2015
2016 /* ------------------------------------------------------------------------- */
2017 /* functions for loading generic level                                       */
2018 /* ------------------------------------------------------------------------- */
2019
2020 void LoadLevelFromFileInfo(struct LevelInfo *level,
2021                            struct LevelFileInfo *level_file_info)
2022 {
2023   /* always start with reliable default values */
2024   setLevelInfoToDefaults(level);
2025
2026   switch (level_file_info->type)
2027   {
2028     case LEVEL_FILE_TYPE_RND:
2029       LoadLevelFromFileInfo_RND(level, level_file_info);
2030       break;
2031
2032     case LEVEL_FILE_TYPE_EM:
2033       LoadLevelFromFileInfo_EM(level, level_file_info);
2034       break;
2035
2036     case LEVEL_FILE_TYPE_SP:
2037       LoadLevelFromFileInfo_SP(level, level_file_info);
2038       break;
2039
2040     default:
2041       LoadLevelFromFileInfo_RND(level, level_file_info);
2042       break;
2043   }
2044 }
2045
2046 void LoadLevelFromFilename(struct LevelInfo *level, char *filename)
2047 {
2048   static struct LevelFileInfo level_file_info;
2049
2050   /* always start with reliable default values */
2051   setFileInfoToDefaults(&level_file_info);
2052
2053   level_file_info.nr = 0;                       /* unknown level number */
2054   level_file_info.type = LEVEL_FILE_TYPE_RND;   /* no others supported yet */
2055   level_file_info.filename = filename;
2056
2057   LoadLevelFromFileInfo(level, &level_file_info);
2058 }
2059
2060 static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
2061 {
2062   if (leveldir_current == NULL)         /* only when dumping level */
2063     return;
2064
2065 #if 0
2066   printf("::: sort_priority: %d\n", leveldir_current->sort_priority);
2067 #endif
2068
2069   /* determine correct game engine version of current level */
2070 #if 1
2071   if (!leveldir_current->latest_engine)
2072 #else
2073   if (IS_LEVELCLASS_CONTRIB(leveldir_current) ||
2074       IS_LEVELCLASS_PRIVATE(leveldir_current) ||
2075       IS_LEVELCLASS_UNDEFINED(leveldir_current))
2076 #endif
2077   {
2078 #if 0
2079     printf("\n::: This level is private or contributed: '%s'\n", filename);
2080 #endif
2081
2082 #if 0
2083     printf("\n::: Use the stored game engine version for this level\n");
2084 #endif
2085
2086     /* For all levels which are not forced to use the latest game engine
2087        version (normally user contributed, private and undefined levels),
2088        use the version of the game engine the levels were created for.
2089
2090        Since 2.0.1, the game engine version is now directly stored
2091        in the level file (chunk "VERS"), so there is no need anymore
2092        to set the game version from the file version (except for old,
2093        pre-2.0 levels, where the game version is still taken from the
2094        file format version used to store the level -- see above). */
2095
2096     /* do some special adjustments to support older level versions */
2097     if (level->file_version == FILE_VERSION_1_0)
2098     {
2099       Error(ERR_WARN, "level file '%s' has version number 1.0", filename);
2100       Error(ERR_WARN, "using high speed movement for player");
2101
2102       /* player was faster than monsters in (pre-)1.0 levels */
2103       level->double_speed = TRUE;
2104     }
2105
2106     /* Default behaviour for EM style gems was "slippery" only in 2.0.1 */
2107     if (level->game_version == VERSION_IDENT(2,0,1,0))
2108       level->em_slippery_gems = TRUE;
2109
2110     if (level->game_version < VERSION_IDENT(2,2,0,0))
2111       level->use_spring_bug = TRUE;
2112
2113     if (level->game_version < VERSION_IDENT(3,1,0,0))
2114     {
2115       int i, j;
2116
2117       level->can_move_into_acid_bits = 0; /* nothing can move into acid */
2118       level->dont_collide_with_bits = 0; /* nothing is deadly when colliding */
2119
2120       setMoveIntoAcidProperty(level, EL_ROBOT,     TRUE);
2121       setMoveIntoAcidProperty(level, EL_SATELLITE, TRUE);
2122       setMoveIntoAcidProperty(level, EL_PENGUIN,   TRUE);
2123       setMoveIntoAcidProperty(level, EL_BALLOON,   TRUE);
2124
2125       for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2126         SET_PROPERTY(EL_CUSTOM_START + i, EP_CAN_MOVE_INTO_ACID, TRUE);
2127
2128       for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2129       {
2130         int element = EL_CUSTOM_START + i;
2131         struct ElementInfo *ei = &element_info[element];
2132
2133         for (j = 0; j < ei->num_change_pages; j++)
2134         {
2135           struct ElementChangeInfo *change = &ei->change_page[j];
2136
2137           change->trigger_player = CH_PLAYER_ANY;
2138           change->trigger_page = CH_PAGE_ANY;
2139         }
2140       }
2141     }
2142   }
2143   else
2144   {
2145 #if 0
2146     printf("\n::: ALWAYS USE LATEST ENGINE FOR THIS LEVEL: [%d] '%s'\n",
2147            leveldir_current->sort_priority, filename);
2148 #endif
2149
2150 #if 0
2151     printf("\n::: Use latest game engine version for this level.\n");
2152 #endif
2153
2154     /* For all levels which are forced to use the latest game engine version
2155        (normally all but user contributed, private and undefined levels), set
2156        the game engine version to the actual version; this allows for actual
2157        corrections in the game engine to take effect for existing, converted
2158        levels (from "classic" or other existing games) to make the emulation
2159        of the corresponding game more accurate, while (hopefully) not breaking
2160        existing levels created from other players. */
2161
2162 #if 0
2163     printf("::: changing engine from %d to %d\n",
2164            level->game_version, GAME_VERSION_ACTUAL);
2165 #endif
2166
2167     level->game_version = GAME_VERSION_ACTUAL;
2168
2169     /* Set special EM style gems behaviour: EM style gems slip down from
2170        normal, steel and growing wall. As this is a more fundamental change,
2171        it seems better to set the default behaviour to "off" (as it is more
2172        natural) and make it configurable in the level editor (as a property
2173        of gem style elements). Already existing converted levels (neither
2174        private nor contributed levels) are changed to the new behaviour. */
2175
2176     if (level->file_version < FILE_VERSION_2_0)
2177       level->em_slippery_gems = TRUE;
2178   }
2179
2180 #if 0
2181   printf("::: => %d\n", level->game_version);
2182 #endif
2183 }
2184
2185 static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
2186 {
2187   int i, j, x, y;
2188
2189   /* map custom element change events that have changed in newer versions
2190      (these following values were accidentally changed in version 3.0.1) */
2191   if (level->game_version <= VERSION_IDENT(3,0,0,0))
2192   {
2193     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2194     {
2195       int element = EL_CUSTOM_START + i;
2196
2197       /* order of checking and copying events to be mapped is important */
2198       for (j = CE_BY_OTHER_ACTION; j >= CE_BY_PLAYER_OBSOLETE; j--)
2199       {
2200         if (HAS_CHANGE_EVENT(element, j - 2))
2201         {
2202           SET_CHANGE_EVENT(element, j - 2, FALSE);
2203           SET_CHANGE_EVENT(element, j, TRUE);
2204         }
2205       }
2206
2207       /* order of checking and copying events to be mapped is important */
2208       for (j = CE_OTHER_GETS_COLLECTED; j >= CE_HITTING_SOMETHING; j--)
2209       {
2210         if (HAS_CHANGE_EVENT(element, j - 1))
2211         {
2212           SET_CHANGE_EVENT(element, j - 1, FALSE);
2213           SET_CHANGE_EVENT(element, j, TRUE);
2214         }
2215       }
2216     }
2217   }
2218
2219   /* some custom element change events get mapped since version 3.0.3 */
2220   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2221   {
2222     int element = EL_CUSTOM_START + i;
2223
2224     if (HAS_CHANGE_EVENT(element, CE_BY_PLAYER_OBSOLETE) ||
2225         HAS_CHANGE_EVENT(element, CE_BY_COLLISION_OBSOLETE))
2226     {
2227       SET_CHANGE_EVENT(element, CE_BY_PLAYER_OBSOLETE, FALSE);
2228       SET_CHANGE_EVENT(element, CE_BY_COLLISION_OBSOLETE, FALSE);
2229
2230       SET_CHANGE_EVENT(element, CE_BY_DIRECT_ACTION, TRUE);
2231     }
2232   }
2233
2234   /* initialize "can_change" field for old levels with only one change page */
2235   if (level->game_version <= VERSION_IDENT(3,0,2,0))
2236   {
2237     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2238     {
2239       int element = EL_CUSTOM_START + i;
2240
2241       if (CAN_CHANGE(element))
2242         element_info[element].change->can_change = TRUE;
2243     }
2244   }
2245
2246   /* correct custom element values (for old levels without these options) */
2247   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2248   {
2249     int element = EL_CUSTOM_START + i;
2250     struct ElementInfo *ei = &element_info[element];
2251
2252     if (ei->access_direction == MV_NO_MOVING)
2253       ei->access_direction = MV_ALL_DIRECTIONS;
2254
2255     for (j = 0; j < ei->num_change_pages; j++)
2256     {
2257       struct ElementChangeInfo *change = &ei->change_page[j];
2258
2259       if (change->trigger_side == CH_SIDE_NONE)
2260         change->trigger_side = CH_SIDE_ANY;
2261     }
2262   }
2263
2264 #if 0
2265   /* set default push delay values (corrected since version 3.0.7-1) */
2266   if (level->game_version < VERSION_IDENT(3,0,7,1))
2267   {
2268     game.default_push_delay_fixed = 2;
2269     game.default_push_delay_random = 8;
2270   }
2271   else
2272   {
2273     game.default_push_delay_fixed = 8;
2274     game.default_push_delay_random = 8;
2275   }
2276
2277   /* set uninitialized push delay values of custom elements in older levels */
2278   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2279   {
2280     int element = EL_CUSTOM_START + i;
2281
2282     if (element_info[element].push_delay_fixed == -1)
2283       element_info[element].push_delay_fixed = game.default_push_delay_fixed;
2284     if (element_info[element].push_delay_random == -1)
2285       element_info[element].push_delay_random = game.default_push_delay_random;
2286   }
2287 #endif
2288
2289   /* map elements that have changed in newer versions */
2290   level->amoeba_content = getMappedElementByVersion(level->amoeba_content,
2291                                                     level->game_version);
2292   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2293     for (x = 0; x < 3; x++)
2294       for (y = 0; y < 3; y++)
2295         level->yamyam_content[i][x][y] =
2296           getMappedElementByVersion(level->yamyam_content[i][x][y],
2297                                     level->game_version);
2298
2299   /* initialize element properties for level editor etc. */
2300   InitElementPropertiesEngine(level->game_version);
2301 }
2302
2303 static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename)
2304 {
2305   int x, y;
2306
2307   /* map elements that have changed in newer versions */
2308   for (y = 0; y < level->fieldy; y++)
2309   {
2310     for (x = 0; x < level->fieldx; x++)
2311     {
2312       int element = level->field[x][y];
2313
2314 #if 1
2315       element = getMappedElementByVersion(element, level->game_version);
2316 #else
2317       if (level->game_version <= VERSION_IDENT(2,2,0,0))
2318       {
2319         /* map game font elements */
2320         element = (element == EL_CHAR('[')  ? EL_CHAR_AUMLAUT :
2321                    element == EL_CHAR('\\') ? EL_CHAR_OUMLAUT :
2322                    element == EL_CHAR(']')  ? EL_CHAR_UUMLAUT :
2323                    element == EL_CHAR('^')  ? EL_CHAR_COPYRIGHT : element);
2324       }
2325
2326       if (level->game_version < VERSION_IDENT(3,0,0,0))
2327       {
2328         /* map Supaplex gravity tube elements */
2329         element = (element == EL_SP_GRAVITY_PORT_LEFT  ? EL_SP_PORT_LEFT  :
2330                    element == EL_SP_GRAVITY_PORT_RIGHT ? EL_SP_PORT_RIGHT :
2331                    element == EL_SP_GRAVITY_PORT_UP    ? EL_SP_PORT_UP    :
2332                    element == EL_SP_GRAVITY_PORT_DOWN  ? EL_SP_PORT_DOWN  :
2333                    element);
2334       }
2335 #endif
2336
2337       level->field[x][y] = element;
2338     }
2339   }
2340
2341   /* copy elements to runtime playfield array */
2342   for (x = 0; x < MAX_LEV_FIELDX; x++)
2343     for (y = 0; y < MAX_LEV_FIELDY; y++)
2344       Feld[x][y] = level->field[x][y];
2345
2346   /* initialize level size variables for faster access */
2347   lev_fieldx = level->fieldx;
2348   lev_fieldy = level->fieldy;
2349
2350   /* determine border element for this level */
2351   SetBorderElement();
2352 }
2353
2354 void LoadLevelTemplate(int nr)
2355 {
2356 #if 1
2357   struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
2358   char *filename = level_file_info->filename;
2359
2360   LoadLevelFromFileInfo(&level_template, level_file_info);
2361 #else
2362   char *filename = getDefaultLevelFilename(nr);
2363
2364   LoadLevelFromFilename_RND(&level_template, filename);
2365 #endif
2366
2367   LoadLevel_InitVersion(&level, filename);
2368   LoadLevel_InitElements(&level, filename);
2369
2370   ActivateLevelTemplate();
2371 }
2372
2373 void LoadLevel(int nr)
2374 {
2375 #if 1
2376   struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
2377   char *filename = level_file_info->filename;
2378
2379   LoadLevelFromFileInfo(&level, level_file_info);
2380 #else
2381   char *filename = getLevelFilename(nr);
2382
2383   LoadLevelFromFilename_RND(&level, filename);
2384 #endif
2385
2386   if (level.use_custom_template)
2387     LoadLevelTemplate(-1);
2388
2389 #if 1
2390   LoadLevel_InitVersion(&level, filename);
2391   LoadLevel_InitElements(&level, filename);
2392   LoadLevel_InitPlayfield(&level, filename);
2393 #else
2394   LoadLevel_InitLevel(&level, filename);
2395 #endif
2396 }
2397
2398 static void SaveLevel_VERS(FILE *file, struct LevelInfo *level)
2399 {
2400   putFileVersion(file, level->file_version);
2401   putFileVersion(file, level->game_version);
2402 }
2403
2404 static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
2405 {
2406   int i, x, y;
2407
2408   putFile8Bit(file, level->fieldx);
2409   putFile8Bit(file, level->fieldy);
2410
2411   putFile16BitBE(file, level->time);
2412   putFile16BitBE(file, level->gems_needed);
2413
2414   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
2415     putFile8Bit(file, level->name[i]);
2416
2417   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
2418     putFile8Bit(file, level->score[i]);
2419
2420   for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
2421     for (y = 0; y < 3; y++)
2422       for (x = 0; x < 3; x++)
2423         putFile8Bit(file, (level->encoding_16bit_yamyam ? EL_EMPTY :
2424                            level->yamyam_content[i][x][y]));
2425   putFile8Bit(file, level->amoeba_speed);
2426   putFile8Bit(file, level->time_magic_wall);
2427   putFile8Bit(file, level->time_wheel);
2428   putFile8Bit(file, (level->encoding_16bit_amoeba ? EL_EMPTY :
2429                      level->amoeba_content));
2430   putFile8Bit(file, (level->double_speed ? 1 : 0));
2431   putFile8Bit(file, (level->initial_gravity ? 1 : 0));
2432   putFile8Bit(file, (level->encoding_16bit_field ? 1 : 0));
2433   putFile8Bit(file, (level->em_slippery_gems ? 1 : 0));
2434
2435   putFile8Bit(file, (level->use_custom_template ? 1 : 0));
2436
2437   putFile8Bit(file, (level->block_last_field ? 1 : 0));
2438   putFile8Bit(file, (level->sp_block_last_field ? 1 : 0));
2439   putFile32BitBE(file, level->can_move_into_acid_bits);
2440   putFile8Bit(file, level->dont_collide_with_bits);
2441
2442   putFile8Bit(file, (level->use_spring_bug ? 1 : 0));
2443   putFile8Bit(file, (level->use_step_counter ? 1 : 0));
2444
2445   putFile8Bit(file, (level->instant_relocation ? 1 : 0));
2446   putFile8Bit(file, (level->can_pass_to_walkable ? 1 : 0));
2447
2448   WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
2449 }
2450
2451 static void SaveLevel_AUTH(FILE *file, struct LevelInfo *level)
2452 {
2453   int i;
2454
2455   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
2456     putFile8Bit(file, level->author[i]);
2457 }
2458
2459 static void SaveLevel_BODY(FILE *file, struct LevelInfo *level)
2460 {
2461   int x, y;
2462
2463   for (y = 0; y < level->fieldy; y++)
2464     for (x = 0; x < level->fieldx; x++)
2465       if (level->encoding_16bit_field)
2466         putFile16BitBE(file, level->field[x][y]);
2467       else
2468         putFile8Bit(file, level->field[x][y]);
2469 }
2470
2471 #if 0
2472 static void SaveLevel_CONT(FILE *file, struct LevelInfo *level)
2473 {
2474   int i, x, y;
2475
2476   putFile8Bit(file, EL_YAMYAM);
2477   putFile8Bit(file, level->num_yamyam_contents);
2478   putFile8Bit(file, 0);
2479   putFile8Bit(file, 0);
2480
2481   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2482     for (y = 0; y < 3; y++)
2483       for (x = 0; x < 3; x++)
2484         if (level->encoding_16bit_field)
2485           putFile16BitBE(file, level->yamyam_content[i][x][y]);
2486         else
2487           putFile8Bit(file, level->yamyam_content[i][x][y]);
2488 }
2489 #endif
2490
2491 static void SaveLevel_CNT2(FILE *file, struct LevelInfo *level, int element)
2492 {
2493   int i, x, y;
2494   int num_contents, content_xsize, content_ysize;
2495   int content_array[MAX_ELEMENT_CONTENTS][3][3];
2496
2497   if (element == EL_YAMYAM)
2498   {
2499     num_contents = level->num_yamyam_contents;
2500     content_xsize = 3;
2501     content_ysize = 3;
2502
2503     for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2504       for (y = 0; y < 3; y++)
2505         for (x = 0; x < 3; x++)
2506           content_array[i][x][y] = level->yamyam_content[i][x][y];
2507   }
2508   else if (element == EL_BD_AMOEBA)
2509   {
2510     num_contents = 1;
2511     content_xsize = 1;
2512     content_ysize = 1;
2513
2514     for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2515       for (y = 0; y < 3; y++)
2516         for (x = 0; x < 3; x++)
2517           content_array[i][x][y] = EL_EMPTY;
2518     content_array[0][0][0] = level->amoeba_content;
2519   }
2520   else
2521   {
2522     /* chunk header already written -- write empty chunk data */
2523     WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_SIZE);
2524
2525     Error(ERR_WARN, "cannot save content for element '%d'", element);
2526     return;
2527   }
2528
2529   putFile16BitBE(file, element);
2530   putFile8Bit(file, num_contents);
2531   putFile8Bit(file, content_xsize);
2532   putFile8Bit(file, content_ysize);
2533
2534   WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_UNUSED);
2535
2536   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2537     for (y = 0; y < 3; y++)
2538       for (x = 0; x < 3; x++)
2539         putFile16BitBE(file, content_array[i][x][y]);
2540 }
2541
2542 static void SaveLevel_CNT3(FILE *file, struct LevelInfo *level, int element)
2543 {
2544   int i;
2545   int envelope_nr = element - EL_ENVELOPE_1;
2546   int envelope_len = strlen(level->envelope_text[envelope_nr]) + 1;
2547
2548   putFile16BitBE(file, element);
2549   putFile16BitBE(file, envelope_len);
2550   putFile8Bit(file, level->envelope_xsize[envelope_nr]);
2551   putFile8Bit(file, level->envelope_ysize[envelope_nr]);
2552
2553   WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT3_UNUSED);
2554
2555   for (i = 0; i < envelope_len; i++)
2556     putFile8Bit(file, level->envelope_text[envelope_nr][i]);
2557 }
2558
2559 #if 0
2560 static void SaveLevel_CUS1(FILE *file, struct LevelInfo *level,
2561                            int num_changed_custom_elements)
2562 {
2563   int i, check = 0;
2564
2565   putFile16BitBE(file, num_changed_custom_elements);
2566
2567   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2568   {
2569     int element = EL_CUSTOM_START + i;
2570
2571     if (Properties[element][EP_BITFIELD_BASE] != EP_BITMASK_DEFAULT)
2572     {
2573       if (check < num_changed_custom_elements)
2574       {
2575         putFile16BitBE(file, element);
2576         putFile32BitBE(file, Properties[element][EP_BITFIELD_BASE]);
2577       }
2578
2579       check++;
2580     }
2581   }
2582
2583   if (check != num_changed_custom_elements)     /* should not happen */
2584     Error(ERR_WARN, "inconsistent number of custom element properties");
2585 }
2586 #endif
2587
2588 #if 0
2589 static void SaveLevel_CUS2(FILE *file, struct LevelInfo *level,
2590                            int num_changed_custom_elements)
2591 {
2592   int i, check = 0;
2593
2594   putFile16BitBE(file, num_changed_custom_elements);
2595
2596   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2597   {
2598     int element = EL_CUSTOM_START + i;
2599
2600     if (element_info[element].change->target_element != EL_EMPTY_SPACE)
2601     {
2602       if (check < num_changed_custom_elements)
2603       {
2604         putFile16BitBE(file, element);
2605         putFile16BitBE(file, element_info[element].change->target_element);
2606       }
2607
2608       check++;
2609     }
2610   }
2611
2612   if (check != num_changed_custom_elements)     /* should not happen */
2613     Error(ERR_WARN, "inconsistent number of custom target elements");
2614 }
2615 #endif
2616
2617 #if 0
2618 static void SaveLevel_CUS3(FILE *file, struct LevelInfo *level,
2619                            int num_changed_custom_elements)
2620 {
2621   int i, j, x, y, check = 0;
2622
2623   putFile16BitBE(file, num_changed_custom_elements);
2624
2625   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2626   {
2627     int element = EL_CUSTOM_START + i;
2628
2629     if (element_info[element].modified_settings)
2630     {
2631       if (check < num_changed_custom_elements)
2632       {
2633         putFile16BitBE(file, element);
2634
2635         for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
2636           putFile8Bit(file, element_info[element].description[j]);
2637
2638         putFile32BitBE(file, Properties[element][EP_BITFIELD_BASE]);
2639
2640         /* some free bytes for future properties and padding */
2641         WriteUnusedBytesToFile(file, 7);
2642
2643         putFile8Bit(file, element_info[element].use_gfx_element);
2644         putFile16BitBE(file, element_info[element].gfx_element);
2645
2646         putFile8Bit(file, element_info[element].collect_score);
2647         putFile8Bit(file, element_info[element].collect_count);
2648
2649         putFile16BitBE(file, element_info[element].push_delay_fixed);
2650         putFile16BitBE(file, element_info[element].push_delay_random);
2651         putFile16BitBE(file, element_info[element].move_delay_fixed);
2652         putFile16BitBE(file, element_info[element].move_delay_random);
2653
2654         putFile16BitBE(file, element_info[element].move_pattern);
2655         putFile8Bit(file, element_info[element].move_direction_initial);
2656         putFile8Bit(file, element_info[element].move_stepsize);
2657
2658         for (y = 0; y < 3; y++)
2659           for (x = 0; x < 3; x++)
2660             putFile16BitBE(file, element_info[element].content[x][y]);
2661
2662         putFile32BitBE(file, element_info[element].change->events);
2663
2664         putFile16BitBE(file, element_info[element].change->target_element);
2665
2666         putFile16BitBE(file, element_info[element].change->delay_fixed);
2667         putFile16BitBE(file, element_info[element].change->delay_random);
2668         putFile16BitBE(file, element_info[element].change->delay_frames);
2669
2670         putFile16BitBE(file, element_info[element].change->trigger_element);
2671
2672         putFile8Bit(file, element_info[element].change->explode);
2673         putFile8Bit(file, element_info[element].change->use_target_content);
2674         putFile8Bit(file, element_info[element].change->only_if_complete);
2675         putFile8Bit(file, element_info[element].change->use_random_replace);
2676
2677         putFile8Bit(file, element_info[element].change->random_percentage);
2678         putFile8Bit(file, element_info[element].change->replace_when);
2679
2680         for (y = 0; y < 3; y++)
2681           for (x = 0; x < 3; x++)
2682             putFile16BitBE(file, element_info[element].change->content[x][y]);
2683
2684         putFile8Bit(file, element_info[element].slippery_type);
2685
2686         /* some free bytes for future properties and padding */
2687         WriteUnusedBytesToFile(file, LEVEL_CPART_CUS3_UNUSED);
2688       }
2689
2690       check++;
2691     }
2692   }
2693
2694   if (check != num_changed_custom_elements)     /* should not happen */
2695     Error(ERR_WARN, "inconsistent number of custom element properties");
2696 }
2697 #endif
2698
2699 static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
2700 {
2701   struct ElementInfo *ei = &element_info[element];
2702   int i, x, y;
2703
2704   putFile16BitBE(file, element);
2705
2706   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
2707     putFile8Bit(file, ei->description[i]);
2708
2709   putFile32BitBE(file, Properties[element][EP_BITFIELD_BASE]);
2710   WriteUnusedBytesToFile(file, 4);      /* reserved for more base properties */
2711
2712   putFile8Bit(file, ei->num_change_pages);
2713
2714   /* some free bytes for future base property values and padding */
2715   WriteUnusedBytesToFile(file, 5);
2716
2717   /* write custom property values */
2718
2719   putFile8Bit(file, ei->use_gfx_element);
2720   putFile16BitBE(file, ei->gfx_element);
2721
2722   putFile8Bit(file, ei->collect_score);
2723   putFile8Bit(file, ei->collect_count);
2724
2725   putFile8Bit(file, ei->drop_delay_fixed);
2726   putFile8Bit(file, ei->push_delay_fixed);
2727   putFile8Bit(file, ei->drop_delay_random);
2728   putFile8Bit(file, ei->push_delay_random);
2729   putFile16BitBE(file, ei->move_delay_fixed);
2730   putFile16BitBE(file, ei->move_delay_random);
2731
2732   /* bits 0 - 15 of "move_pattern" ... */
2733   putFile16BitBE(file, ei->move_pattern & 0xffff);
2734   putFile8Bit(file, ei->move_direction_initial);
2735   putFile8Bit(file, ei->move_stepsize);
2736
2737   putFile8Bit(file, ei->slippery_type);
2738
2739   for (y = 0; y < 3; y++)
2740     for (x = 0; x < 3; x++)
2741       putFile16BitBE(file, ei->content[x][y]);
2742
2743   putFile16BitBE(file, ei->move_enter_element);
2744   putFile16BitBE(file, ei->move_leave_element);
2745   putFile8Bit(file, ei->move_leave_type);
2746
2747   /* ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible) */
2748   putFile16BitBE(file, (ei->move_pattern >> 16) & 0xffff);
2749
2750   putFile8Bit(file, ei->access_direction);
2751
2752   putFile8Bit(file, ei->explosion_delay);
2753   putFile8Bit(file, ei->ignition_delay);
2754
2755   /* some free bytes for future custom property values and padding */
2756   WriteUnusedBytesToFile(file, 2);
2757
2758   /* write change property values */
2759
2760   for (i = 0; i < ei->num_change_pages; i++)
2761   {
2762     struct ElementChangeInfo *change = &ei->change_page[i];
2763
2764     putFile32BitBE(file, change->events);
2765
2766     putFile16BitBE(file, change->target_element);
2767
2768     putFile16BitBE(file, change->delay_fixed);
2769     putFile16BitBE(file, change->delay_random);
2770     putFile16BitBE(file, change->delay_frames);
2771
2772     putFile16BitBE(file, change->trigger_element);
2773
2774     putFile8Bit(file, change->explode);
2775     putFile8Bit(file, change->use_target_content);
2776     putFile8Bit(file, change->only_if_complete);
2777     putFile8Bit(file, change->use_random_replace);
2778
2779     putFile8Bit(file, change->random_percentage);
2780     putFile8Bit(file, change->replace_when);
2781
2782     for (y = 0; y < 3; y++)
2783       for (x = 0; x < 3; x++)
2784         putFile16BitBE(file, change->target_content[x][y]);
2785
2786     putFile8Bit(file, change->can_change);
2787
2788     putFile8Bit(file, change->trigger_side);
2789
2790 #if 1
2791     putFile8Bit(file, change->trigger_player);
2792     putFile8Bit(file, (change->trigger_page == CH_PAGE_ANY ? CH_PAGE_ANY_FILE :
2793                        log_2(change->trigger_page)));
2794
2795     /* some free bytes for future change property values and padding */
2796     WriteUnusedBytesToFile(file, 6);
2797
2798 #else
2799
2800     /* some free bytes for future change property values and padding */
2801     WriteUnusedBytesToFile(file, 8);
2802 #endif
2803   }
2804 }
2805
2806 static void SaveLevel_GRP1(FILE *file, struct LevelInfo *level, int element)
2807 {
2808   struct ElementInfo *ei = &element_info[element];
2809   struct ElementGroupInfo *group = ei->group;
2810   int i;
2811
2812   putFile16BitBE(file, element);
2813
2814   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
2815     putFile8Bit(file, ei->description[i]);
2816
2817   putFile8Bit(file, group->num_elements);
2818
2819   putFile8Bit(file, ei->use_gfx_element);
2820   putFile16BitBE(file, ei->gfx_element);
2821
2822   putFile8Bit(file, group->choice_mode);
2823
2824   /* some free bytes for future values and padding */
2825   WriteUnusedBytesToFile(file, 3);
2826
2827   for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
2828     putFile16BitBE(file, group->element[i]);
2829 }
2830
2831 static void SaveLevelFromFilename(struct LevelInfo *level, char *filename)
2832 {
2833   int body_chunk_size;
2834   int i, x, y;
2835   FILE *file;
2836
2837   if (!(file = fopen(filename, MODE_WRITE)))
2838   {
2839     Error(ERR_WARN, "cannot save level file '%s'", filename);
2840     return;
2841   }
2842
2843   level->file_version = FILE_VERSION_ACTUAL;
2844   level->game_version = GAME_VERSION_ACTUAL;
2845
2846   /* check level field for 16-bit elements */
2847   level->encoding_16bit_field = FALSE;
2848   for (y = 0; y < level->fieldy; y++)
2849     for (x = 0; x < level->fieldx; x++)
2850       if (level->field[x][y] > 255)
2851         level->encoding_16bit_field = TRUE;
2852
2853   /* check yamyam content for 16-bit elements */
2854   level->encoding_16bit_yamyam = FALSE;
2855   for (i = 0; i < level->num_yamyam_contents; i++)
2856     for (y = 0; y < 3; y++)
2857       for (x = 0; x < 3; x++)
2858         if (level->yamyam_content[i][x][y] > 255)
2859           level->encoding_16bit_yamyam = TRUE;
2860
2861   /* check amoeba content for 16-bit elements */
2862   level->encoding_16bit_amoeba = FALSE;
2863   if (level->amoeba_content > 255)
2864     level->encoding_16bit_amoeba = TRUE;
2865
2866   /* calculate size of "BODY" chunk */
2867   body_chunk_size =
2868     level->fieldx * level->fieldy * (level->encoding_16bit_field ? 2 : 1);
2869
2870   putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
2871   putFileChunkBE(file, "CAVE", CHUNK_SIZE_NONE);
2872
2873   putFileChunkBE(file, "VERS", FILE_VERS_CHUNK_SIZE);
2874   SaveLevel_VERS(file, level);
2875
2876   putFileChunkBE(file, "HEAD", LEVEL_HEADER_SIZE);
2877   SaveLevel_HEAD(file, level);
2878
2879   putFileChunkBE(file, "AUTH", MAX_LEVEL_AUTHOR_LEN);
2880   SaveLevel_AUTH(file, level);
2881
2882   putFileChunkBE(file, "BODY", body_chunk_size);
2883   SaveLevel_BODY(file, level);
2884
2885   if (level->encoding_16bit_yamyam ||
2886       level->num_yamyam_contents != STD_ELEMENT_CONTENTS)
2887   {
2888     putFileChunkBE(file, "CNT2", LEVEL_CHUNK_CNT2_SIZE);
2889     SaveLevel_CNT2(file, level, EL_YAMYAM);
2890   }
2891
2892   if (level->encoding_16bit_amoeba)
2893   {
2894     putFileChunkBE(file, "CNT2", LEVEL_CHUNK_CNT2_SIZE);
2895     SaveLevel_CNT2(file, level, EL_BD_AMOEBA);
2896   }
2897
2898   /* check for envelope content */
2899   for (i = 0; i < 4; i++)
2900   {
2901     if (strlen(level->envelope_text[i]) > 0)
2902     {
2903       int envelope_len = strlen(level->envelope_text[i]) + 1;
2904
2905       putFileChunkBE(file, "CNT3", LEVEL_CHUNK_CNT3_SIZE(envelope_len));
2906       SaveLevel_CNT3(file, level, EL_ENVELOPE_1 + i);
2907     }
2908   }
2909
2910   /* check for non-default custom elements (unless using template level) */
2911   if (!level->use_custom_template)
2912   {
2913     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
2914     {
2915       int element = EL_CUSTOM_START + i;
2916
2917       if (element_info[element].modified_settings)
2918       {
2919         int num_change_pages = element_info[element].num_change_pages;
2920
2921         putFileChunkBE(file, "CUS4", LEVEL_CHUNK_CUS4_SIZE(num_change_pages));
2922         SaveLevel_CUS4(file, level, element);
2923       }
2924     }
2925   }
2926
2927   /* check for non-default group elements (unless using template level) */
2928   if (!level->use_custom_template)
2929   {
2930     for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2931     {
2932       int element = EL_GROUP_START + i;
2933
2934       if (element_info[element].modified_settings)
2935       {
2936         putFileChunkBE(file, "GRP1", LEVEL_CHUNK_GRP1_SIZE);
2937         SaveLevel_GRP1(file, level, element);
2938       }
2939     }
2940   }
2941
2942   fclose(file);
2943
2944   SetFilePermissions(filename, PERMS_PRIVATE);
2945 }
2946
2947 void SaveLevel(int nr)
2948 {
2949   char *filename = getDefaultLevelFilename(nr);
2950
2951   SaveLevelFromFilename(&level, filename);
2952 }
2953
2954 void SaveLevelTemplate()
2955 {
2956   char *filename = getDefaultLevelFilename(-1);
2957
2958   SaveLevelFromFilename(&level, filename);
2959 }
2960
2961 void DumpLevel(struct LevelInfo *level)
2962 {
2963   if (level->no_valid_file)
2964   {
2965     Error(ERR_WARN, "cannot dump -- no valid level file found");
2966
2967     return;
2968   }
2969
2970   printf_line("-", 79);
2971   printf("Level xxx (file version %08d, game version %08d)\n",
2972          level->file_version, level->game_version);
2973   printf_line("-", 79);
2974
2975   printf("Level author: '%s'\n", level->author);
2976   printf("Level title:  '%s'\n", level->name);
2977   printf("\n");
2978   printf("Playfield size: %d x %d\n", level->fieldx, level->fieldy);
2979   printf("\n");
2980   printf("Level time:  %d seconds\n", level->time);
2981   printf("Gems needed: %d\n", level->gems_needed);
2982   printf("\n");
2983   printf("Time for magic wall: %d seconds\n", level->time_magic_wall);
2984   printf("Time for wheel:      %d seconds\n", level->time_wheel);
2985   printf("Time for light:      %d seconds\n", level->time_light);
2986   printf("Time for timegate:   %d seconds\n", level->time_timegate);
2987   printf("\n");
2988   printf("Amoeba speed: %d\n", level->amoeba_speed);
2989   printf("\n");
2990   printf("Initial gravity:             %s\n", (level->initial_gravity ? "yes" : "no"));
2991   printf("Double speed movement:       %s\n", (level->double_speed ? "yes" : "no"));
2992   printf("EM style slippery gems:      %s\n", (level->em_slippery_gems ? "yes" : "no"));
2993   printf("Player blocks last field:    %s\n", (level->block_last_field ? "yes" : "no"));
2994   printf("SP player blocks last field: %s\n", (level->sp_block_last_field ? "yes" : "no"));
2995   printf("use spring bug: %s\n", (level->use_spring_bug ? "yes" : "no"));
2996   printf("use step counter: %s\n", (level->use_step_counter ? "yes" : "no"));
2997
2998   printf_line("-", 79);
2999 }
3000
3001
3002 /* ========================================================================= */
3003 /* tape file functions                                                       */
3004 /* ========================================================================= */
3005
3006 static void setTapeInfoToDefaults()
3007 {
3008   int i;
3009
3010   /* always start with reliable default values (empty tape) */
3011   TapeErase();
3012
3013   /* default values (also for pre-1.2 tapes) with only the first player */
3014   tape.player_participates[0] = TRUE;
3015   for (i = 1; i < MAX_PLAYERS; i++)
3016     tape.player_participates[i] = FALSE;
3017
3018   /* at least one (default: the first) player participates in every tape */
3019   tape.num_participating_players = 1;
3020
3021   tape.level_nr = level_nr;
3022   tape.counter = 0;
3023   tape.changed = FALSE;
3024
3025   tape.recording = FALSE;
3026   tape.playing = FALSE;
3027   tape.pausing = FALSE;
3028
3029   tape.no_valid_file = FALSE;
3030 }
3031
3032 static int LoadTape_VERS(FILE *file, int chunk_size, struct TapeInfo *tape)
3033 {
3034   tape->file_version = getFileVersion(file);
3035   tape->game_version = getFileVersion(file);
3036
3037   return chunk_size;
3038 }
3039
3040 static int LoadTape_HEAD(FILE *file, int chunk_size, struct TapeInfo *tape)
3041 {
3042   int i;
3043
3044   tape->random_seed = getFile32BitBE(file);
3045   tape->date        = getFile32BitBE(file);
3046   tape->length      = getFile32BitBE(file);
3047
3048   /* read header fields that are new since version 1.2 */
3049   if (tape->file_version >= FILE_VERSION_1_2)
3050   {
3051     byte store_participating_players = getFile8Bit(file);
3052     int engine_version;
3053
3054     /* since version 1.2, tapes store which players participate in the tape */
3055     tape->num_participating_players = 0;
3056     for (i = 0; i < MAX_PLAYERS; i++)
3057     {
3058       tape->player_participates[i] = FALSE;
3059
3060       if (store_participating_players & (1 << i))
3061       {
3062         tape->player_participates[i] = TRUE;
3063         tape->num_participating_players++;
3064       }
3065     }
3066
3067     ReadUnusedBytesFromFile(file, TAPE_HEADER_UNUSED);
3068
3069     engine_version = getFileVersion(file);
3070     if (engine_version > 0)
3071       tape->engine_version = engine_version;
3072     else
3073       tape->engine_version = tape->game_version;
3074   }
3075
3076   return chunk_size;
3077 }
3078
3079 static int LoadTape_INFO(FILE *file, int chunk_size, struct TapeInfo *tape)
3080 {
3081   int level_identifier_size;
3082   int i;
3083
3084   level_identifier_size = getFile16BitBE(file);
3085
3086   tape->level_identifier =
3087     checked_realloc(tape->level_identifier, level_identifier_size);
3088
3089   for (i = 0; i < level_identifier_size; i++)
3090     tape->level_identifier[i] = getFile8Bit(file);
3091
3092   tape->level_nr = getFile16BitBE(file);
3093
3094   chunk_size = 2 + level_identifier_size + 2;
3095
3096   return chunk_size;
3097 }
3098
3099 static int LoadTape_BODY(FILE *file, int chunk_size, struct TapeInfo *tape)
3100 {
3101   int i, j;
3102   int chunk_size_expected =
3103     (tape->num_participating_players + 1) * tape->length;
3104
3105   if (chunk_size_expected != chunk_size)
3106   {
3107     ReadUnusedBytesFromFile(file, chunk_size);
3108     return chunk_size_expected;
3109   }
3110
3111   for (i = 0; i < tape->length; i++)
3112   {
3113     if (i >= MAX_TAPELEN)
3114       break;
3115
3116     for (j = 0; j < MAX_PLAYERS; j++)
3117     {
3118       tape->pos[i].action[j] = MV_NO_MOVING;
3119
3120       if (tape->player_participates[j])
3121         tape->pos[i].action[j] = getFile8Bit(file);
3122     }
3123
3124     tape->pos[i].delay = getFile8Bit(file);
3125
3126     if (tape->file_version == FILE_VERSION_1_0)
3127     {
3128       /* eliminate possible diagonal moves in old tapes */
3129       /* this is only for backward compatibility */
3130
3131       byte joy_dir[4] = { JOY_LEFT, JOY_RIGHT, JOY_UP, JOY_DOWN };
3132       byte action = tape->pos[i].action[0];
3133       int k, num_moves = 0;
3134
3135       for (k = 0; k<4; k++)
3136       {
3137         if (action & joy_dir[k])
3138         {
3139           tape->pos[i + num_moves].action[0] = joy_dir[k];
3140           if (num_moves > 0)
3141             tape->pos[i + num_moves].delay = 0;
3142           num_moves++;
3143         }
3144       }
3145
3146       if (num_moves > 1)
3147       {
3148         num_moves--;
3149         i += num_moves;
3150         tape->length += num_moves;
3151       }
3152     }
3153     else if (tape->file_version < FILE_VERSION_2_0)
3154     {
3155       /* convert pre-2.0 tapes to new tape format */
3156
3157       if (tape->pos[i].delay > 1)
3158       {
3159         /* action part */
3160         tape->pos[i + 1] = tape->pos[i];
3161         tape->pos[i + 1].delay = 1;
3162
3163         /* delay part */
3164         for (j = 0; j < MAX_PLAYERS; j++)
3165           tape->pos[i].action[j] = MV_NO_MOVING;
3166         tape->pos[i].delay--;
3167
3168         i++;
3169         tape->length++;
3170       }
3171     }
3172
3173     if (feof(file))
3174       break;
3175   }
3176
3177   if (i != tape->length)
3178     chunk_size = (tape->num_participating_players + 1) * i;
3179
3180   return chunk_size;
3181 }
3182
3183 void LoadTapeFromFilename(char *filename)
3184 {
3185   char cookie[MAX_LINE_LEN];
3186   char chunk_name[CHUNK_ID_LEN + 1];
3187   FILE *file;
3188   int chunk_size;
3189
3190   /* always start with reliable default values */
3191   setTapeInfoToDefaults();
3192
3193   if (!(file = fopen(filename, MODE_READ)))
3194   {
3195     tape.no_valid_file = TRUE;
3196
3197 #if 0
3198     Error(ERR_WARN, "cannot read tape '%s' -- using empty tape", filename);
3199 #endif
3200
3201     return;
3202   }
3203
3204   getFileChunkBE(file, chunk_name, NULL);
3205   if (strcmp(chunk_name, "RND1") == 0)
3206   {
3207     getFile32BitBE(file);               /* not used */
3208
3209     getFileChunkBE(file, chunk_name, NULL);
3210     if (strcmp(chunk_name, "TAPE") != 0)
3211     {
3212       tape.no_valid_file = TRUE;
3213
3214       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
3215       fclose(file);
3216       return;
3217     }
3218   }
3219   else  /* check for pre-2.0 file format with cookie string */
3220   {
3221     strcpy(cookie, chunk_name);
3222     fgets(&cookie[4], MAX_LINE_LEN - 4, file);
3223     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
3224       cookie[strlen(cookie) - 1] = '\0';
3225
3226     if (!checkCookieString(cookie, TAPE_COOKIE_TMPL))
3227     {
3228       tape.no_valid_file = TRUE;
3229
3230       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
3231       fclose(file);
3232       return;
3233     }
3234
3235     if ((tape.file_version = getFileVersionFromCookieString(cookie)) == -1)
3236     {
3237       tape.no_valid_file = TRUE;
3238
3239       Error(ERR_WARN, "unsupported version of tape file '%s'", filename);
3240       fclose(file);
3241       return;
3242     }
3243
3244     /* pre-2.0 tape files have no game version, so use file version here */
3245     tape.game_version = tape.file_version;
3246   }
3247
3248   if (tape.file_version < FILE_VERSION_1_2)
3249   {
3250     /* tape files from versions before 1.2.0 without chunk structure */
3251     LoadTape_HEAD(file, TAPE_HEADER_SIZE, &tape);
3252     LoadTape_BODY(file, 2 * tape.length,  &tape);
3253   }
3254   else
3255   {
3256     static struct
3257     {
3258       char *name;
3259       int size;
3260       int (*loader)(FILE *, int, struct TapeInfo *);
3261     }
3262     chunk_info[] =
3263     {
3264       { "VERS", FILE_VERS_CHUNK_SIZE,   LoadTape_VERS },
3265       { "HEAD", TAPE_HEADER_SIZE,       LoadTape_HEAD },
3266       { "INFO", -1,                     LoadTape_INFO },
3267       { "BODY", -1,                     LoadTape_BODY },
3268       {  NULL,  0,                      NULL }
3269     };
3270
3271     while (getFileChunkBE(file, chunk_name, &chunk_size))
3272     {
3273       int i = 0;
3274
3275       while (chunk_info[i].name != NULL &&
3276              strcmp(chunk_name, chunk_info[i].name) != 0)
3277         i++;
3278
3279       if (chunk_info[i].name == NULL)
3280       {
3281         Error(ERR_WARN, "unknown chunk '%s' in tape file '%s'",
3282               chunk_name, filename);
3283         ReadUnusedBytesFromFile(file, chunk_size);
3284       }
3285       else if (chunk_info[i].size != -1 &&
3286                chunk_info[i].size != chunk_size)
3287       {
3288         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
3289               chunk_size, chunk_name, filename);
3290         ReadUnusedBytesFromFile(file, chunk_size);
3291       }
3292       else
3293       {
3294         /* call function to load this tape chunk */
3295         int chunk_size_expected =
3296           (chunk_info[i].loader)(file, chunk_size, &tape);
3297
3298         /* the size of some chunks cannot be checked before reading other
3299            chunks first (like "HEAD" and "BODY") that contain some header
3300            information, so check them here */
3301         if (chunk_size_expected != chunk_size)
3302         {
3303           Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
3304                 chunk_size, chunk_name, filename);
3305         }
3306       }
3307     }
3308   }
3309
3310   fclose(file);
3311
3312   tape.length_seconds = GetTapeLength();
3313
3314 #if 0
3315   printf("::: tape game version: %d\n", tape.game_version);
3316   printf("::: tape engine version: %d\n", tape.engine_version);
3317 #endif
3318 }
3319
3320 void LoadTape(int nr)
3321 {
3322   char *filename = getTapeFilename(nr);
3323
3324   LoadTapeFromFilename(filename);
3325 }
3326
3327 void LoadSolutionTape(int nr)
3328 {
3329   char *filename = getSolutionTapeFilename(nr);
3330
3331   LoadTapeFromFilename(filename);
3332 }
3333
3334 static void SaveTape_VERS(FILE *file, struct TapeInfo *tape)
3335 {
3336   putFileVersion(file, tape->file_version);
3337   putFileVersion(file, tape->game_version);
3338 }
3339
3340 static void SaveTape_HEAD(FILE *file, struct TapeInfo *tape)
3341 {
3342   int i;
3343   byte store_participating_players = 0;
3344
3345   /* set bits for participating players for compact storage */
3346   for (i = 0; i < MAX_PLAYERS; i++)
3347     if (tape->player_participates[i])
3348       store_participating_players |= (1 << i);
3349
3350   putFile32BitBE(file, tape->random_seed);
3351   putFile32BitBE(file, tape->date);
3352   putFile32BitBE(file, tape->length);
3353
3354   putFile8Bit(file, store_participating_players);
3355
3356   /* unused bytes not at the end here for 4-byte alignment of engine_version */
3357   WriteUnusedBytesToFile(file, TAPE_HEADER_UNUSED);
3358
3359   putFileVersion(file, tape->engine_version);
3360 }
3361
3362 static void SaveTape_INFO(FILE *file, struct TapeInfo *tape)
3363 {
3364   int level_identifier_size = strlen(tape->level_identifier) + 1;
3365   int i;
3366
3367   putFile16BitBE(file, level_identifier_size);
3368
3369   for (i = 0; i < level_identifier_size; i++)
3370     putFile8Bit(file, tape->level_identifier[i]);
3371
3372   putFile16BitBE(file, tape->level_nr);
3373 }
3374
3375 static void SaveTape_BODY(FILE *file, struct TapeInfo *tape)
3376 {
3377   int i, j;
3378
3379   for (i = 0; i < tape->length; i++)
3380   {
3381     for (j = 0; j < MAX_PLAYERS; j++)
3382       if (tape->player_participates[j])
3383         putFile8Bit(file, tape->pos[i].action[j]);
3384
3385     putFile8Bit(file, tape->pos[i].delay);
3386   }
3387 }
3388
3389 void SaveTape(int nr)
3390 {
3391   char *filename = getTapeFilename(nr);
3392   FILE *file;
3393   boolean new_tape = TRUE;
3394   int num_participating_players = 0;
3395   int info_chunk_size;
3396   int body_chunk_size;
3397   int i;
3398
3399   InitTapeDirectory(leveldir_current->subdir);
3400
3401   /* if a tape still exists, ask to overwrite it */
3402   if (access(filename, F_OK) == 0)
3403   {
3404     new_tape = FALSE;
3405     if (!Request("Replace old tape ?", REQ_ASK))
3406       return;
3407   }
3408
3409   if (!(file = fopen(filename, MODE_WRITE)))
3410   {
3411     Error(ERR_WARN, "cannot save level recording file '%s'", filename);
3412     return;
3413   }
3414
3415   tape.file_version = FILE_VERSION_ACTUAL;
3416   tape.game_version = GAME_VERSION_ACTUAL;
3417
3418   /* count number of participating players  */
3419   for (i = 0; i < MAX_PLAYERS; i++)
3420     if (tape.player_participates[i])
3421       num_participating_players++;
3422
3423   info_chunk_size = 2 + (strlen(tape.level_identifier) + 1) + 2;
3424   body_chunk_size = (num_participating_players + 1) * tape.length;
3425
3426   putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
3427   putFileChunkBE(file, "TAPE", CHUNK_SIZE_NONE);
3428
3429   putFileChunkBE(file, "VERS", FILE_VERS_CHUNK_SIZE);
3430   SaveTape_VERS(file, &tape);
3431
3432   putFileChunkBE(file, "HEAD", TAPE_HEADER_SIZE);
3433   SaveTape_HEAD(file, &tape);
3434
3435   putFileChunkBE(file, "INFO", info_chunk_size);
3436   SaveTape_INFO(file, &tape);
3437
3438   putFileChunkBE(file, "BODY", body_chunk_size);
3439   SaveTape_BODY(file, &tape);
3440
3441   fclose(file);
3442
3443   SetFilePermissions(filename, PERMS_PRIVATE);
3444
3445   tape.changed = FALSE;
3446
3447   if (new_tape)
3448     Request("tape saved !", REQ_CONFIRM);
3449 }
3450
3451 void DumpTape(struct TapeInfo *tape)
3452 {
3453   int i, j;
3454
3455 #if 1
3456   if (tape->no_valid_file)
3457   {
3458     Error(ERR_WARN, "cannot dump -- no valid tape file found");
3459
3460     return;
3461   }
3462 #else
3463   if (TAPE_IS_EMPTY(*tape))
3464   {
3465     Error(ERR_WARN, "no tape available for level %d", tape->level_nr);
3466
3467     return;
3468   }
3469 #endif
3470
3471   printf_line("-", 79);
3472   printf("Tape of Level %03d (file version %08d, game version %08d)\n",
3473          tape->level_nr, tape->file_version, tape->game_version);
3474   printf("Level series identifier: '%s'\n", tape->level_identifier);
3475   printf_line("-", 79);
3476
3477   for (i = 0; i < tape->length; i++)
3478   {
3479     if (i >= MAX_TAPELEN)
3480       break;
3481
3482     printf("%03d: ", i);
3483
3484     for (j = 0; j < MAX_PLAYERS; j++)
3485     {
3486       if (tape->player_participates[j])
3487       {
3488         int action = tape->pos[i].action[j];
3489
3490         printf("%d:%02x ", j, action);
3491         printf("[%c%c%c%c|%c%c] - ",
3492                (action & JOY_LEFT ? '<' : ' '),
3493                (action & JOY_RIGHT ? '>' : ' '),
3494                (action & JOY_UP ? '^' : ' '),
3495                (action & JOY_DOWN ? 'v' : ' '),
3496                (action & JOY_BUTTON_1 ? '1' : ' '),
3497                (action & JOY_BUTTON_2 ? '2' : ' '));
3498       }
3499     }
3500
3501     printf("(%03d)\n", tape->pos[i].delay);
3502   }
3503
3504   printf_line("-", 79);
3505 }
3506
3507
3508 /* ========================================================================= */
3509 /* score file functions                                                      */
3510 /* ========================================================================= */
3511
3512 void LoadScore(int nr)
3513 {
3514   int i;
3515   char *filename = getScoreFilename(nr);
3516   char cookie[MAX_LINE_LEN];
3517   char line[MAX_LINE_LEN];
3518   char *line_ptr;
3519   FILE *file;
3520
3521   /* always start with reliable default values */
3522   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
3523   {
3524     strcpy(highscore[i].Name, EMPTY_PLAYER_NAME);
3525     highscore[i].Score = 0;
3526   }
3527
3528   if (!(file = fopen(filename, MODE_READ)))
3529     return;
3530
3531   /* check file identifier */
3532   fgets(cookie, MAX_LINE_LEN, file);
3533   if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
3534     cookie[strlen(cookie) - 1] = '\0';
3535
3536   if (!checkCookieString(cookie, SCORE_COOKIE))
3537   {
3538     Error(ERR_WARN, "unknown format of score file '%s'", filename);
3539     fclose(file);
3540     return;
3541   }
3542
3543   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
3544   {
3545     fscanf(file, "%d", &highscore[i].Score);
3546     fgets(line, MAX_LINE_LEN, file);
3547
3548     if (line[strlen(line) - 1] == '\n')
3549       line[strlen(line) - 1] = '\0';
3550
3551     for (line_ptr = line; *line_ptr; line_ptr++)
3552     {
3553       if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != '\0')
3554       {
3555         strncpy(highscore[i].Name, line_ptr, MAX_PLAYER_NAME_LEN);
3556         highscore[i].Name[MAX_PLAYER_NAME_LEN] = '\0';
3557         break;
3558       }
3559     }
3560   }
3561
3562   fclose(file);
3563 }
3564
3565 void SaveScore(int nr)
3566 {
3567   int i;
3568   char *filename = getScoreFilename(nr);
3569   FILE *file;
3570
3571   InitScoreDirectory(leveldir_current->subdir);
3572
3573   if (!(file = fopen(filename, MODE_WRITE)))
3574   {
3575     Error(ERR_WARN, "cannot save score for level %d", nr);
3576     return;
3577   }
3578
3579   fprintf(file, "%s\n\n", SCORE_COOKIE);
3580
3581   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
3582     fprintf(file, "%d %s\n", highscore[i].Score, highscore[i].Name);
3583
3584   fclose(file);
3585
3586   SetFilePermissions(filename, PERMS_PUBLIC);
3587 }
3588
3589
3590 /* ========================================================================= */
3591 /* setup file functions                                                      */
3592 /* ========================================================================= */
3593
3594 #define TOKEN_STR_PLAYER_PREFIX                 "player_"
3595
3596 /* global setup */
3597 #define SETUP_TOKEN_PLAYER_NAME                 0
3598 #define SETUP_TOKEN_SOUND                       1
3599 #define SETUP_TOKEN_SOUND_LOOPS                 2
3600 #define SETUP_TOKEN_SOUND_MUSIC                 3
3601 #define SETUP_TOKEN_SOUND_SIMPLE                4
3602 #define SETUP_TOKEN_TOONS                       5
3603 #define SETUP_TOKEN_SCROLL_DELAY                6
3604 #define SETUP_TOKEN_SOFT_SCROLLING              7
3605 #define SETUP_TOKEN_FADING                      8
3606 #define SETUP_TOKEN_AUTORECORD                  9
3607 #define SETUP_TOKEN_QUICK_DOORS                 10
3608 #define SETUP_TOKEN_TEAM_MODE                   11
3609 #define SETUP_TOKEN_HANDICAP                    12
3610 #define SETUP_TOKEN_TIME_LIMIT                  13
3611 #define SETUP_TOKEN_FULLSCREEN                  14
3612 #define SETUP_TOKEN_ASK_ON_ESCAPE               15
3613 #define SETUP_TOKEN_GRAPHICS_SET                16
3614 #define SETUP_TOKEN_SOUNDS_SET                  17
3615 #define SETUP_TOKEN_MUSIC_SET                   18
3616 #define SETUP_TOKEN_OVERRIDE_LEVEL_GRAPHICS     19
3617 #define SETUP_TOKEN_OVERRIDE_LEVEL_SOUNDS       20
3618 #define SETUP_TOKEN_OVERRIDE_LEVEL_MUSIC        21
3619
3620 #define NUM_GLOBAL_SETUP_TOKENS                 22
3621
3622 /* editor setup */
3623 #define SETUP_TOKEN_EDITOR_EL_BOULDERDASH       0
3624 #define SETUP_TOKEN_EDITOR_EL_EMERALD_MINE      1
3625 #define SETUP_TOKEN_EDITOR_EL_MORE              2
3626 #define SETUP_TOKEN_EDITOR_EL_SOKOBAN           3
3627 #define SETUP_TOKEN_EDITOR_EL_SUPAPLEX          4
3628 #define SETUP_TOKEN_EDITOR_EL_DIAMOND_CAVES     5
3629 #define SETUP_TOKEN_EDITOR_EL_DX_BOULDERDASH    6
3630 #define SETUP_TOKEN_EDITOR_EL_CHARS             7
3631 #define SETUP_TOKEN_EDITOR_EL_CUSTOM            8
3632 #define SETUP_TOKEN_EDITOR_EL_CUSTOM_MORE       9
3633 #define SETUP_TOKEN_EDITOR_EL_HEADLINES         10
3634 #define SETUP_TOKEN_EDITOR_EL_USER_DEFINED      11
3635
3636 #define NUM_EDITOR_SETUP_TOKENS                 12
3637
3638 /* shortcut setup */
3639 #define SETUP_TOKEN_SHORTCUT_SAVE_GAME          0
3640 #define SETUP_TOKEN_SHORTCUT_LOAD_GAME          1
3641 #define SETUP_TOKEN_SHORTCUT_TOGGLE_PAUSE       2
3642
3643 #define NUM_SHORTCUT_SETUP_TOKENS               3
3644
3645 /* player setup */
3646 #define SETUP_TOKEN_PLAYER_USE_JOYSTICK         0
3647 #define SETUP_TOKEN_PLAYER_JOY_DEVICE_NAME      1
3648 #define SETUP_TOKEN_PLAYER_JOY_XLEFT            2
3649 #define SETUP_TOKEN_PLAYER_JOY_XMIDDLE          3
3650 #define SETUP_TOKEN_PLAYER_JOY_XRIGHT           4
3651 #define SETUP_TOKEN_PLAYER_JOY_YUPPER           5
3652 #define SETUP_TOKEN_PLAYER_JOY_YMIDDLE          6
3653 #define SETUP_TOKEN_PLAYER_JOY_YLOWER           7
3654 #define SETUP_TOKEN_PLAYER_JOY_SNAP             8
3655 #define SETUP_TOKEN_PLAYER_JOY_DROP             9
3656 #define SETUP_TOKEN_PLAYER_KEY_LEFT             10
3657 #define SETUP_TOKEN_PLAYER_KEY_RIGHT            11
3658 #define SETUP_TOKEN_PLAYER_KEY_UP               12
3659 #define SETUP_TOKEN_PLAYER_KEY_DOWN             13
3660 #define SETUP_TOKEN_PLAYER_KEY_SNAP             14
3661 #define SETUP_TOKEN_PLAYER_KEY_DROP             15
3662
3663 #define NUM_PLAYER_SETUP_TOKENS                 16
3664
3665 /* system setup */
3666 #define SETUP_TOKEN_SYSTEM_SDL_AUDIODRIVER      0
3667 #define SETUP_TOKEN_SYSTEM_AUDIO_FRAGMENT_SIZE  1
3668
3669 #define NUM_SYSTEM_SETUP_TOKENS                 2
3670
3671 /* options setup */
3672 #define SETUP_TOKEN_OPTIONS_VERBOSE             0
3673
3674 #define NUM_OPTIONS_SETUP_TOKENS                1
3675
3676
3677 static struct SetupInfo si;
3678 static struct SetupEditorInfo sei;
3679 static struct SetupShortcutInfo ssi;
3680 static struct SetupInputInfo sii;
3681 static struct SetupSystemInfo syi;
3682 static struct OptionInfo soi;
3683
3684 static struct TokenInfo global_setup_tokens[] =
3685 {
3686   { TYPE_STRING, &si.player_name,       "player_name"                   },
3687   { TYPE_SWITCH, &si.sound,             "sound"                         },
3688   { TYPE_SWITCH, &si.sound_loops,       "repeating_sound_loops"         },
3689   { TYPE_SWITCH, &si.sound_music,       "background_music"              },
3690   { TYPE_SWITCH, &si.sound_simple,      "simple_sound_effects"          },
3691   { TYPE_SWITCH, &si.toons,             "toons"                         },
3692   { TYPE_SWITCH, &si.scroll_delay,      "scroll_delay"                  },
3693   { TYPE_SWITCH, &si.soft_scrolling,    "soft_scrolling"                },
3694   { TYPE_SWITCH, &si.fading,            "screen_fading"                 },
3695   { TYPE_SWITCH, &si.autorecord,        "automatic_tape_recording"      },
3696   { TYPE_SWITCH, &si.quick_doors,       "quick_doors"                   },
3697   { TYPE_SWITCH, &si.team_mode,         "team_mode"                     },
3698   { TYPE_SWITCH, &si.handicap,          "handicap"                      },
3699   { TYPE_SWITCH, &si.time_limit,        "time_limit"                    },
3700   { TYPE_SWITCH, &si.fullscreen,        "fullscreen"                    },
3701   { TYPE_SWITCH, &si.ask_on_escape,     "ask_on_escape"                 },
3702   { TYPE_STRING, &si.graphics_set,      "graphics_set"                  },
3703   { TYPE_STRING, &si.sounds_set,        "sounds_set"                    },
3704   { TYPE_STRING, &si.music_set,         "music_set"                     },
3705   { TYPE_SWITCH, &si.override_level_graphics, "override_level_graphics" },
3706   { TYPE_SWITCH, &si.override_level_sounds,   "override_level_sounds"   },
3707   { TYPE_SWITCH, &si.override_level_music,    "override_level_music"    },
3708 };
3709
3710 static struct TokenInfo editor_setup_tokens[] =
3711 {
3712   { TYPE_SWITCH, &sei.el_boulderdash,   "editor.el_boulderdash"         },
3713   { TYPE_SWITCH, &sei.el_emerald_mine,  "editor.el_emerald_mine"        },
3714   { TYPE_SWITCH, &sei.el_more,          "editor.el_more"                },
3715   { TYPE_SWITCH, &sei.el_sokoban,       "editor.el_sokoban"             },
3716   { TYPE_SWITCH, &sei.el_supaplex,      "editor.el_supaplex"            },
3717   { TYPE_SWITCH, &sei.el_diamond_caves, "editor.el_diamond_caves"       },
3718   { TYPE_SWITCH, &sei.el_dx_boulderdash,"editor.el_dx_boulderdash"      },
3719   { TYPE_SWITCH, &sei.el_chars,         "editor.el_chars"               },
3720   { TYPE_SWITCH, &sei.el_custom,        "editor.el_custom"              },
3721   { TYPE_SWITCH, &sei.el_custom_more,   "editor.el_custom_more"         },
3722   { TYPE_SWITCH, &sei.el_headlines,     "editor.el_headlines"           },
3723   { TYPE_SWITCH, &sei.el_user_defined,  "editor.el_user_defined"        },
3724 };
3725
3726 static struct TokenInfo shortcut_setup_tokens[] =
3727 {
3728   { TYPE_KEY_X11, &ssi.save_game,       "shortcut.save_game"            },
3729   { TYPE_KEY_X11, &ssi.load_game,       "shortcut.load_game"            },
3730   { TYPE_KEY_X11, &ssi.toggle_pause,    "shortcut.toggle_pause"         }
3731 };
3732
3733 static struct TokenInfo player_setup_tokens[] =
3734 {
3735   { TYPE_BOOLEAN, &sii.use_joystick,    ".use_joystick"                 },
3736   { TYPE_STRING,  &sii.joy.device_name, ".joy.device_name"              },
3737   { TYPE_INTEGER, &sii.joy.xleft,       ".joy.xleft"                    },
3738   { TYPE_INTEGER, &sii.joy.xmiddle,     ".joy.xmiddle"                  },
3739   { TYPE_INTEGER, &sii.joy.xright,      ".joy.xright"                   },
3740   { TYPE_INTEGER, &sii.joy.yupper,      ".joy.yupper"                   },
3741   { TYPE_INTEGER, &sii.joy.ymiddle,     ".joy.ymiddle"                  },
3742   { TYPE_INTEGER, &sii.joy.ylower,      ".joy.ylower"                   },
3743   { TYPE_INTEGER, &sii.joy.snap,        ".joy.snap_field"               },
3744   { TYPE_INTEGER, &sii.joy.drop,        ".joy.place_bomb"               },
3745   { TYPE_KEY_X11, &sii.key.left,        ".key.move_left"                },
3746   { TYPE_KEY_X11, &sii.key.right,       ".key.move_right"               },
3747   { TYPE_KEY_X11, &sii.key.up,          ".key.move_up"                  },
3748   { TYPE_KEY_X11, &sii.key.down,        ".key.move_down"                },
3749   { TYPE_KEY_X11, &sii.key.snap,        ".key.snap_field"               },
3750   { TYPE_KEY_X11, &sii.key.drop,        ".key.place_bomb"               }
3751 };
3752
3753 static struct TokenInfo system_setup_tokens[] =
3754 {
3755   { TYPE_STRING,  &syi.sdl_audiodriver, "system.sdl_audiodriver"        },
3756   { TYPE_INTEGER, &syi.audio_fragment_size,"system.audio_fragment_size" }
3757 };
3758
3759 static struct TokenInfo options_setup_tokens[] =
3760 {
3761   { TYPE_BOOLEAN, &soi.verbose,         "options.verbose"               }
3762 };
3763
3764 static char *get_corrected_login_name(char *login_name)
3765 {
3766   /* needed because player name must be a fixed length string */
3767   char *login_name_new = checked_malloc(MAX_PLAYER_NAME_LEN + 1);
3768
3769   strncpy(login_name_new, login_name, MAX_PLAYER_NAME_LEN);
3770   login_name_new[MAX_PLAYER_NAME_LEN] = '\0';
3771
3772   if (strlen(login_name) > MAX_PLAYER_NAME_LEN)         /* name has been cut */
3773     if (strchr(login_name_new, ' '))
3774       *strchr(login_name_new, ' ') = '\0';
3775
3776   return login_name_new;
3777 }
3778
3779 static void setSetupInfoToDefaults(struct SetupInfo *si)
3780 {
3781   int i;
3782
3783   si->player_name = get_corrected_login_name(getLoginName());
3784
3785   si->sound = TRUE;
3786   si->sound_loops = TRUE;
3787   si->sound_music = TRUE;
3788   si->sound_simple = TRUE;
3789   si->toons = TRUE;
3790   si->double_buffering = TRUE;
3791   si->direct_draw = !si->double_buffering;
3792   si->scroll_delay = TRUE;
3793   si->soft_scrolling = TRUE;
3794   si->fading = FALSE;
3795   si->autorecord = TRUE;
3796   si->quick_doors = FALSE;
3797   si->team_mode = FALSE;
3798   si->handicap = TRUE;
3799   si->time_limit = TRUE;
3800   si->fullscreen = FALSE;
3801   si->ask_on_escape = TRUE;
3802
3803   si->graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
3804   si->sounds_set = getStringCopy(SND_CLASSIC_SUBDIR);
3805   si->music_set = getStringCopy(MUS_CLASSIC_SUBDIR);
3806   si->override_level_graphics = FALSE;
3807   si->override_level_sounds = FALSE;
3808   si->override_level_music = FALSE;
3809
3810   si->editor.el_boulderdash = TRUE;
3811   si->editor.el_emerald_mine = TRUE;
3812   si->editor.el_more = TRUE;
3813   si->editor.el_sokoban = TRUE;
3814   si->editor.el_supaplex = TRUE;
3815   si->editor.el_diamond_caves = TRUE;
3816   si->editor.el_dx_boulderdash = TRUE;
3817   si->editor.el_chars = TRUE;
3818   si->editor.el_custom = TRUE;
3819   si->editor.el_custom_more = FALSE;
3820
3821   si->editor.el_headlines = TRUE;
3822   si->editor.el_user_defined = FALSE;
3823
3824   si->shortcut.save_game = DEFAULT_KEY_SAVE_GAME;
3825   si->shortcut.load_game = DEFAULT_KEY_LOAD_GAME;
3826   si->shortcut.toggle_pause = DEFAULT_KEY_TOGGLE_PAUSE;
3827
3828   for (i = 0; i < MAX_PLAYERS; i++)
3829   {
3830     si->input[i].use_joystick = FALSE;
3831     si->input[i].joy.device_name=getStringCopy(getDeviceNameFromJoystickNr(i));
3832     si->input[i].joy.xleft   = JOYSTICK_XLEFT;
3833     si->input[i].joy.xmiddle = JOYSTICK_XMIDDLE;
3834     si->input[i].joy.xright  = JOYSTICK_XRIGHT;
3835     si->input[i].joy.yupper  = JOYSTICK_YUPPER;
3836     si->input[i].joy.ymiddle = JOYSTICK_YMIDDLE;
3837     si->input[i].joy.ylower  = JOYSTICK_YLOWER;
3838     si->input[i].joy.snap  = (i == 0 ? JOY_BUTTON_1 : 0);
3839     si->input[i].joy.drop  = (i == 0 ? JOY_BUTTON_2 : 0);
3840     si->input[i].key.left  = (i == 0 ? DEFAULT_KEY_LEFT  : KSYM_UNDEFINED);
3841     si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KSYM_UNDEFINED);
3842     si->input[i].key.up    = (i == 0 ? DEFAULT_KEY_UP    : KSYM_UNDEFINED);
3843     si->input[i].key.down  = (i == 0 ? DEFAULT_KEY_DOWN  : KSYM_UNDEFINED);
3844     si->input[i].key.snap  = (i == 0 ? DEFAULT_KEY_SNAP  : KSYM_UNDEFINED);
3845     si->input[i].key.drop  = (i == 0 ? DEFAULT_KEY_DROP  : KSYM_UNDEFINED);
3846   }
3847
3848   si->system.sdl_audiodriver = getStringCopy(ARG_DEFAULT);
3849   si->system.audio_fragment_size = DEFAULT_AUDIO_FRAGMENT_SIZE;
3850
3851   si->options.verbose = FALSE;
3852 }
3853
3854 static void decodeSetupFileHash(SetupFileHash *setup_file_hash)
3855 {
3856   int i, pnr;
3857
3858   if (!setup_file_hash)
3859     return;
3860
3861   /* global setup */
3862   si = setup;
3863   for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
3864     setSetupInfo(global_setup_tokens, i,
3865                  getHashEntry(setup_file_hash, global_setup_tokens[i].text));
3866   setup = si;
3867
3868   /* editor setup */
3869   sei = setup.editor;
3870   for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
3871     setSetupInfo(editor_setup_tokens, i,
3872                  getHashEntry(setup_file_hash,editor_setup_tokens[i].text));
3873   setup.editor = sei;
3874
3875   /* shortcut setup */
3876   ssi = setup.shortcut;
3877   for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
3878     setSetupInfo(shortcut_setup_tokens, i,
3879                  getHashEntry(setup_file_hash,shortcut_setup_tokens[i].text));
3880   setup.shortcut = ssi;
3881
3882   /* player setup */
3883   for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
3884   {
3885     char prefix[30];
3886
3887     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
3888
3889     sii = setup.input[pnr];
3890     for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
3891     {
3892       char full_token[100];
3893
3894       sprintf(full_token, "%s%s", prefix, player_setup_tokens[i].text);
3895       setSetupInfo(player_setup_tokens, i,
3896                    getHashEntry(setup_file_hash, full_token));
3897     }
3898     setup.input[pnr] = sii;
3899   }
3900
3901   /* system setup */
3902   syi = setup.system;
3903   for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
3904     setSetupInfo(system_setup_tokens, i,
3905                  getHashEntry(setup_file_hash, system_setup_tokens[i].text));
3906   setup.system = syi;
3907
3908   /* options setup */
3909   soi = setup.options;
3910   for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
3911     setSetupInfo(options_setup_tokens, i,
3912                  getHashEntry(setup_file_hash, options_setup_tokens[i].text));
3913   setup.options = soi;
3914 }
3915
3916 void LoadSetup()
3917 {
3918   char *filename = getSetupFilename();
3919   SetupFileHash *setup_file_hash = NULL;
3920
3921   /* always start with reliable default values */
3922   setSetupInfoToDefaults(&setup);
3923
3924   setup_file_hash = loadSetupFileHash(filename);
3925
3926   if (setup_file_hash)
3927   {
3928     char *player_name_new;
3929
3930     checkSetupFileHashIdentifier(setup_file_hash, getCookie("SETUP"));
3931     decodeSetupFileHash(setup_file_hash);
3932
3933     setup.direct_draw = !setup.double_buffering;
3934
3935     freeSetupFileHash(setup_file_hash);
3936
3937     /* needed to work around problems with fixed length strings */
3938     player_name_new = get_corrected_login_name(setup.player_name);
3939     free(setup.player_name);
3940     setup.player_name = player_name_new;
3941   }
3942   else
3943     Error(ERR_WARN, "using default setup values");
3944 }
3945
3946 void SaveSetup()
3947 {
3948   char *filename = getSetupFilename();
3949   FILE *file;
3950   int i, pnr;
3951
3952   InitUserDataDirectory();
3953
3954   if (!(file = fopen(filename, MODE_WRITE)))
3955   {
3956     Error(ERR_WARN, "cannot write setup file '%s'", filename);
3957     return;
3958   }
3959
3960   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
3961                                                getCookie("SETUP")));
3962   fprintf(file, "\n");
3963
3964   /* global setup */
3965   si = setup;
3966   for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
3967   {
3968     /* just to make things nicer :) */
3969     if (i == SETUP_TOKEN_PLAYER_NAME + 1 ||
3970         i == SETUP_TOKEN_GRAPHICS_SET)
3971       fprintf(file, "\n");
3972
3973     fprintf(file, "%s\n", getSetupLine(global_setup_tokens, "", i));
3974   }
3975
3976   /* editor setup */
3977   sei = setup.editor;
3978   fprintf(file, "\n");
3979   for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
3980     fprintf(file, "%s\n", getSetupLine(editor_setup_tokens, "", i));
3981
3982   /* shortcut setup */
3983   ssi = setup.shortcut;
3984   fprintf(file, "\n");
3985   for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
3986     fprintf(file, "%s\n", getSetupLine(shortcut_setup_tokens, "", i));
3987
3988   /* player setup */
3989   for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
3990   {
3991     char prefix[30];
3992
3993     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
3994     fprintf(file, "\n");
3995
3996     sii = setup.input[pnr];
3997     for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
3998       fprintf(file, "%s\n", getSetupLine(player_setup_tokens, prefix, i));
3999   }
4000
4001   /* system setup */
4002   syi = setup.system;
4003   fprintf(file, "\n");
4004   for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
4005     fprintf(file, "%s\n", getSetupLine(system_setup_tokens, "", i));
4006
4007   /* options setup */
4008   soi = setup.options;
4009   fprintf(file, "\n");
4010   for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
4011     fprintf(file, "%s\n", getSetupLine(options_setup_tokens, "", i));
4012
4013   fclose(file);
4014
4015   SetFilePermissions(filename, PERMS_PRIVATE);
4016 }
4017
4018 void LoadCustomElementDescriptions()
4019 {
4020   char *filename = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
4021   SetupFileHash *setup_file_hash;
4022   int i;
4023
4024   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
4025   {
4026     if (element_info[i].custom_description != NULL)
4027     {
4028       free(element_info[i].custom_description);
4029       element_info[i].custom_description = NULL;
4030     }
4031   }
4032
4033   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
4034     return;
4035
4036   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
4037   {
4038     char *token = getStringCat2(element_info[i].token_name, ".name");
4039     char *value = getHashEntry(setup_file_hash, token);
4040
4041     if (value != NULL)
4042       element_info[i].custom_description = getStringCopy(value);
4043
4044     free(token);
4045   }
4046
4047   freeSetupFileHash(setup_file_hash);
4048 }
4049
4050 void LoadSpecialMenuDesignSettings()
4051 {
4052   char *filename = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
4053   SetupFileHash *setup_file_hash;
4054   int i, j;
4055
4056   /* always start with reliable default values from default config */
4057   for (i = 0; image_config_vars[i].token != NULL; i++)
4058     for (j = 0; image_config[j].token != NULL; j++)
4059       if (strcmp(image_config_vars[i].token, image_config[j].token) == 0)
4060         *image_config_vars[i].value =
4061           get_auto_parameter_value(image_config_vars[i].token,
4062                                    image_config[j].value);
4063
4064   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
4065     return;
4066
4067   /* special case: initialize with default values that may be overwritten */
4068   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
4069   {
4070     char *value_x = getHashEntry(setup_file_hash, "menu.draw_xoffset");
4071     char *value_y = getHashEntry(setup_file_hash, "menu.draw_yoffset");
4072     char *list_size = getHashEntry(setup_file_hash, "menu.list_size");
4073
4074     if (value_x != NULL)
4075       menu.draw_xoffset[i] = get_integer_from_string(value_x);
4076     if (value_y != NULL)
4077       menu.draw_yoffset[i] = get_integer_from_string(value_y);
4078     if (list_size != NULL)
4079       menu.list_size[i] = get_integer_from_string(list_size);
4080   }
4081
4082   /* read (and overwrite with) values that may be specified in config file */
4083   for (i = 0; image_config_vars[i].token != NULL; i++)
4084   {
4085     char *value = getHashEntry(setup_file_hash, image_config_vars[i].token);
4086
4087     if (value != NULL)
4088       *image_config_vars[i].value =
4089         get_auto_parameter_value(image_config_vars[i].token, value);
4090   }
4091
4092   freeSetupFileHash(setup_file_hash);
4093 }
4094
4095 void LoadUserDefinedEditorElementList(int **elements, int *num_elements)
4096 {
4097   char *filename = getEditorSetupFilename();
4098   SetupFileList *setup_file_list, *list;
4099   SetupFileHash *element_hash;
4100   int num_unknown_tokens = 0;
4101   int i;
4102
4103   if ((setup_file_list = loadSetupFileList(filename)) == NULL)
4104     return;
4105
4106   element_hash = newSetupFileHash();
4107
4108   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
4109     setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
4110
4111   /* determined size may be larger than needed (due to unknown elements) */
4112   *num_elements = 0;
4113   for (list = setup_file_list; list != NULL; list = list->next)
4114     (*num_elements)++;
4115
4116   /* add space for up to 3 more elements for padding that may be needed */
4117   *num_elements += 3;
4118
4119   *elements = checked_malloc(*num_elements * sizeof(int));
4120
4121   *num_elements = 0;
4122   for (list = setup_file_list; list != NULL; list = list->next)
4123   {
4124     char *value = getHashEntry(element_hash, list->token);
4125
4126     if (value)
4127     {
4128       (*elements)[(*num_elements)++] = atoi(value);
4129     }
4130     else
4131     {
4132       if (num_unknown_tokens == 0)
4133       {
4134         Error(ERR_RETURN_LINE, "-");
4135         Error(ERR_RETURN, "warning: unknown token(s) found in config file:");
4136         Error(ERR_RETURN, "- config file: '%s'", filename);
4137
4138         num_unknown_tokens++;
4139       }
4140
4141       Error(ERR_RETURN, "- token: '%s'", list->token);
4142     }
4143   }
4144
4145   if (num_unknown_tokens > 0)
4146     Error(ERR_RETURN_LINE, "-");
4147
4148   while (*num_elements % 4)     /* pad with empty elements, if needed */
4149     (*elements)[(*num_elements)++] = EL_EMPTY;
4150
4151   freeSetupFileList(setup_file_list);
4152   freeSetupFileHash(element_hash);
4153
4154 #if 0
4155   /* TEST-ONLY */
4156   for (i = 0; i < *num_elements; i++)
4157     printf("editor: element '%s' [%d]\n",
4158            element_info[(*elements)[i]].token_name, (*elements)[i]);
4159 #endif
4160 }
4161
4162 static struct MusicFileInfo *get_music_file_info_ext(char *basename, int music,
4163                                                      boolean is_sound)
4164 {
4165   SetupFileHash *setup_file_hash = NULL;
4166   struct MusicFileInfo tmp_music_file_info, *new_music_file_info;
4167   char *filename_music, *filename_prefix, *filename_info;
4168   struct
4169   {
4170     char *token;
4171     char **value_ptr;
4172   }
4173   token_to_value_ptr[] =
4174   {
4175     { "title_header",   &tmp_music_file_info.title_header       },
4176     { "artist_header",  &tmp_music_file_info.artist_header      },
4177     { "album_header",   &tmp_music_file_info.album_header       },
4178     { "year_header",    &tmp_music_file_info.year_header        },
4179
4180     { "title",          &tmp_music_file_info.title              },
4181     { "artist",         &tmp_music_file_info.artist             },
4182     { "album",          &tmp_music_file_info.album              },
4183     { "year",           &tmp_music_file_info.year               },
4184
4185     { NULL,             NULL                                    },
4186   };
4187   int i;
4188
4189   filename_music = (is_sound ? getCustomSoundFilename(basename) :
4190                     getCustomMusicFilename(basename));
4191
4192   if (filename_music == NULL)
4193     return NULL;
4194
4195   /* ---------- try to replace file extension ---------- */
4196
4197   filename_prefix = getStringCopy(filename_music);
4198   if (strrchr(filename_prefix, '.') != NULL)
4199     *strrchr(filename_prefix, '.') = '\0';
4200   filename_info = getStringCat2(filename_prefix, ".txt");
4201
4202 #if 0
4203   printf("trying to load file '%s'...\n", filename_info);
4204 #endif
4205
4206   if (fileExists(filename_info))
4207     setup_file_hash = loadSetupFileHash(filename_info);
4208
4209   free(filename_prefix);
4210   free(filename_info);
4211
4212   if (setup_file_hash == NULL)
4213   {
4214     /* ---------- try to add file extension ---------- */
4215
4216     filename_prefix = getStringCopy(filename_music);
4217     filename_info = getStringCat2(filename_prefix, ".txt");
4218
4219 #if 0
4220     printf("trying to load file '%s'...\n", filename_info);
4221 #endif
4222
4223     if (fileExists(filename_info))
4224       setup_file_hash = loadSetupFileHash(filename_info);
4225
4226     free(filename_prefix);
4227     free(filename_info);
4228   }
4229
4230   if (setup_file_hash == NULL)
4231     return NULL;
4232
4233   /* ---------- music file info found ---------- */
4234
4235   memset(&tmp_music_file_info, 0, sizeof(struct MusicFileInfo));
4236
4237   for (i = 0; token_to_value_ptr[i].token != NULL; i++)
4238   {
4239     char *value = getHashEntry(setup_file_hash, token_to_value_ptr[i].token);
4240
4241     *token_to_value_ptr[i].value_ptr =
4242       getStringCopy(value != NULL && *value != '\0' ? value : UNKNOWN_NAME);
4243   }
4244
4245   tmp_music_file_info.basename = getStringCopy(basename);
4246   tmp_music_file_info.music = music;
4247   tmp_music_file_info.is_sound = is_sound;
4248
4249   new_music_file_info = checked_malloc(sizeof(struct MusicFileInfo));
4250   *new_music_file_info = tmp_music_file_info;
4251
4252   return new_music_file_info;
4253 }
4254
4255 static struct MusicFileInfo *get_music_file_info(char *basename, int music)
4256 {
4257   return get_music_file_info_ext(basename, music, FALSE);
4258 }
4259
4260 static struct MusicFileInfo *get_sound_file_info(char *basename, int sound)
4261 {
4262   return get_music_file_info_ext(basename, sound, TRUE);
4263 }
4264
4265 static boolean music_info_listed_ext(struct MusicFileInfo *list,
4266                                      char *basename, boolean is_sound)
4267 {
4268   for (; list != NULL; list = list->next)
4269     if (list->is_sound == is_sound && strcmp(list->basename, basename) == 0)
4270       return TRUE;
4271
4272   return FALSE;
4273 }
4274
4275 static boolean music_info_listed(struct MusicFileInfo *list, char *basename)
4276 {
4277   return music_info_listed_ext(list, basename, FALSE);
4278 }
4279
4280 static boolean sound_info_listed(struct MusicFileInfo *list, char *basename)
4281 {
4282   return music_info_listed_ext(list, basename, TRUE);
4283 }
4284
4285 void LoadMusicInfo()
4286 {
4287   char *music_directory = getCustomMusicDirectory();
4288   int num_music = getMusicListSize();
4289   int num_music_noconf = 0;
4290   int num_sounds = getSoundListSize();
4291   DIR *dir;
4292   struct dirent *dir_entry;
4293   struct FileInfo *music, *sound;
4294   struct MusicFileInfo *next, **new;
4295   int i;
4296
4297   while (music_file_info != NULL)
4298   {
4299     next = music_file_info->next;
4300
4301     checked_free(music_file_info->basename);
4302
4303     checked_free(music_file_info->title_header);
4304     checked_free(music_file_info->artist_header);
4305     checked_free(music_file_info->album_header);
4306     checked_free(music_file_info->year_header);
4307
4308     checked_free(music_file_info->title);
4309     checked_free(music_file_info->artist);
4310     checked_free(music_file_info->album);
4311     checked_free(music_file_info->year);
4312
4313     free(music_file_info);
4314
4315     music_file_info = next;
4316   }
4317
4318   new = &music_file_info;
4319
4320 #if 0
4321   printf("::: num_music == %d\n", num_music);
4322 #endif
4323
4324   for (i = 0; i < num_music; i++)
4325   {
4326     music = getMusicListEntry(i);
4327
4328 #if 0
4329     printf("::: %d [%08x]\n", i, music->filename);
4330 #endif
4331
4332     if (music->filename == NULL)
4333       continue;
4334
4335     if (strcmp(music->filename, UNDEFINED_FILENAME) == 0)
4336       continue;
4337
4338     /* a configured file may be not recognized as music */
4339     if (!FileIsMusic(music->filename))
4340       continue;
4341
4342 #if 0
4343     printf("::: -> '%s' (configured)\n", music->filename);
4344 #endif
4345
4346     if (!music_info_listed(music_file_info, music->filename))
4347     {
4348       *new = get_music_file_info(music->filename, i);
4349       if (*new != NULL)
4350         new = &(*new)->next;
4351     }
4352   }
4353
4354   if ((dir = opendir(music_directory)) == NULL)
4355   {
4356     Error(ERR_WARN, "cannot read music directory '%s'", music_directory);
4357     return;
4358   }
4359
4360   while ((dir_entry = readdir(dir)) != NULL)    /* loop until last dir entry */
4361   {
4362     char *basename = dir_entry->d_name;
4363     boolean music_already_used = FALSE;
4364     int i;
4365
4366     /* skip all music files that are configured in music config file */
4367     for (i = 0; i < num_music; i++)
4368     {
4369       music = getMusicListEntry(i);
4370
4371       if (music->filename == NULL)
4372         continue;
4373
4374       if (strcmp(basename, music->filename) == 0)
4375       {
4376         music_already_used = TRUE;
4377         break;
4378       }
4379     }
4380
4381     if (music_already_used)
4382       continue;
4383
4384     if (!FileIsMusic(basename))
4385       continue;
4386
4387 #if 0
4388     printf("::: -> '%s' (found in directory)\n", basename);
4389 #endif
4390
4391     if (!music_info_listed(music_file_info, basename))
4392     {
4393       *new = get_music_file_info(basename, MAP_NOCONF_MUSIC(num_music_noconf));
4394       if (*new != NULL)
4395         new = &(*new)->next;
4396     }
4397
4398     num_music_noconf++;
4399   }
4400
4401   closedir(dir);
4402
4403   for (i = 0; i < num_sounds; i++)
4404   {
4405     sound = getSoundListEntry(i);
4406
4407     if (sound->filename == NULL)
4408       continue;
4409
4410     if (strcmp(sound->filename, UNDEFINED_FILENAME) == 0)
4411       continue;
4412
4413     /* a configured file may be not recognized as sound */
4414     if (!FileIsSound(sound->filename))
4415       continue;
4416
4417 #if 0
4418     printf("::: -> '%s' (configured)\n", sound->filename);
4419 #endif
4420
4421     if (!sound_info_listed(music_file_info, sound->filename))
4422     {
4423       *new = get_sound_file_info(sound->filename, i);
4424       if (*new != NULL)
4425         new = &(*new)->next;
4426     }
4427   }
4428
4429 #if 0
4430   /* TEST-ONLY */
4431   for (next = music_file_info; next != NULL; next = next->next)
4432     printf("::: title == '%s'\n", next->title);
4433 #endif
4434 }
4435
4436 void add_helpanim_entry(int element, int action, int direction, int delay,
4437                         int *num_list_entries)
4438 {
4439   struct HelpAnimInfo *new_list_entry;
4440   (*num_list_entries)++;
4441
4442   helpanim_info =
4443     checked_realloc(helpanim_info,
4444                     *num_list_entries * sizeof(struct HelpAnimInfo));
4445   new_list_entry = &helpanim_info[*num_list_entries - 1];
4446
4447   new_list_entry->element = element;
4448   new_list_entry->action = action;
4449   new_list_entry->direction = direction;
4450   new_list_entry->delay = delay;
4451 }
4452
4453 void print_unknown_token(char *filename, char *token, int token_nr)
4454 {
4455   if (token_nr == 0)
4456   {
4457     Error(ERR_RETURN_LINE, "-");
4458     Error(ERR_RETURN, "warning: unknown token(s) found in config file:");
4459     Error(ERR_RETURN, "- config file: '%s'", filename);
4460   }
4461
4462   Error(ERR_RETURN, "- token: '%s'", token);
4463 }
4464
4465 void print_unknown_token_end(int token_nr)
4466 {
4467   if (token_nr > 0)
4468     Error(ERR_RETURN_LINE, "-");
4469 }
4470
4471 void LoadHelpAnimInfo()
4472 {
4473   char *filename = getHelpAnimFilename();
4474   SetupFileList *setup_file_list = NULL, *list;
4475   SetupFileHash *element_hash, *action_hash, *direction_hash;
4476   int num_list_entries = 0;
4477   int num_unknown_tokens = 0;
4478   int i;
4479
4480   if (fileExists(filename))
4481     setup_file_list = loadSetupFileList(filename);
4482
4483   if (setup_file_list == NULL)
4484   {
4485     /* use reliable default values from static configuration */
4486     SetupFileList *insert_ptr;
4487
4488     insert_ptr = setup_file_list =
4489       newSetupFileList(helpanim_config[0].token,
4490                        helpanim_config[0].value);
4491
4492     for (i = 1; helpanim_config[i].token; i++)
4493       insert_ptr = addListEntry(insert_ptr,
4494                                 helpanim_config[i].token,
4495                                 helpanim_config[i].value);
4496   }
4497
4498   element_hash   = newSetupFileHash();
4499   action_hash    = newSetupFileHash();
4500   direction_hash = newSetupFileHash();
4501
4502   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
4503     setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
4504
4505   for (i = 0; i < NUM_ACTIONS; i++)
4506     setHashEntry(action_hash, element_action_info[i].suffix,
4507                  i_to_a(element_action_info[i].value));
4508
4509   /* do not store direction index (bit) here, but direction value! */
4510   for (i = 0; i < NUM_DIRECTIONS; i++)
4511     setHashEntry(direction_hash, element_direction_info[i].suffix,
4512                  i_to_a(1 << element_direction_info[i].value));
4513
4514   for (list = setup_file_list; list != NULL; list = list->next)
4515   {
4516     char *element_token, *action_token, *direction_token;
4517     char *element_value, *action_value, *direction_value;
4518     int delay = atoi(list->value);
4519
4520     if (strcmp(list->token, "end") == 0)
4521     {
4522       add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
4523
4524       continue;
4525     }
4526
4527     /* first try to break element into element/action/direction parts;
4528        if this does not work, also accept combined "element[.act][.dir]"
4529        elements (like "dynamite.active"), which are unique elements */
4530
4531     if (strchr(list->token, '.') == NULL)       /* token contains no '.' */
4532     {
4533       element_value = getHashEntry(element_hash, list->token);
4534       if (element_value != NULL)        /* element found */
4535         add_helpanim_entry(atoi(element_value), -1, -1, delay,
4536                            &num_list_entries);
4537       else
4538       {
4539         /* no further suffixes found -- this is not an element */
4540         print_unknown_token(filename, list->token, num_unknown_tokens++);
4541       }
4542
4543       continue;
4544     }
4545
4546     /* token has format "<prefix>.<something>" */
4547
4548     action_token = strchr(list->token, '.');    /* suffix may be action ... */
4549     direction_token = action_token;             /* ... or direction */
4550
4551     element_token = getStringCopy(list->token);
4552     *strchr(element_token, '.') = '\0';
4553
4554     element_value = getHashEntry(element_hash, element_token);
4555
4556     if (element_value == NULL)          /* this is no element */
4557     {
4558       element_value = getHashEntry(element_hash, list->token);
4559       if (element_value != NULL)        /* combined element found */
4560         add_helpanim_entry(atoi(element_value), -1, -1, delay,
4561                            &num_list_entries);
4562       else
4563         print_unknown_token(filename, list->token, num_unknown_tokens++);
4564
4565       free(element_token);
4566
4567       continue;
4568     }
4569
4570     action_value = getHashEntry(action_hash, action_token);
4571
4572     if (action_value != NULL)           /* action found */
4573     {
4574       add_helpanim_entry(atoi(element_value), atoi(action_value), -1, delay,
4575                     &num_list_entries);
4576
4577       free(element_token);
4578
4579       continue;
4580     }
4581
4582     direction_value = getHashEntry(direction_hash, direction_token);
4583
4584     if (direction_value != NULL)        /* direction found */
4585     {
4586       add_helpanim_entry(atoi(element_value), -1, atoi(direction_value), delay,
4587                          &num_list_entries);
4588
4589       free(element_token);
4590
4591       continue;
4592     }
4593
4594     if (strchr(action_token + 1, '.') == NULL)
4595     {
4596       /* no further suffixes found -- this is not an action nor direction */
4597
4598       element_value = getHashEntry(element_hash, list->token);
4599       if (element_value != NULL)        /* combined element found */
4600         add_helpanim_entry(atoi(element_value), -1, -1, delay,
4601                            &num_list_entries);
4602       else
4603         print_unknown_token(filename, list->token, num_unknown_tokens++);
4604
4605       free(element_token);
4606
4607       continue;
4608     }
4609
4610     /* token has format "<prefix>.<suffix>.<something>" */
4611
4612     direction_token = strchr(action_token + 1, '.');
4613
4614     action_token = getStringCopy(action_token);
4615     *strchr(action_token + 1, '.') = '\0';
4616
4617     action_value = getHashEntry(action_hash, action_token);
4618
4619     if (action_value == NULL)           /* this is no action */
4620     {
4621       element_value = getHashEntry(element_hash, list->token);
4622       if (element_value != NULL)        /* combined element found */
4623         add_helpanim_entry(atoi(element_value), -1, -1, delay,
4624                            &num_list_entries);
4625       else
4626         print_unknown_token(filename, list->token, num_unknown_tokens++);
4627
4628       free(element_token);
4629       free(action_token);
4630
4631       continue;
4632     }
4633
4634     direction_value = getHashEntry(direction_hash, direction_token);
4635
4636     if (direction_value != NULL)        /* direction found */
4637     {
4638       add_helpanim_entry(atoi(element_value), atoi(action_value),
4639                          atoi(direction_value), delay, &num_list_entries);
4640
4641       free(element_token);
4642       free(action_token);
4643
4644       continue;
4645     }
4646
4647     /* this is no direction */
4648
4649     element_value = getHashEntry(element_hash, list->token);
4650     if (element_value != NULL)          /* combined element found */
4651       add_helpanim_entry(atoi(element_value), -1, -1, delay,
4652                          &num_list_entries);
4653     else
4654       print_unknown_token(filename, list->token, num_unknown_tokens++);
4655
4656     free(element_token);
4657     free(action_token);
4658   }
4659
4660   print_unknown_token_end(num_unknown_tokens);
4661
4662   add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
4663   add_helpanim_entry(HELPANIM_LIST_END,  -1, -1, -1, &num_list_entries);
4664
4665   freeSetupFileList(setup_file_list);
4666   freeSetupFileHash(element_hash);
4667   freeSetupFileHash(action_hash);
4668   freeSetupFileHash(direction_hash);
4669
4670 #if 0
4671   /* TEST ONLY */
4672   for (i = 0; i < num_list_entries; i++)
4673     printf("::: %d, %d, %d => %d\n",
4674            helpanim_info[i].element,
4675            helpanim_info[i].action,
4676            helpanim_info[i].direction,
4677            helpanim_info[i].delay);
4678 #endif
4679 }
4680
4681 void LoadHelpTextInfo()
4682 {
4683   char *filename = getHelpTextFilename();
4684   int i;
4685
4686   if (helptext_info != NULL)
4687   {
4688     freeSetupFileHash(helptext_info);
4689     helptext_info = NULL;
4690   }
4691
4692   if (fileExists(filename))
4693     helptext_info = loadSetupFileHash(filename);
4694
4695   if (helptext_info == NULL)
4696   {
4697     /* use reliable default values from static configuration */
4698     helptext_info = newSetupFileHash();
4699
4700     for (i = 0; helptext_config[i].token; i++)
4701       setHashEntry(helptext_info,
4702                    helptext_config[i].token,
4703                    helptext_config[i].value);
4704   }
4705
4706 #if 0
4707   /* TEST ONLY */
4708   BEGIN_HASH_ITERATION(helptext_info, itr)
4709   {
4710     printf("::: '%s' => '%s'\n",
4711            HASH_ITERATION_TOKEN(itr), HASH_ITERATION_VALUE(itr));
4712   }
4713   END_HASH_ITERATION(hash, itr)
4714 #endif
4715 }