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