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