src/files.c

   1 // ============================================================================
   2 // Rocks'n'Diamonds - McDuffin Strikes Back!
   3 // ----------------------------------------------------------------------------
   4 // (c) 1995-2014 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  http://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // files.c
  10 // ============================================================================
  11
  12 #include <ctype.h>
  13 #include <sys/stat.h>
  14 #include <dirent.h>
  15 #include <math.h>
  16
  17 #include "libgame/libgame.h"
  18
  19 #include "files.h"
  20 #include "init.h"
  21 #include "tools.h"
  22 #include "tape.h"
  23 #include "config.h"
  24
  25 #define ENABLE_UNUSED_CODE      0       /* currently unused functions */
  26 #define ENABLE_HISTORIC_CHUNKS  0       /* only for historic reference */
  27 #define ENABLE_RESERVED_CODE    0       /* reserved for later use */
  28
  29 #define CHUNK_ID_LEN            4       /* IFF style chunk id length  */
  30 #define CHUNK_SIZE_UNDEFINED    0       /* undefined chunk size == 0  */
  31 #define CHUNK_SIZE_NONE         -1      /* do not write chunk size    */
  32
  33 #define LEVEL_CHUNK_NAME_SIZE   MAX_LEVEL_NAME_LEN
  34 #define LEVEL_CHUNK_AUTH_SIZE   MAX_LEVEL_AUTHOR_LEN
  35
  36 #define LEVEL_CHUNK_VERS_SIZE   8       /* size of file version chunk */
  37 #define LEVEL_CHUNK_DATE_SIZE   4       /* size of file date chunk    */
  38 #define LEVEL_CHUNK_HEAD_SIZE   80      /* size of level file header  */
  39 #define LEVEL_CHUNK_HEAD_UNUSED 0       /* unused level header bytes  */
  40 #define LEVEL_CHUNK_CNT2_SIZE   160     /* size of level CNT2 chunk   */
  41 #define LEVEL_CHUNK_CNT2_UNUSED 11      /* unused CNT2 chunk bytes    */
  42 #define LEVEL_CHUNK_CNT3_HEADER 16      /* size of level CNT3 header  */
  43 #define LEVEL_CHUNK_CNT3_UNUSED 10      /* unused CNT3 chunk bytes    */
  44 #define LEVEL_CPART_CUS3_SIZE   134     /* size of CUS3 chunk part    */
  45 #define LEVEL_CPART_CUS3_UNUSED 15      /* unused CUS3 bytes / part   */
  46 #define LEVEL_CHUNK_GRP1_SIZE   74      /* size of level GRP1 chunk   */
  47
  48 /* (element number, number of change pages, change page number) */
  49 #define LEVEL_CHUNK_CUSX_UNCHANGED      (2 + (1 + 1) + (1 + 1))
  50
  51 /* (element number only) */
  52 #define LEVEL_CHUNK_GRPX_UNCHANGED      2
  53 #define LEVEL_CHUNK_NOTE_UNCHANGED      2
  54
  55 /* (nothing at all if unchanged) */
  56 #define LEVEL_CHUNK_ELEM_UNCHANGED      0
  57
  58 #define TAPE_CHUNK_VERS_SIZE    8       /* size of file version chunk */
  59 #define TAPE_CHUNK_HEAD_SIZE    20      /* size of tape file header   */
  60 #define TAPE_CHUNK_HEAD_UNUSED  3       /* unused tape header bytes   */
  61
  62 #define LEVEL_CHUNK_CNT3_SIZE(x)         (LEVEL_CHUNK_CNT3_HEADER + (x))
  63 #define LEVEL_CHUNK_CUS3_SIZE(x)         (2 + (x) * LEVEL_CPART_CUS3_SIZE)
  64 #define LEVEL_CHUNK_CUS4_SIZE(x)         (96 + (x) * 48)
  65
  66 /* file identifier strings */
  67 #define LEVEL_COOKIE_TMPL               "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_x.x"
  68 #define TAPE_COOKIE_TMPL                "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
  69 #define SCORE_COOKIE                    "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
  70
  71 /* values for deciding when (not) to save configuration data */
  72 #define SAVE_CONF_NEVER                 0
  73 #define SAVE_CONF_ALWAYS                1
  74 #define SAVE_CONF_WHEN_CHANGED          -1
  75
  76 /* values for chunks using micro chunks */
  77 #define CONF_MASK_1_BYTE                0x00
  78 #define CONF_MASK_2_BYTE                0x40
  79 #define CONF_MASK_4_BYTE                0x80
  80 #define CONF_MASK_MULTI_BYTES           0xc0
  81
  82 #define CONF_MASK_BYTES                 0xc0
  83 #define CONF_MASK_TOKEN                 0x3f
  84
  85 #define CONF_VALUE_1_BYTE(x)            (CONF_MASK_1_BYTE       | (x))
  86 #define CONF_VALUE_2_BYTE(x)            (CONF_MASK_2_BYTE       | (x))
  87 #define CONF_VALUE_4_BYTE(x)            (CONF_MASK_4_BYTE       | (x))
  88 #define CONF_VALUE_MULTI_BYTES(x)       (CONF_MASK_MULTI_BYTES  | (x))
  89
  90 /* these definitions are just for convenience of use and readability */
  91 #define CONF_VALUE_8_BIT(x)             CONF_VALUE_1_BYTE(x)
  92 #define CONF_VALUE_16_BIT(x)            CONF_VALUE_2_BYTE(x)
  93 #define CONF_VALUE_32_BIT(x)            CONF_VALUE_4_BYTE(x)
  94 #define CONF_VALUE_BYTES(x)             CONF_VALUE_MULTI_BYTES(x)
  95
  96 #define CONF_VALUE_NUM_BYTES(x)         ((x) == CONF_MASK_1_BYTE ? 1 :  \
  97                                          (x) == CONF_MASK_2_BYTE ? 2 :  \
  98                                          (x) == CONF_MASK_4_BYTE ? 4 : 0)
  99
 100 #define CONF_CONTENT_NUM_ELEMENTS       (3 * 3)
 101 #define CONF_CONTENT_NUM_BYTES          (CONF_CONTENT_NUM_ELEMENTS * 2)
 102 #define CONF_ELEMENT_NUM_BYTES          (2)
 103
 104 #define CONF_ENTITY_NUM_BYTES(t)        ((t) == TYPE_ELEMENT ||         \
 105                                          (t) == TYPE_ELEMENT_LIST ?     \
 106                                          CONF_ELEMENT_NUM_BYTES :       \
 107                                          (t) == TYPE_CONTENT ||         \
 108                                          (t) == TYPE_CONTENT_LIST ?     \
 109                                          CONF_CONTENT_NUM_BYTES : 1)
 110
 111 #define CONF_ELEMENT_BYTE_POS(i)        ((i) * CONF_ELEMENT_NUM_BYTES)
 112 #define CONF_ELEMENTS_ELEMENT(b,i)     ((b[CONF_ELEMENT_BYTE_POS(i)] << 8) |  \
 113                                         (b[CONF_ELEMENT_BYTE_POS(i) + 1]))
 114
 115 #define CONF_CONTENT_ELEMENT_POS(c,x,y) ((c) * CONF_CONTENT_NUM_ELEMENTS +    \
 116                                          (y) * 3 + (x))
 117 #define CONF_CONTENT_BYTE_POS(c,x,y)    (CONF_CONTENT_ELEMENT_POS(c,x,y) *    \
 118                                          CONF_ELEMENT_NUM_BYTES)
 119 #define CONF_CONTENTS_ELEMENT(b,c,x,y) ((b[CONF_CONTENT_BYTE_POS(c,x,y)]<< 8)|\
 120                                         (b[CONF_CONTENT_BYTE_POS(c,x,y) + 1]))
 121
 122 /* temporary variables used to store pointers to structure members */
 123 static struct LevelInfo li;
 124 static struct ElementInfo xx_ei, yy_ei;
 125 static struct ElementChangeInfo xx_change;
 126 static struct ElementGroupInfo xx_group;
 127 static struct EnvelopeInfo xx_envelope;
 128 static unsigned int xx_event_bits[NUM_CE_BITFIELDS];
 129 static char xx_default_description[MAX_ELEMENT_NAME_LEN + 1];
 130 static int xx_num_contents;
 131 static int xx_current_change_page;
 132 static char xx_default_string_empty[1] = "";
 133 static int xx_string_length_unused;
 134
 135 struct LevelFileConfigInfo
 136 {
 137   int element;                  /* element for which data is to be stored */
 138   int save_type;                /* save data always, never or when changed */
 139   int data_type;                /* data type (used internally, not stored) */
 140   int conf_type;                /* micro chunk identifier (stored in file) */
 141
 142   /* (mandatory) */
 143   void *value;                  /* variable that holds the data to be stored */
 144   int default_value;            /* initial default value for this variable */
 145
 146   /* (optional) */
 147   void *value_copy;             /* variable that holds the data to be copied */
 148   void *num_entities;           /* number of entities for multi-byte data */
 149   int default_num_entities;     /* default number of entities for this data */
 150   int max_num_entities;         /* maximal number of entities for this data */
 151   char *default_string;         /* optional default string for string data */
 152 };
 153
 154 static struct LevelFileConfigInfo chunk_config_INFO[] =
 155 {
 156   /* ---------- values not related to single elements ----------------------- */
 157
 158   {
 159     -1,                                 SAVE_CONF_ALWAYS,
 160     TYPE_INTEGER,                       CONF_VALUE_8_BIT(1),
 161     &li.game_engine_type,               GAME_ENGINE_TYPE_RND
 162   },
 163
 164   {
 165     -1,                                 SAVE_CONF_ALWAYS,
 166     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 167     &li.fieldx,                         STD_LEV_FIELDX
 168   },
 169   {
 170     -1,                                 SAVE_CONF_ALWAYS,
 171     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 172     &li.fieldy,                         STD_LEV_FIELDY
 173   },
 174
 175   {
 176     -1,                                 SAVE_CONF_ALWAYS,
 177     TYPE_INTEGER,                       CONF_VALUE_16_BIT(3),
 178     &li.time,                           100
 179   },
 180
 181   {
 182     -1,                                 SAVE_CONF_ALWAYS,
 183     TYPE_INTEGER,                       CONF_VALUE_16_BIT(4),
 184     &li.gems_needed,                    0
 185   },
 186
 187   {
 188     -1,                                 -1,
 189     TYPE_INTEGER,                       CONF_VALUE_32_BIT(2),
 190     &li.random_seed,                    0
 191   },
 192
 193   {
 194     -1,                                 -1,
 195     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(2),
 196     &li.use_step_counter,               FALSE
 197   },
 198
 199   {
 200     -1,                                 -1,
 201     TYPE_BITFIELD,                      CONF_VALUE_8_BIT(4),
 202     &li.wind_direction_initial,         MV_NONE
 203   },
 204
 205   {
 206     -1,                                 -1,
 207     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(5),
 208     &li.em_slippery_gems,               FALSE
 209   },
 210
 211   {
 212     -1,                                 -1,
 213     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(6),
 214     &li.use_custom_template,            FALSE
 215   },
 216
 217   {
 218     -1,                                 -1,
 219     TYPE_BITFIELD,                      CONF_VALUE_32_BIT(1),
 220     &li.can_move_into_acid_bits,        ~0      /* default: everything can */
 221   },
 222
 223   {
 224     -1,                                 -1,
 225     TYPE_BITFIELD,                      CONF_VALUE_8_BIT(7),
 226     &li.dont_collide_with_bits,         ~0      /* default: always deadly */
 227   },
 228
 229   {
 230     -1,                                 -1,
 231     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(8),
 232     &li.em_explodes_by_fire,            FALSE
 233   },
 234
 235   {
 236     -1,                                 -1,
 237     TYPE_INTEGER,                       CONF_VALUE_16_BIT(5),
 238     &li.score[SC_TIME_BONUS],           1
 239   },
 240
 241   {
 242     -1,                                 -1,
 243     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(9),
 244     &li.auto_exit_sokoban,              FALSE
 245   },
 246
 247   {
 248     -1,                                 -1,
 249     -1,                                 -1,
 250     NULL,                               -1
 251   }
 252 };
 253
 254 static struct LevelFileConfigInfo chunk_config_ELEM[] =
 255 {
 256   /* (these values are the same for each player) */
 257   {
 258     EL_PLAYER_1,                        -1,
 259     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(1),
 260     &li.block_last_field,               FALSE   /* default case for EM levels */
 261   },
 262   {
 263     EL_PLAYER_1,                        -1,
 264     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(2),
 265     &li.sp_block_last_field,            TRUE    /* default case for SP levels */
 266   },
 267   {
 268     EL_PLAYER_1,                        -1,
 269     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(3),
 270     &li.instant_relocation,             FALSE
 271   },
 272   {
 273     EL_PLAYER_1,                        -1,
 274     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(4),
 275     &li.can_pass_to_walkable,           FALSE
 276   },
 277   {
 278     EL_PLAYER_1,                        -1,
 279     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(5),
 280     &li.block_snap_field,               TRUE
 281   },
 282   {
 283     EL_PLAYER_1,                        -1,
 284     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(6),
 285     &li.continuous_snapping,            TRUE
 286   },
 287   {
 288     EL_PLAYER_1,                        -1,
 289     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(12),
 290     &li.shifted_relocation,             FALSE
 291   },
 292   {
 293     EL_PLAYER_1,                        -1,
 294     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(15),
 295     &li.lazy_relocation,                FALSE
 296   },
 297
 298   /* (these values are different for each player) */
 299   {
 300     EL_PLAYER_1,                        -1,
 301     TYPE_INTEGER,                       CONF_VALUE_8_BIT(7),
 302     &li.initial_player_stepsize[0],     STEPSIZE_NORMAL
 303   },
 304   {
 305     EL_PLAYER_1,                        -1,
 306     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(8),
 307     &li.initial_player_gravity[0],      FALSE
 308   },
 309   {
 310     EL_PLAYER_1,                        -1,
 311     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(9),
 312     &li.use_start_element[0],           FALSE
 313   },
 314   {
 315     EL_PLAYER_1,                        -1,
 316     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
 317     &li.start_element[0],               EL_PLAYER_1
 318   },
 319   {
 320     EL_PLAYER_1,                        -1,
 321     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(10),
 322     &li.use_artwork_element[0],         FALSE
 323   },
 324   {
 325     EL_PLAYER_1,                        -1,
 326     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(2),
 327     &li.artwork_element[0],             EL_PLAYER_1
 328   },
 329   {
 330     EL_PLAYER_1,                        -1,
 331     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(11),
 332     &li.use_explosion_element[0],       FALSE
 333   },
 334   {
 335     EL_PLAYER_1,                        -1,
 336     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(3),
 337     &li.explosion_element[0],           EL_PLAYER_1
 338   },
 339   {
 340     EL_PLAYER_1,                        -1,
 341     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(13),
 342     &li.use_initial_inventory[0],       FALSE
 343   },
 344   {
 345     EL_PLAYER_1,                        -1,
 346     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(14),
 347     &li.initial_inventory_size[0],      1
 348   },
 349   {
 350     EL_PLAYER_1,                        -1,
 351     TYPE_ELEMENT_LIST,                  CONF_VALUE_BYTES(1),
 352     &li.initial_inventory_content[0][0],EL_EMPTY, NULL,
 353     &li.initial_inventory_size[0],      1, MAX_INITIAL_INVENTORY_SIZE
 354   },
 355
 356   {
 357     EL_PLAYER_2,                        -1,
 358     TYPE_INTEGER,                       CONF_VALUE_8_BIT(7),
 359     &li.initial_player_stepsize[1],     STEPSIZE_NORMAL
 360   },
 361   {
 362     EL_PLAYER_2,                        -1,
 363     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(8),
 364     &li.initial_player_gravity[1],      FALSE
 365   },
 366   {
 367     EL_PLAYER_2,                        -1,
 368     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(9),
 369     &li.use_start_element[1],           FALSE
 370   },
 371   {
 372     EL_PLAYER_2,                        -1,
 373     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
 374     &li.start_element[1],               EL_PLAYER_2
 375   },
 376   {
 377     EL_PLAYER_2,                        -1,
 378     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(10),
 379     &li.use_artwork_element[1],         FALSE
 380   },
 381   {
 382     EL_PLAYER_2,                        -1,
 383     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(2),
 384     &li.artwork_element[1],             EL_PLAYER_2
 385   },
 386   {
 387     EL_PLAYER_2,                        -1,
 388     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(11),
 389     &li.use_explosion_element[1],       FALSE
 390   },
 391   {
 392     EL_PLAYER_2,                        -1,
 393     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(3),
 394     &li.explosion_element[1],           EL_PLAYER_2
 395   },
 396   {
 397     EL_PLAYER_2,                        -1,
 398     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(13),
 399     &li.use_initial_inventory[1],       FALSE
 400   },
 401   {
 402     EL_PLAYER_2,                        -1,
 403     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(14),
 404     &li.initial_inventory_size[1],      1
 405   },
 406   {
 407     EL_PLAYER_2,                        -1,
 408     TYPE_ELEMENT_LIST,                  CONF_VALUE_BYTES(1),
 409     &li.initial_inventory_content[1][0],EL_EMPTY, NULL,
 410     &li.initial_inventory_size[1],      1, MAX_INITIAL_INVENTORY_SIZE
 411   },
 412
 413   {
 414     EL_PLAYER_3,                        -1,
 415     TYPE_INTEGER,                       CONF_VALUE_8_BIT(7),
 416     &li.initial_player_stepsize[2],     STEPSIZE_NORMAL
 417   },
 418   {
 419     EL_PLAYER_3,                        -1,
 420     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(8),
 421     &li.initial_player_gravity[2],      FALSE
 422   },
 423   {
 424     EL_PLAYER_3,                        -1,
 425     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(9),
 426     &li.use_start_element[2],           FALSE
 427   },
 428   {
 429     EL_PLAYER_3,                        -1,
 430     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
 431     &li.start_element[2],               EL_PLAYER_3
 432   },
 433   {
 434     EL_PLAYER_3,                        -1,
 435     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(10),
 436     &li.use_artwork_element[2],         FALSE
 437   },
 438   {
 439     EL_PLAYER_3,                        -1,
 440     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(2),
 441     &li.artwork_element[2],             EL_PLAYER_3
 442   },
 443   {
 444     EL_PLAYER_3,                        -1,
 445     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(11),
 446     &li.use_explosion_element[2],       FALSE
 447   },
 448   {
 449     EL_PLAYER_3,                        -1,
 450     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(3),
 451     &li.explosion_element[2],           EL_PLAYER_3
 452   },
 453   {
 454     EL_PLAYER_3,                        -1,
 455     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(13),
 456     &li.use_initial_inventory[2],       FALSE
 457   },
 458   {
 459     EL_PLAYER_3,                        -1,
 460     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(14),
 461     &li.initial_inventory_size[2],      1
 462   },
 463   {
 464     EL_PLAYER_3,                        -1,
 465     TYPE_ELEMENT_LIST,                  CONF_VALUE_BYTES(1),
 466     &li.initial_inventory_content[2][0],EL_EMPTY, NULL,
 467     &li.initial_inventory_size[2],      1, MAX_INITIAL_INVENTORY_SIZE
 468   },
 469
 470   {
 471     EL_PLAYER_4,                        -1,
 472     TYPE_INTEGER,                       CONF_VALUE_8_BIT(7),
 473     &li.initial_player_stepsize[3],     STEPSIZE_NORMAL
 474   },
 475   {
 476     EL_PLAYER_4,                        -1,
 477     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(8),
 478     &li.initial_player_gravity[3],      FALSE
 479   },
 480   {
 481     EL_PLAYER_4,                        -1,
 482     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(9),
 483     &li.use_start_element[3],           FALSE
 484   },
 485   {
 486     EL_PLAYER_4,                        -1,
 487     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
 488     &li.start_element[3],               EL_PLAYER_4
 489   },
 490   {
 491     EL_PLAYER_4,                        -1,
 492     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(10),
 493     &li.use_artwork_element[3],         FALSE
 494   },
 495   {
 496     EL_PLAYER_4,                        -1,
 497     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(2),
 498     &li.artwork_element[3],             EL_PLAYER_4
 499   },
 500   {
 501     EL_PLAYER_4,                        -1,
 502     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(11),
 503     &li.use_explosion_element[3],       FALSE
 504   },
 505   {
 506     EL_PLAYER_4,                        -1,
 507     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(3),
 508     &li.explosion_element[3],           EL_PLAYER_4
 509   },
 510   {
 511     EL_PLAYER_4,                        -1,
 512     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(13),
 513     &li.use_initial_inventory[3],       FALSE
 514   },
 515   {
 516     EL_PLAYER_4,                        -1,
 517     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(14),
 518     &li.initial_inventory_size[3],      1
 519   },
 520   {
 521     EL_PLAYER_4,                        -1,
 522     TYPE_ELEMENT_LIST,                  CONF_VALUE_BYTES(1),
 523     &li.initial_inventory_content[3][0],EL_EMPTY, NULL,
 524     &li.initial_inventory_size[3],      1, MAX_INITIAL_INVENTORY_SIZE
 525   },
 526
 527   {
 528     EL_EMERALD,                         -1,
 529     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 530     &li.score[SC_EMERALD],              10
 531   },
 532
 533   {
 534     EL_DIAMOND,                         -1,
 535     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 536     &li.score[SC_DIAMOND],              10
 537   },
 538
 539   {
 540     EL_BUG,                             -1,
 541     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 542     &li.score[SC_BUG],                  10
 543   },
 544
 545   {
 546     EL_SPACESHIP,                       -1,
 547     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 548     &li.score[SC_SPACESHIP],            10
 549   },
 550
 551   {
 552     EL_PACMAN,                          -1,
 553     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 554     &li.score[SC_PACMAN],               10
 555   },
 556
 557   {
 558     EL_NUT,                             -1,
 559     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 560     &li.score[SC_NUT],                  10
 561   },
 562
 563   {
 564     EL_DYNAMITE,                        -1,
 565     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 566     &li.score[SC_DYNAMITE],             10
 567   },
 568
 569   {
 570     EL_KEY_1,                           -1,
 571     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 572     &li.score[SC_KEY],                  10
 573   },
 574
 575   {
 576     EL_PEARL,                           -1,
 577     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 578     &li.score[SC_PEARL],                10
 579   },
 580
 581   {
 582     EL_CRYSTAL,                         -1,
 583     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 584     &li.score[SC_CRYSTAL],              10
 585   },
 586
 587   {
 588     EL_BD_AMOEBA,                       -1,
 589     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
 590     &li.amoeba_content,                 EL_DIAMOND
 591   },
 592   {
 593     EL_BD_AMOEBA,                       -1,
 594     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 595     &li.amoeba_speed,                   10
 596   },
 597   {
 598     EL_BD_AMOEBA,                       -1,
 599     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(1),
 600     &li.grow_into_diggable,             TRUE
 601   },
 602
 603   {
 604     EL_YAMYAM,                          -1,
 605     TYPE_CONTENT_LIST,                  CONF_VALUE_BYTES(1),
 606     &li.yamyam_content,                 EL_ROCK, NULL,
 607     &li.num_yamyam_contents,            4, MAX_ELEMENT_CONTENTS
 608   },
 609   {
 610     EL_YAMYAM,                          -1,
 611     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 612     &li.score[SC_YAMYAM],               10
 613   },
 614
 615   {
 616     EL_ROBOT,                           -1,
 617     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 618     &li.score[SC_ROBOT],                10
 619   },
 620   {
 621     EL_ROBOT,                           -1,
 622     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 623     &li.slurp_score,                    10
 624   },
 625
 626   {
 627     EL_ROBOT_WHEEL,                     -1,
 628     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 629     &li.time_wheel,                     10
 630   },
 631
 632   {
 633     EL_MAGIC_WALL,                      -1,
 634     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 635     &li.time_magic_wall,                10
 636   },
 637
 638   {
 639     EL_GAME_OF_LIFE,                    -1,
 640     TYPE_INTEGER,                       CONF_VALUE_8_BIT(1),
 641     &li.game_of_life[0],                2
 642   },
 643   {
 644     EL_GAME_OF_LIFE,                    -1,
 645     TYPE_INTEGER,                       CONF_VALUE_8_BIT(2),
 646     &li.game_of_life[1],                3
 647   },
 648   {
 649     EL_GAME_OF_LIFE,                    -1,
 650     TYPE_INTEGER,                       CONF_VALUE_8_BIT(3),
 651     &li.game_of_life[2],                3
 652   },
 653   {
 654     EL_GAME_OF_LIFE,                    -1,
 655     TYPE_INTEGER,                       CONF_VALUE_8_BIT(4),
 656     &li.game_of_life[3],                3
 657   },
 658
 659   {
 660     EL_BIOMAZE,                         -1,
 661     TYPE_INTEGER,                       CONF_VALUE_8_BIT(1),
 662     &li.biomaze[0],                     2
 663   },
 664   {
 665     EL_BIOMAZE,                         -1,
 666     TYPE_INTEGER,                       CONF_VALUE_8_BIT(2),
 667     &li.biomaze[1],                     3
 668   },
 669   {
 670     EL_BIOMAZE,                         -1,
 671     TYPE_INTEGER,                       CONF_VALUE_8_BIT(3),
 672     &li.biomaze[2],                     3
 673   },
 674   {
 675     EL_BIOMAZE,                         -1,
 676     TYPE_INTEGER,                       CONF_VALUE_8_BIT(4),
 677     &li.biomaze[3],                     3
 678   },
 679
 680   {
 681     EL_TIMEGATE_SWITCH,                 -1,
 682     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 683     &li.time_timegate,                  10
 684   },
 685
 686   {
 687     EL_LIGHT_SWITCH_ACTIVE,             -1,
 688     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 689     &li.time_light,                     10
 690   },
 691
 692   {
 693     EL_SHIELD_NORMAL,                   -1,
 694     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 695     &li.shield_normal_time,             10
 696   },
 697   {
 698     EL_SHIELD_NORMAL,                   -1,
 699     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 700     &li.score[SC_SHIELD],               10
 701   },
 702
 703   {
 704     EL_SHIELD_DEADLY,                   -1,
 705     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 706     &li.shield_deadly_time,             10
 707   },
 708   {
 709     EL_SHIELD_DEADLY,                   -1,
 710     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 711     &li.score[SC_SHIELD],               10
 712   },
 713
 714   {
 715     EL_EXTRA_TIME,                      -1,
 716     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 717     &li.extra_time,                     10
 718   },
 719   {
 720     EL_EXTRA_TIME,                      -1,
 721     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 722     &li.extra_time_score,               10
 723   },
 724
 725   {
 726     EL_TIME_ORB_FULL,                   -1,
 727     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 728     &li.time_orb_time,                  10
 729   },
 730   {
 731     EL_TIME_ORB_FULL,                   -1,
 732     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(1),
 733     &li.use_time_orb_bug,               FALSE
 734   },
 735
 736   {
 737     EL_SPRING,                          -1,
 738     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(1),
 739     &li.use_spring_bug,                 FALSE
 740   },
 741
 742   {
 743     EL_EMC_ANDROID,                     -1,
 744     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 745     &li.android_move_time,              10
 746   },
 747   {
 748     EL_EMC_ANDROID,                     -1,
 749     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 750     &li.android_clone_time,             10
 751   },
 752   {
 753     EL_EMC_ANDROID,                     -1,
 754     TYPE_ELEMENT_LIST,                  CONF_VALUE_BYTES(1),
 755     &li.android_clone_element[0],       EL_EMPTY, NULL,
 756     &li.num_android_clone_elements,     1, MAX_ANDROID_ELEMENTS
 757   },
 758
 759   {
 760     EL_EMC_LENSES,                      -1,
 761     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 762     &li.lenses_score,                   10
 763   },
 764   {
 765     EL_EMC_LENSES,                      -1,
 766     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 767     &li.lenses_time,                    10
 768   },
 769
 770   {
 771     EL_EMC_MAGNIFIER,                   -1,
 772     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 773     &li.magnify_score,                  10
 774   },
 775   {
 776     EL_EMC_MAGNIFIER,                   -1,
 777     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 778     &li.magnify_time,                   10
 779   },
 780
 781   {
 782     EL_EMC_MAGIC_BALL,                  -1,
 783     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 784     &li.ball_time,                      10
 785   },
 786   {
 787     EL_EMC_MAGIC_BALL,                  -1,
 788     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(1),
 789     &li.ball_random,                    FALSE
 790   },
 791   {
 792     EL_EMC_MAGIC_BALL,                  -1,
 793     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(2),
 794     &li.ball_state_initial,             FALSE
 795   },
 796   {
 797     EL_EMC_MAGIC_BALL,                  -1,
 798     TYPE_CONTENT_LIST,                  CONF_VALUE_BYTES(1),
 799     &li.ball_content,                   EL_EMPTY, NULL,
 800     &li.num_ball_contents,              4, MAX_ELEMENT_CONTENTS
 801   },
 802
 803   /* ---------- unused values ----------------------------------------------- */
 804
 805   {
 806     EL_UNKNOWN,                         SAVE_CONF_NEVER,
 807     TYPE_INTEGER,                       CONF_VALUE_16_BIT(1),
 808     &li.score[SC_UNKNOWN_14],           10
 809   },
 810   {
 811     EL_UNKNOWN,                         SAVE_CONF_NEVER,
 812     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 813     &li.score[SC_UNKNOWN_15],           10
 814   },
 815
 816   {
 817     -1,                                 -1,
 818     -1,                                 -1,
 819     NULL,                               -1
 820   }
 821 };
 822
 823 static struct LevelFileConfigInfo chunk_config_NOTE[] =
 824 {
 825   {
 826     -1,                                 -1,
 827     TYPE_INTEGER,                       CONF_VALUE_8_BIT(1),
 828     &xx_envelope.xsize,                 MAX_ENVELOPE_XSIZE,
 829   },
 830   {
 831     -1,                                 -1,
 832     TYPE_INTEGER,                       CONF_VALUE_8_BIT(2),
 833     &xx_envelope.ysize,                 MAX_ENVELOPE_YSIZE,
 834   },
 835
 836   {
 837     -1,                                 -1,
 838     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(3),
 839     &xx_envelope.autowrap,              FALSE
 840   },
 841   {
 842     -1,                                 -1,
 843     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(4),
 844     &xx_envelope.centered,              FALSE
 845   },
 846
 847   {
 848     -1,                                 -1,
 849     TYPE_STRING,                        CONF_VALUE_BYTES(1),
 850     &xx_envelope.text,                  -1, NULL,
 851     &xx_string_length_unused,           -1, MAX_ENVELOPE_TEXT_LEN,
 852     &xx_default_string_empty[0]
 853   },
 854
 855   {
 856     -1,                                 -1,
 857     -1,                                 -1,
 858     NULL,                               -1
 859   }
 860 };
 861
 862 static struct LevelFileConfigInfo chunk_config_CUSX_base[] =
 863 {
 864   {
 865     -1,                                 -1,
 866     TYPE_STRING,                        CONF_VALUE_BYTES(1),
 867     &xx_ei.description[0],              -1,
 868     &yy_ei.description[0],
 869     &xx_string_length_unused,           -1, MAX_ELEMENT_NAME_LEN,
 870     &xx_default_description[0]
 871   },
 872
 873   {
 874     -1,                                 -1,
 875     TYPE_BITFIELD,                      CONF_VALUE_32_BIT(1),
 876     &xx_ei.properties[EP_BITFIELD_BASE_NR], EP_BITMASK_BASE_DEFAULT,
 877     &yy_ei.properties[EP_BITFIELD_BASE_NR]
 878   },
 879 #if ENABLE_RESERVED_CODE
 880   /* (reserved for later use) */
 881   {
 882     -1,                                 -1,
 883     TYPE_BITFIELD,                      CONF_VALUE_32_BIT(2),
 884     &xx_ei.properties[EP_BITFIELD_BASE_NR + 1], EP_BITMASK_DEFAULT,
 885     &yy_ei.properties[EP_BITFIELD_BASE_NR + 1]
 886   },
 887 #endif
 888
 889   {
 890     -1,                                 -1,
 891     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(1),
 892     &xx_ei.use_gfx_element,             FALSE,
 893     &yy_ei.use_gfx_element
 894   },
 895   {
 896     -1,                                 -1,
 897     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
 898     &xx_ei.gfx_element_initial,         EL_EMPTY_SPACE,
 899     &yy_ei.gfx_element_initial
 900   },
 901
 902   {
 903     -1,                                 -1,
 904     TYPE_BITFIELD,                      CONF_VALUE_8_BIT(2),
 905     &xx_ei.access_direction,            MV_ALL_DIRECTIONS,
 906     &yy_ei.access_direction
 907   },
 908
 909   {
 910     -1,                                 -1,
 911     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
 912     &xx_ei.collect_score_initial,       10,
 913     &yy_ei.collect_score_initial
 914   },
 915   {
 916     -1,                                 -1,
 917     TYPE_INTEGER,                       CONF_VALUE_16_BIT(3),
 918     &xx_ei.collect_count_initial,       1,
 919     &yy_ei.collect_count_initial
 920   },
 921
 922   {
 923     -1,                                 -1,
 924     TYPE_INTEGER,                       CONF_VALUE_16_BIT(4),
 925     &xx_ei.ce_value_fixed_initial,      0,
 926     &yy_ei.ce_value_fixed_initial
 927   },
 928   {
 929     -1,                                 -1,
 930     TYPE_INTEGER,                       CONF_VALUE_16_BIT(5),
 931     &xx_ei.ce_value_random_initial,     0,
 932     &yy_ei.ce_value_random_initial
 933   },
 934   {
 935     -1,                                 -1,
 936     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(3),
 937     &xx_ei.use_last_ce_value,           FALSE,
 938     &yy_ei.use_last_ce_value
 939   },
 940
 941   {
 942     -1,                                 -1,
 943     TYPE_INTEGER,                       CONF_VALUE_16_BIT(6),
 944     &xx_ei.push_delay_fixed,            8,
 945     &yy_ei.push_delay_fixed
 946   },
 947   {
 948     -1,                                 -1,
 949     TYPE_INTEGER,                       CONF_VALUE_16_BIT(7),
 950     &xx_ei.push_delay_random,           8,
 951     &yy_ei.push_delay_random
 952   },
 953   {
 954     -1,                                 -1,
 955     TYPE_INTEGER,                       CONF_VALUE_16_BIT(8),
 956     &xx_ei.drop_delay_fixed,            0,
 957     &yy_ei.drop_delay_fixed
 958   },
 959   {
 960     -1,                                 -1,
 961     TYPE_INTEGER,                       CONF_VALUE_16_BIT(9),
 962     &xx_ei.drop_delay_random,           0,
 963     &yy_ei.drop_delay_random
 964   },
 965   {
 966     -1,                                 -1,
 967     TYPE_INTEGER,                       CONF_VALUE_16_BIT(10),
 968     &xx_ei.move_delay_fixed,            0,
 969     &yy_ei.move_delay_fixed
 970   },
 971   {
 972     -1,                                 -1,
 973     TYPE_INTEGER,                       CONF_VALUE_16_BIT(11),
 974     &xx_ei.move_delay_random,           0,
 975     &yy_ei.move_delay_random
 976   },
 977
 978   {
 979     -1,                                 -1,
 980     TYPE_BITFIELD,                      CONF_VALUE_32_BIT(3),
 981     &xx_ei.move_pattern,                MV_ALL_DIRECTIONS,
 982     &yy_ei.move_pattern
 983   },
 984   {
 985     -1,                                 -1,
 986     TYPE_BITFIELD,                      CONF_VALUE_8_BIT(4),
 987     &xx_ei.move_direction_initial,      MV_START_AUTOMATIC,
 988     &yy_ei.move_direction_initial
 989   },
 990   {
 991     -1,                                 -1,
 992     TYPE_INTEGER,                       CONF_VALUE_8_BIT(5),
 993     &xx_ei.move_stepsize,               TILEX / 8,
 994     &yy_ei.move_stepsize
 995   },
 996
 997   {
 998     -1,                                 -1,
 999     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(12),
1000     &xx_ei.move_enter_element,          EL_EMPTY_SPACE,
1001     &yy_ei.move_enter_element
1002   },
1003   {
1004     -1,                                 -1,
1005     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(13),
1006     &xx_ei.move_leave_element,          EL_EMPTY_SPACE,
1007     &yy_ei.move_leave_element
1008   },
1009   {
1010     -1,                                 -1,
1011     TYPE_INTEGER,                       CONF_VALUE_8_BIT(6),
1012     &xx_ei.move_leave_type,             LEAVE_TYPE_UNLIMITED,
1013     &yy_ei.move_leave_type
1014   },
1015
1016   {
1017     -1,                                 -1,
1018     TYPE_INTEGER,                       CONF_VALUE_8_BIT(7),
1019     &xx_ei.slippery_type,               SLIPPERY_ANY_RANDOM,
1020     &yy_ei.slippery_type
1021   },
1022
1023   {
1024     -1,                                 -1,
1025     TYPE_INTEGER,                       CONF_VALUE_8_BIT(8),
1026     &xx_ei.explosion_type,              EXPLODES_3X3,
1027     &yy_ei.explosion_type
1028   },
1029   {
1030     -1,                                 -1,
1031     TYPE_INTEGER,                       CONF_VALUE_16_BIT(14),
1032     &xx_ei.explosion_delay,             16,
1033     &yy_ei.explosion_delay
1034   },
1035   {
1036     -1,                                 -1,
1037     TYPE_INTEGER,                       CONF_VALUE_16_BIT(15),
1038     &xx_ei.ignition_delay,              8,
1039     &yy_ei.ignition_delay
1040   },
1041
1042   {
1043     -1,                                 -1,
1044     TYPE_CONTENT_LIST,                  CONF_VALUE_BYTES(2),
1045     &xx_ei.content,                     EL_EMPTY_SPACE,
1046     &yy_ei.content,
1047     &xx_num_contents,                   1, 1
1048   },
1049
1050   /* ---------- "num_change_pages" must be the last entry ------------------- */
1051
1052   {
1053     -1,                                 SAVE_CONF_ALWAYS,
1054     TYPE_INTEGER,                       CONF_VALUE_8_BIT(9),
1055     &xx_ei.num_change_pages,            1,
1056     &yy_ei.num_change_pages
1057   },
1058
1059   {
1060     -1,                                 -1,
1061     -1,                                 -1,
1062     NULL,                               -1,
1063     NULL
1064   }
1065 };
1066
1067 static struct LevelFileConfigInfo chunk_config_CUSX_change[] =
1068 {
1069   /* ---------- "current_change_page" must be the first entry --------------- */
1070
1071   {
1072     -1,                                 SAVE_CONF_ALWAYS,
1073     TYPE_INTEGER,                       CONF_VALUE_8_BIT(1),
1074     &xx_current_change_page,            -1
1075   },
1076
1077   /* ---------- (the remaining entries can be in any order) ----------------- */
1078
1079   {
1080     -1,                                 -1,
1081     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(2),
1082     &xx_change.can_change,              FALSE
1083   },
1084
1085   {
1086     -1,                                 -1,
1087     TYPE_BITFIELD,                      CONF_VALUE_32_BIT(1),
1088     &xx_event_bits[0],                  0
1089   },
1090   {
1091     -1,                                 -1,
1092     TYPE_BITFIELD,                      CONF_VALUE_32_BIT(2),
1093     &xx_event_bits[1],                  0
1094   },
1095
1096   {
1097     -1,                                 -1,
1098     TYPE_BITFIELD,                      CONF_VALUE_8_BIT(3),
1099     &xx_change.trigger_player,          CH_PLAYER_ANY
1100   },
1101   {
1102     -1,                                 -1,
1103     TYPE_BITFIELD,                      CONF_VALUE_8_BIT(4),
1104     &xx_change.trigger_side,            CH_SIDE_ANY
1105   },
1106   {
1107     -1,                                 -1,
1108     TYPE_BITFIELD,                      CONF_VALUE_32_BIT(3),
1109     &xx_change.trigger_page,            CH_PAGE_ANY
1110   },
1111
1112   {
1113     -1,                                 -1,
1114     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
1115     &xx_change.target_element,          EL_EMPTY_SPACE
1116   },
1117
1118   {
1119     -1,                                 -1,
1120     TYPE_INTEGER,                       CONF_VALUE_16_BIT(2),
1121     &xx_change.delay_fixed,             0
1122   },
1123   {
1124     -1,                                 -1,
1125     TYPE_INTEGER,                       CONF_VALUE_16_BIT(3),
1126     &xx_change.delay_random,            0
1127   },
1128   {
1129     -1,                                 -1,
1130     TYPE_INTEGER,                       CONF_VALUE_16_BIT(4),
1131     &xx_change.delay_frames,            FRAMES_PER_SECOND
1132   },
1133
1134   {
1135     -1,                                 -1,
1136     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(5),
1137     &xx_change.initial_trigger_element, EL_EMPTY_SPACE
1138   },
1139
1140   {
1141     -1,                                 -1,
1142     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(6),
1143     &xx_change.explode,                 FALSE
1144   },
1145   {
1146     -1,                                 -1,
1147     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(7),
1148     &xx_change.use_target_content,      FALSE
1149   },
1150   {
1151     -1,                                 -1,
1152     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(8),
1153     &xx_change.only_if_complete,        FALSE
1154   },
1155   {
1156     -1,                                 -1,
1157     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(9),
1158     &xx_change.use_random_replace,      FALSE
1159   },
1160   {
1161     -1,                                 -1,
1162     TYPE_INTEGER,                       CONF_VALUE_8_BIT(10),
1163     &xx_change.random_percentage,       100
1164   },
1165   {
1166     -1,                                 -1,
1167     TYPE_INTEGER,                       CONF_VALUE_8_BIT(11),
1168     &xx_change.replace_when,            CP_WHEN_EMPTY
1169   },
1170
1171   {
1172     -1,                                 -1,
1173     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(12),
1174     &xx_change.has_action,              FALSE
1175   },
1176   {
1177     -1,                                 -1,
1178     TYPE_INTEGER,                       CONF_VALUE_8_BIT(13),
1179     &xx_change.action_type,             CA_NO_ACTION
1180   },
1181   {
1182     -1,                                 -1,
1183     TYPE_INTEGER,                       CONF_VALUE_8_BIT(14),
1184     &xx_change.action_mode,             CA_MODE_UNDEFINED
1185   },
1186   {
1187     -1,                                 -1,
1188     TYPE_INTEGER,                       CONF_VALUE_16_BIT(6),
1189     &xx_change.action_arg,              CA_ARG_UNDEFINED
1190   },
1191
1192   {
1193     -1,                                 -1,
1194     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(7),
1195     &xx_change.action_element,          EL_EMPTY_SPACE
1196   },
1197
1198   {
1199     -1,                                 -1,
1200     TYPE_CONTENT_LIST,                  CONF_VALUE_BYTES(1),
1201     &xx_change.target_content,          EL_EMPTY_SPACE, NULL,
1202     &xx_num_contents,                   1, 1
1203   },
1204
1205   {
1206     -1,                                 -1,
1207     -1,                                 -1,
1208     NULL,                               -1
1209   }
1210 };
1211
1212 static struct LevelFileConfigInfo chunk_config_GRPX[] =
1213 {
1214   {
1215     -1,                                 -1,
1216     TYPE_STRING,                        CONF_VALUE_BYTES(1),
1217     &xx_ei.description[0],              -1, NULL,
1218     &xx_string_length_unused,           -1, MAX_ELEMENT_NAME_LEN,
1219     &xx_default_description[0]
1220   },
1221
1222   {
1223     -1,                                 -1,
1224     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(1),
1225     &xx_ei.use_gfx_element,             FALSE
1226   },
1227   {
1228     -1,                                 -1,
1229     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
1230     &xx_ei.gfx_element_initial,         EL_EMPTY_SPACE
1231   },
1232
1233   {
1234     -1,                                 -1,
1235     TYPE_INTEGER,                       CONF_VALUE_8_BIT(2),
1236     &xx_group.choice_mode,              ANIM_RANDOM
1237   },
1238
1239   {
1240     -1,                                 -1,
1241     TYPE_ELEMENT_LIST,                  CONF_VALUE_BYTES(2),
1242     &xx_group.element[0],               EL_EMPTY_SPACE, NULL,
1243     &xx_group.num_elements,             1, MAX_ELEMENTS_IN_GROUP
1244   },
1245
1246   {
1247     -1,                                 -1,
1248     -1,                                 -1,
1249     NULL,                               -1
1250   }
1251 };
1252
1253 static struct LevelFileConfigInfo chunk_config_CONF[] =         /* (OBSOLETE) */
1254 {
1255   {
1256     EL_PLAYER_1,                        -1,
1257     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(9),
1258     &li.block_snap_field,               TRUE
1259   },
1260   {
1261     EL_PLAYER_1,                        -1,
1262     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(13),
1263     &li.continuous_snapping,            TRUE
1264   },
1265   {
1266     EL_PLAYER_1,                        -1,
1267     TYPE_INTEGER,                       CONF_VALUE_8_BIT(1),
1268     &li.initial_player_stepsize[0],     STEPSIZE_NORMAL
1269   },
1270   {
1271     EL_PLAYER_1,                        -1,
1272     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(10),
1273     &li.use_start_element[0],           FALSE
1274   },
1275   {
1276     EL_PLAYER_1,                        -1,
1277     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(1),
1278     &li.start_element[0],               EL_PLAYER_1
1279   },
1280   {
1281     EL_PLAYER_1,                        -1,
1282     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(11),
1283     &li.use_artwork_element[0],         FALSE
1284   },
1285   {
1286     EL_PLAYER_1,                        -1,
1287     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(2),
1288     &li.artwork_element[0],             EL_PLAYER_1
1289   },
1290   {
1291     EL_PLAYER_1,                        -1,
1292     TYPE_BOOLEAN,                       CONF_VALUE_8_BIT(12),
1293     &li.use_explosion_element[0],       FALSE
1294   },
1295   {
1296     EL_PLAYER_1,                        -1,
1297     TYPE_ELEMENT,                       CONF_VALUE_16_BIT(3),
1298     &li.explosion_element[0],           EL_PLAYER_1
1299   },
1300
1301   {
1302     -1,                                 -1,
1303     -1,                                 -1,
1304     NULL,                               -1
1305   }
1306 };
1307
1308 static struct
1309 {
1310   int filetype;
1311   char *id;
1312 }
1313 filetype_id_list[] =
1314 {
1315   { LEVEL_FILE_TYPE_RND,        "RND"   },
1316   { LEVEL_FILE_TYPE_BD,         "BD"    },
1317   { LEVEL_FILE_TYPE_EM,         "EM"    },
1318   { LEVEL_FILE_TYPE_SP,         "SP"    },
1319   { LEVEL_FILE_TYPE_DX,         "DX"    },
1320   { LEVEL_FILE_TYPE_SB,         "SB"    },
1321   { LEVEL_FILE_TYPE_DC,         "DC"    },
1322   { -1,                         NULL    },
1323 };
1324
1325
1326 /* ========================================================================= */
1327 /* level file functions                                                      */
1328 /* ========================================================================= */
1329
1330 static boolean check_special_flags(char *flag)
1331 {
1332   if (strEqual(options.special_flags, flag) ||
1333       strEqual(leveldir_current->special_flags, flag))
1334     return TRUE;
1335
1336   return FALSE;
1337 }
1338
1339 static struct DateInfo getCurrentDate()
1340 {
1341   time_t epoch_seconds = time(NULL);
1342   struct tm *now = localtime(&epoch_seconds);
1343   struct DateInfo date;
1344
1345   date.year  = now->tm_year + 1900;
1346   date.month = now->tm_mon  + 1;
1347   date.day   = now->tm_mday;
1348
1349   date.src   = DATE_SRC_CLOCK;
1350
1351   return date;
1352 }
1353
1354 static void resetEventFlags(struct ElementChangeInfo *change)
1355 {
1356   int i;
1357
1358   for (i = 0; i < NUM_CHANGE_EVENTS; i++)
1359     change->has_event[i] = FALSE;
1360 }
1361
1362 static void resetEventBits()
1363 {
1364   int i;
1365
1366   for (i = 0; i < NUM_CE_BITFIELDS; i++)
1367     xx_event_bits[i] = 0;
1368 }
1369
1370 static void setEventFlagsFromEventBits(struct ElementChangeInfo *change)
1371 {
1372   int i;
1373
1374   /* important: only change event flag if corresponding event bit is set
1375      (this is because all xx_event_bits[] values are loaded separately,
1376      and all xx_event_bits[] values are set back to zero before loading
1377      another value xx_event_bits[x] (each value representing 32 flags)) */
1378
1379   for (i = 0; i < NUM_CHANGE_EVENTS; i++)
1380     if (xx_event_bits[CH_EVENT_BITFIELD_NR(i)] & CH_EVENT_BIT(i))
1381       change->has_event[i] = TRUE;
1382 }
1383
1384 static void setEventBitsFromEventFlags(struct ElementChangeInfo *change)
1385 {
1386   int i;
1387
1388   /* in contrast to the above function setEventFlagsFromEventBits(), it
1389      would also be possible to set all bits in xx_event_bits[] to 0 or 1
1390      depending on the corresponding change->has_event[i] values here, as
1391      all xx_event_bits[] values are reset in resetEventBits() before */
1392
1393   for (i = 0; i < NUM_CHANGE_EVENTS; i++)
1394     if (change->has_event[i])
1395       xx_event_bits[CH_EVENT_BITFIELD_NR(i)] |= CH_EVENT_BIT(i);
1396 }
1397
1398 static char *getDefaultElementDescription(struct ElementInfo *ei)
1399 {
1400   static char description[MAX_ELEMENT_NAME_LEN + 1];
1401   char *default_description = (ei->custom_description != NULL ?
1402                                ei->custom_description :
1403                                ei->editor_description);
1404   int i;
1405
1406   /* always start with reliable default values */
1407   for (i = 0; i < MAX_ELEMENT_NAME_LEN + 1; i++)
1408     description[i] = '\0';
1409
1410   /* truncate element description to MAX_ELEMENT_NAME_LEN bytes */
1411   strncpy(description, default_description, MAX_ELEMENT_NAME_LEN);
1412
1413   return &description[0];
1414 }
1415
1416 static void setElementDescriptionToDefault(struct ElementInfo *ei)
1417 {
1418   char *default_description = getDefaultElementDescription(ei);
1419   int i;
1420
1421   for (i = 0; i < MAX_ELEMENT_NAME_LEN + 1; i++)
1422     ei->description[i] = default_description[i];
1423 }
1424
1425 static void setConfigToDefaultsFromConfigList(struct LevelFileConfigInfo *conf)
1426 {
1427   int i;
1428
1429   for (i = 0; conf[i].data_type != -1; i++)
1430   {
1431     int default_value = conf[i].default_value;
1432     int data_type = conf[i].data_type;
1433     int conf_type = conf[i].conf_type;
1434     int byte_mask = conf_type & CONF_MASK_BYTES;
1435
1436     if (byte_mask == CONF_MASK_MULTI_BYTES)
1437     {
1438       int default_num_entities = conf[i].default_num_entities;
1439       int max_num_entities = conf[i].max_num_entities;
1440
1441       *(int *)(conf[i].num_entities) = default_num_entities;
1442
1443       if (data_type == TYPE_STRING)
1444       {
1445         char *default_string = conf[i].default_string;
1446         char *string = (char *)(conf[i].value);
1447
1448         strncpy(string, default_string, max_num_entities);
1449       }
1450       else if (data_type == TYPE_ELEMENT_LIST)
1451       {
1452         int *element_array = (int *)(conf[i].value);
1453         int j;
1454
1455         for (j = 0; j < max_num_entities; j++)
1456           element_array[j] = default_value;
1457       }
1458       else if (data_type == TYPE_CONTENT_LIST)
1459       {
1460         struct Content *content = (struct Content *)(conf[i].value);
1461         int c, x, y;
1462
1463         for (c = 0; c < max_num_entities; c++)
1464           for (y = 0; y < 3; y++)
1465             for (x = 0; x < 3; x++)
1466               content[c].e[x][y] = default_value;
1467       }
1468     }
1469     else        /* constant size configuration data (1, 2 or 4 bytes) */
1470     {
1471       if (data_type == TYPE_BOOLEAN)
1472         *(boolean *)(conf[i].value) = default_value;
1473       else
1474         *(int *)    (conf[i].value) = default_value;
1475     }
1476   }
1477 }
1478
1479 static void copyConfigFromConfigList(struct LevelFileConfigInfo *conf)
1480 {
1481   int i;
1482
1483   for (i = 0; conf[i].data_type != -1; i++)
1484   {
1485     int data_type = conf[i].data_type;
1486     int conf_type = conf[i].conf_type;
1487     int byte_mask = conf_type & CONF_MASK_BYTES;
1488
1489     if (byte_mask == CONF_MASK_MULTI_BYTES)
1490     {
1491       int max_num_entities = conf[i].max_num_entities;
1492
1493       if (data_type == TYPE_STRING)
1494       {
1495         char *string      = (char *)(conf[i].value);
1496         char *string_copy = (char *)(conf[i].value_copy);
1497
1498         strncpy(string_copy, string, max_num_entities);
1499       }
1500       else if (data_type == TYPE_ELEMENT_LIST)
1501       {
1502         int *element_array      = (int *)(conf[i].value);
1503         int *element_array_copy = (int *)(conf[i].value_copy);
1504         int j;
1505
1506         for (j = 0; j < max_num_entities; j++)
1507           element_array_copy[j] = element_array[j];
1508       }
1509       else if (data_type == TYPE_CONTENT_LIST)
1510       {
1511         struct Content *content      = (struct Content *)(conf[i].value);
1512         struct Content *content_copy = (struct Content *)(conf[i].value_copy);
1513         int c, x, y;
1514
1515         for (c = 0; c < max_num_entities; c++)
1516           for (y = 0; y < 3; y++)
1517             for (x = 0; x < 3; x++)
1518               content_copy[c].e[x][y] = content[c].e[x][y];
1519       }
1520     }
1521     else        /* constant size configuration data (1, 2 or 4 bytes) */
1522     {
1523       if (data_type == TYPE_BOOLEAN)
1524         *(boolean *)(conf[i].value_copy) = *(boolean *)(conf[i].value);
1525       else
1526         *(int *)    (conf[i].value_copy) = *(int *)    (conf[i].value);
1527     }
1528   }
1529 }
1530
1531 void copyElementInfo(struct ElementInfo *ei_from, struct ElementInfo *ei_to)
1532 {
1533   int i;
1534
1535   xx_ei = *ei_from;     /* copy element data into temporary buffer */
1536   yy_ei = *ei_to;       /* copy element data into temporary buffer */
1537
1538   copyConfigFromConfigList(chunk_config_CUSX_base);
1539
1540   *ei_from = xx_ei;
1541   *ei_to   = yy_ei;
1542
1543   /* ---------- reinitialize and copy change pages ---------- */
1544
1545   ei_to->num_change_pages = ei_from->num_change_pages;
1546   ei_to->current_change_page = ei_from->current_change_page;
1547
1548   setElementChangePages(ei_to, ei_to->num_change_pages);
1549
1550   for (i = 0; i < ei_to->num_change_pages; i++)
1551     ei_to->change_page[i] = ei_from->change_page[i];
1552
1553   /* ---------- copy group element info ---------- */
1554   if (ei_from->group != NULL && ei_to->group != NULL)   /* group or internal */
1555     *ei_to->group = *ei_from->group;
1556
1557   /* mark this custom element as modified */
1558   ei_to->modified_settings = TRUE;
1559 }
1560
1561 void setElementChangePages(struct ElementInfo *ei, int change_pages)
1562 {
1563   int change_page_size = sizeof(struct ElementChangeInfo);
1564
1565   ei->num_change_pages = MAX(1, change_pages);
1566
1567   ei->change_page =
1568     checked_realloc(ei->change_page, ei->num_change_pages * change_page_size);
1569
1570   if (ei->current_change_page >= ei->num_change_pages)
1571     ei->current_change_page = ei->num_change_pages - 1;
1572
1573   ei->change = &ei->change_page[ei->current_change_page];
1574 }
1575
1576 void setElementChangeInfoToDefaults(struct ElementChangeInfo *change)
1577 {
1578   xx_change = *change;          /* copy change data into temporary buffer */
1579
1580   setConfigToDefaultsFromConfigList(chunk_config_CUSX_change);
1581
1582   *change = xx_change;
1583
1584   resetEventFlags(change);
1585
1586   change->direct_action = 0;
1587   change->other_action = 0;
1588
1589   change->pre_change_function = NULL;
1590   change->change_function = NULL;
1591   change->post_change_function = NULL;
1592 }
1593
1594 static void setLevelInfoToDefaults_Level(struct LevelInfo *level)
1595 {
1596   int i, x, y;
1597
1598   li = *level;          /* copy level data into temporary buffer */
1599   setConfigToDefaultsFromConfigList(chunk_config_INFO);
1600   *level = li;          /* copy temporary buffer back to level data */
1601
1602   setLevelInfoToDefaults_EM();
1603   setLevelInfoToDefaults_SP();
1604
1605   level->native_em_level = &native_em_level;
1606   level->native_sp_level = &native_sp_level;
1607
1608   level->file_version = FILE_VERSION_ACTUAL;
1609   level->game_version = GAME_VERSION_ACTUAL;
1610
1611   level->creation_date = getCurrentDate();
1612
1613   level->encoding_16bit_field  = TRUE;
1614   level->encoding_16bit_yamyam = TRUE;
1615   level->encoding_16bit_amoeba = TRUE;
1616
1617   /* clear level name and level author string buffers */
1618   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
1619     level->name[i] = '\0';
1620   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
1621     level->author[i] = '\0';
1622
1623   /* set level name and level author to default values */
1624   strcpy(level->name, NAMELESS_LEVEL_NAME);
1625   strcpy(level->author, ANONYMOUS_NAME);
1626
1627   /* set level playfield to playable default level with player and exit */
1628   for (x = 0; x < MAX_LEV_FIELDX; x++)
1629     for (y = 0; y < MAX_LEV_FIELDY; y++)
1630       level->field[x][y] = EL_SAND;
1631
1632   level->field[0][0] = EL_PLAYER_1;
1633   level->field[STD_LEV_FIELDX - 1][STD_LEV_FIELDY - 1] = EL_EXIT_CLOSED;
1634
1635   BorderElement = EL_STEELWALL;
1636
1637   /* set all bug compatibility flags to "false" => do not emulate this bug */
1638   level->use_action_after_change_bug = FALSE;
1639
1640   if (leveldir_current)
1641   {
1642     /* try to determine better author name than 'anonymous' */
1643     if (!strEqual(leveldir_current->author, ANONYMOUS_NAME))
1644     {
1645       strncpy(level->author, leveldir_current->author, MAX_LEVEL_AUTHOR_LEN);
1646       level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
1647     }
1648     else
1649     {
1650       switch (LEVELCLASS(leveldir_current))
1651       {
1652         case LEVELCLASS_TUTORIAL:
1653           strcpy(level->author, PROGRAM_AUTHOR_STRING);
1654           break;
1655
1656         case LEVELCLASS_CONTRIB:
1657           strncpy(level->author, leveldir_current->name, MAX_LEVEL_AUTHOR_LEN);
1658           level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
1659           break;
1660
1661         case LEVELCLASS_PRIVATE:
1662           strncpy(level->author, getRealName(), MAX_LEVEL_AUTHOR_LEN);
1663           level->author[MAX_LEVEL_AUTHOR_LEN] = '\0';
1664           break;
1665
1666         default:
1667           /* keep default value */
1668           break;
1669       }
1670     }
1671   }
1672 }
1673
1674 static void setLevelInfoToDefaults_Elements(struct LevelInfo *level)
1675 {
1676   static boolean clipboard_elements_initialized = FALSE;
1677   int i;
1678
1679   InitElementPropertiesStatic();
1680
1681   li = *level;          /* copy level data into temporary buffer */
1682   setConfigToDefaultsFromConfigList(chunk_config_ELEM);
1683   *level = li;          /* copy temporary buffer back to level data */
1684
1685   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1686   {
1687     int element = i;
1688     struct ElementInfo *ei = &element_info[element];
1689
1690     /* never initialize clipboard elements after the very first time */
1691     /* (to be able to use clipboard elements between several levels) */
1692     if (IS_CLIPBOARD_ELEMENT(element) && clipboard_elements_initialized)
1693       continue;
1694
1695     if (IS_ENVELOPE(element))
1696     {
1697       int envelope_nr = element - EL_ENVELOPE_1;
1698
1699       setConfigToDefaultsFromConfigList(chunk_config_NOTE);
1700
1701       level->envelope[envelope_nr] = xx_envelope;
1702     }
1703
1704     if (IS_CUSTOM_ELEMENT(element) ||
1705         IS_GROUP_ELEMENT(element) ||
1706         IS_INTERNAL_ELEMENT(element))
1707     {
1708       xx_ei = *ei;      /* copy element data into temporary buffer */
1709
1710       setConfigToDefaultsFromConfigList(chunk_config_CUSX_base);
1711
1712       *ei = xx_ei;
1713     }
1714
1715     setElementChangePages(ei, 1);
1716     setElementChangeInfoToDefaults(ei->change);
1717
1718     if (IS_CUSTOM_ELEMENT(element) ||
1719         IS_GROUP_ELEMENT(element) ||
1720         IS_INTERNAL_ELEMENT(element))
1721     {
1722       setElementDescriptionToDefault(ei);
1723
1724       ei->modified_settings = FALSE;
1725     }
1726
1727     if (IS_CUSTOM_ELEMENT(element) ||
1728         IS_INTERNAL_ELEMENT(element))
1729     {
1730       /* internal values used in level editor */
1731
1732       ei->access_type = 0;
1733       ei->access_layer = 0;
1734       ei->access_protected = 0;
1735       ei->walk_to_action = 0;
1736       ei->smash_targets = 0;
1737       ei->deadliness = 0;
1738
1739       ei->can_explode_by_fire = FALSE;
1740       ei->can_explode_smashed = FALSE;
1741       ei->can_explode_impact = FALSE;
1742
1743       ei->current_change_page = 0;
1744     }
1745
1746     if (IS_GROUP_ELEMENT(element) ||
1747         IS_INTERNAL_ELEMENT(element))
1748     {
1749       struct ElementGroupInfo *group;
1750
1751       /* initialize memory for list of elements in group */
1752       if (ei->group == NULL)
1753         ei->group = checked_malloc(sizeof(struct ElementGroupInfo));
1754
1755       group = ei->group;
1756
1757       xx_group = *group;        /* copy group data into temporary buffer */
1758
1759       setConfigToDefaultsFromConfigList(chunk_config_GRPX);
1760
1761       *group = xx_group;
1762     }
1763   }
1764
1765   clipboard_elements_initialized = TRUE;
1766 }
1767
1768 static void setLevelInfoToDefaults(struct LevelInfo *level,
1769                                    boolean level_info_only,
1770                                    boolean reset_file_status)
1771 {
1772   setLevelInfoToDefaults_Level(level);
1773
1774   if (!level_info_only)
1775     setLevelInfoToDefaults_Elements(level);
1776
1777   if (reset_file_status)
1778   {
1779     level->no_valid_file = FALSE;
1780     level->no_level_file = FALSE;
1781   }
1782
1783   level->changed = FALSE;
1784 }
1785
1786 static void setFileInfoToDefaults(struct LevelFileInfo *level_file_info)
1787 {
1788   level_file_info->nr = 0;
1789   level_file_info->type = LEVEL_FILE_TYPE_UNKNOWN;
1790   level_file_info->packed = FALSE;
1791   level_file_info->basename = NULL;
1792   level_file_info->filename = NULL;
1793 }
1794
1795 int getMappedElement_SB(int, boolean);
1796
1797 static void ActivateLevelTemplate()
1798 {
1799   int x, y;
1800
1801   if (check_special_flags("load_xsb_to_ces"))
1802   {
1803     /* fill smaller playfields with padding "beyond border wall" elements */
1804     if (level.fieldx < level_template.fieldx ||
1805         level.fieldy < level_template.fieldy)
1806     {
1807       short field[level.fieldx][level.fieldy];
1808       int new_fieldx = MAX(level.fieldx, level_template.fieldx);
1809       int new_fieldy = MAX(level.fieldy, level_template.fieldy);
1810       int pos_fieldx = (new_fieldx - level.fieldx) / 2;
1811       int pos_fieldy = (new_fieldy - level.fieldy) / 2;
1812
1813       /* copy old playfield (which is smaller than the visible area) */
1814       for (y = 0; y < level.fieldy; y++) for (x = 0; x < level.fieldx; x++)
1815         field[x][y] = level.field[x][y];
1816
1817       /* fill new, larger playfield with "beyond border wall" elements */
1818       for (y = 0; y < new_fieldy; y++) for (x = 0; x < new_fieldx; x++)
1819         level.field[x][y] = getMappedElement_SB('_', TRUE);
1820
1821       /* copy the old playfield to the middle of the new playfield */
1822       for (y = 0; y < level.fieldy; y++) for (x = 0; x < level.fieldx; x++)
1823         level.field[pos_fieldx + x][pos_fieldy + y] = field[x][y];
1824
1825       level.fieldx = new_fieldx;
1826       level.fieldy = new_fieldy;
1827     }
1828   }
1829
1830   /* Currently there is no special action needed to activate the template
1831      data, because 'element_info' property settings overwrite the original
1832      level data, while all other variables do not change. */
1833
1834   /* Exception: 'from_level_template' elements in the original level playfield
1835      are overwritten with the corresponding elements at the same position in
1836      playfield from the level template. */
1837
1838   for (x = 0; x < level.fieldx; x++)
1839     for (y = 0; y < level.fieldy; y++)
1840       if (level.field[x][y] == EL_FROM_LEVEL_TEMPLATE)
1841         level.field[x][y] = level_template.field[x][y];
1842
1843   if (check_special_flags("load_xsb_to_ces"))
1844   {
1845     struct LevelInfo level_backup = level;
1846
1847     /* overwrite all individual level settings from template level settings */
1848     level = level_template;
1849
1850     /* restore playfield size */
1851     level.fieldx = level_backup.fieldx;
1852     level.fieldy = level_backup.fieldy;
1853
1854     /* restore playfield content */
1855     for (x = 0; x < level.fieldx; x++)
1856       for (y = 0; y < level.fieldy; y++)
1857         level.field[x][y] = level_backup.field[x][y];
1858
1859     /* restore name and author from individual level */
1860     strcpy(level.name,   level_backup.name);
1861     strcpy(level.author, level_backup.author);
1862
1863     /* restore flag "use_custom_template" */
1864     level.use_custom_template = level_backup.use_custom_template;
1865   }
1866 }
1867
1868 static char *getLevelFilenameFromBasename(char *basename)
1869 {
1870   static char *filename[2] = { NULL, NULL };
1871   int pos = (strEqual(basename, LEVELTEMPLATE_FILENAME) ? 0 : 1);
1872
1873   checked_free(filename[pos]);
1874
1875   filename[pos] = getPath2(getCurrentLevelDir(), basename);
1876
1877   return filename[pos];
1878 }
1879
1880 static int getFileTypeFromBasename(char *basename)
1881 {
1882   /* !!! ALSO SEE COMMENT IN checkForPackageFromBasename() !!! */
1883
1884   static char *filename = NULL;
1885   struct stat file_status;
1886
1887   /* ---------- try to determine file type from filename ---------- */
1888
1889   /* check for typical filename of a Supaplex level package file */
1890   if (strlen(basename) == 10 && strPrefixLower(basename, "levels.d"))
1891     return LEVEL_FILE_TYPE_SP;
1892
1893   /* check for typical filename of a Diamond Caves II level package file */
1894   if (strSuffixLower(basename, ".dc") ||
1895       strSuffixLower(basename, ".dc2"))
1896     return LEVEL_FILE_TYPE_DC;
1897
1898   /* check for typical filename of a Sokoban level package file */
1899   if (strSuffixLower(basename, ".xsb") &&
1900       strchr(basename, '%') == NULL)
1901     return LEVEL_FILE_TYPE_SB;
1902
1903   /* ---------- try to determine file type from filesize ---------- */
1904
1905   checked_free(filename);
1906   filename = getPath2(getCurrentLevelDir(), basename);
1907
1908   if (stat(filename, &file_status) == 0)
1909   {
1910     /* check for typical filesize of a Supaplex level package file */
1911     if (file_status.st_size == 170496)
1912       return LEVEL_FILE_TYPE_SP;
1913   }
1914
1915   return LEVEL_FILE_TYPE_UNKNOWN;
1916 }
1917
1918 static boolean checkForPackageFromBasename(char *basename)
1919 {
1920   /* !!! WON'T WORK ANYMORE IF getFileTypeFromBasename() ALSO DETECTS !!!
1921      !!! SINGLE LEVELS (CURRENTLY ONLY DETECTS LEVEL PACKAGES         !!! */
1922
1923   return (getFileTypeFromBasename(basename) != LEVEL_FILE_TYPE_UNKNOWN);
1924 }
1925
1926 static char *getSingleLevelBasenameExt(int nr, char *extension)
1927 {
1928   static char basename[MAX_FILENAME_LEN];
1929
1930   if (nr < 0)
1931     sprintf(basename, "%s", LEVELTEMPLATE_FILENAME);
1932   else
1933     sprintf(basename, "%03d.%s", nr, extension);
1934
1935   return basename;
1936 }
1937
1938 static char *getSingleLevelBasename(int nr)
1939 {
1940   return getSingleLevelBasenameExt(nr, LEVELFILE_EXTENSION);
1941 }
1942
1943 static char *getPackedLevelBasename(int type)
1944 {
1945   static char basename[MAX_FILENAME_LEN];
1946   char *directory = getCurrentLevelDir();
1947   Directory *dir;
1948   DirectoryEntry *dir_entry;
1949
1950   strcpy(basename, UNDEFINED_FILENAME);         /* default: undefined file */
1951
1952   if ((dir = openDirectory(directory)) == NULL)
1953   {
1954     Error(ERR_WARN, "cannot read current level directory '%s'", directory);
1955
1956     return basename;
1957   }
1958
1959   while ((dir_entry = readDirectory(dir)) != NULL)      /* loop all entries */
1960   {
1961     char *entry_basename = dir_entry->basename;
1962     int entry_type = getFileTypeFromBasename(entry_basename);
1963
1964     if (entry_type != LEVEL_FILE_TYPE_UNKNOWN)  /* found valid level package */
1965     {
1966       if (type == LEVEL_FILE_TYPE_UNKNOWN ||
1967           type == entry_type)
1968       {
1969         strcpy(basename, entry_basename);
1970
1971         break;
1972       }
1973     }
1974   }
1975
1976   closeDirectory(dir);
1977
1978   return basename;
1979 }
1980
1981 static char *getSingleLevelFilename(int nr)
1982 {
1983   return getLevelFilenameFromBasename(getSingleLevelBasename(nr));
1984 }
1985
1986 #if ENABLE_UNUSED_CODE
1987 static char *getPackedLevelFilename(int type)
1988 {
1989   return getLevelFilenameFromBasename(getPackedLevelBasename(type));
1990 }
1991 #endif
1992
1993 char *getDefaultLevelFilename(int nr)
1994 {
1995   return getSingleLevelFilename(nr);
1996 }
1997
1998 #if ENABLE_UNUSED_CODE
1999 static void setLevelFileInfo_SingleLevelFilename(struct LevelFileInfo *lfi,
2000                                                  int type)
2001 {
2002   lfi->type = type;
2003   lfi->packed = FALSE;
2004   lfi->basename = getSingleLevelBasename(lfi->nr, lfi->type);
2005   lfi->filename = getLevelFilenameFromBasename(lfi->basename);
2006 }
2007 #endif
2008
2009 static void setLevelFileInfo_FormatLevelFilename(struct LevelFileInfo *lfi,
2010                                                  int type, char *format, ...)
2011 {
2012   static char basename[MAX_FILENAME_LEN];
2013   va_list ap;
2014
2015   va_start(ap, format);
2016   vsprintf(basename, format, ap);
2017   va_end(ap);
2018
2019   lfi->type = type;
2020   lfi->packed = FALSE;
2021   lfi->basename = basename;
2022   lfi->filename = getLevelFilenameFromBasename(lfi->basename);
2023 }
2024
2025 static void setLevelFileInfo_PackedLevelFilename(struct LevelFileInfo *lfi,
2026                                                  int type)
2027 {
2028   lfi->type = type;
2029   lfi->packed = TRUE;
2030   lfi->basename = getPackedLevelBasename(lfi->type);
2031   lfi->filename = getLevelFilenameFromBasename(lfi->basename);
2032 }
2033
2034 static int getFiletypeFromID(char *filetype_id)
2035 {
2036   char *filetype_id_lower;
2037   int filetype = LEVEL_FILE_TYPE_UNKNOWN;
2038   int i;
2039
2040   if (filetype_id == NULL)
2041     return LEVEL_FILE_TYPE_UNKNOWN;
2042
2043   filetype_id_lower = getStringToLower(filetype_id);
2044
2045   for (i = 0; filetype_id_list[i].id != NULL; i++)
2046   {
2047     char *id_lower = getStringToLower(filetype_id_list[i].id);
2048
2049     if (strEqual(filetype_id_lower, id_lower))
2050       filetype = filetype_id_list[i].filetype;
2051
2052     free(id_lower);
2053
2054     if (filetype != LEVEL_FILE_TYPE_UNKNOWN)
2055       break;
2056   }
2057
2058   free(filetype_id_lower);
2059
2060   return filetype;
2061 }
2062
2063 char *getLocalLevelTemplateFilename()
2064 {
2065   return getDefaultLevelFilename(-1);
2066 }
2067
2068 char *getGlobalLevelTemplateFilename()
2069 {
2070   /* global variable "leveldir_current" must be modified in the loop below */
2071   LevelDirTree *leveldir_current_last = leveldir_current;
2072   char *filename = NULL;
2073
2074   /* check for template level in path from current to topmost tree node */
2075
2076   while (leveldir_current != NULL)
2077   {
2078     filename = getDefaultLevelFilename(-1);
2079
2080     if (fileExists(filename))
2081       break;
2082
2083     leveldir_current = leveldir_current->node_parent;
2084   }
2085
2086   /* restore global variable "leveldir_current" modified in above loop */
2087   leveldir_current = leveldir_current_last;
2088
2089   return filename;
2090 }
2091
2092 static void determineLevelFileInfo_Filename(struct LevelFileInfo *lfi)
2093 {
2094   int nr = lfi->nr;
2095
2096   /* special case: level number is negative => check for level template file */
2097   if (nr < 0)
2098   {
2099     setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
2100                                          getSingleLevelBasename(-1));
2101
2102     /* replace local level template filename with global template filename */
2103     lfi->filename = getGlobalLevelTemplateFilename();
2104
2105     /* no fallback if template file not existing */
2106     return;
2107   }
2108
2109   /* special case: check for file name/pattern specified in "levelinfo.conf" */
2110   if (leveldir_current->level_filename != NULL)
2111   {
2112     int filetype = getFiletypeFromID(leveldir_current->level_filetype);
2113
2114     setLevelFileInfo_FormatLevelFilename(lfi, filetype,
2115                                          leveldir_current->level_filename, nr);
2116
2117     lfi->packed = checkForPackageFromBasename(leveldir_current->level_filename);
2118
2119     if (fileExists(lfi->filename))
2120       return;
2121   }
2122
2123   /* check for native Rocks'n'Diamonds level file */
2124   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
2125                                        "%03d.%s", nr, LEVELFILE_EXTENSION);
2126   if (fileExists(lfi->filename))
2127     return;
2128
2129   /* check for Emerald Mine level file (V1) */
2130   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "a%c%c",
2131                                        'a' + (nr / 10) % 26, '0' + nr % 10);
2132   if (fileExists(lfi->filename))
2133     return;
2134   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "A%c%c",
2135                                        'A' + (nr / 10) % 26, '0' + nr % 10);
2136   if (fileExists(lfi->filename))
2137     return;
2138
2139   /* check for Emerald Mine level file (V2 to V5) */
2140   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%d", nr);
2141   if (fileExists(lfi->filename))
2142     return;
2143
2144   /* check for Emerald Mine level file (V6 / single mode) */
2145   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02ds", nr);
2146   if (fileExists(lfi->filename))
2147     return;
2148   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dS", nr);
2149   if (fileExists(lfi->filename))
2150     return;
2151
2152   /* check for Emerald Mine level file (V6 / teamwork mode) */
2153   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dt", nr);
2154   if (fileExists(lfi->filename))
2155     return;
2156   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_EM, "%02dT", nr);
2157   if (fileExists(lfi->filename))
2158     return;
2159
2160   /* check for various packed level file formats */
2161   setLevelFileInfo_PackedLevelFilename(lfi, LEVEL_FILE_TYPE_UNKNOWN);
2162   if (fileExists(lfi->filename))
2163     return;
2164
2165   /* no known level file found -- use default values (and fail later) */
2166   setLevelFileInfo_FormatLevelFilename(lfi, LEVEL_FILE_TYPE_RND,
2167                                        "%03d.%s", nr, LEVELFILE_EXTENSION);
2168 }
2169
2170 static void determineLevelFileInfo_Filetype(struct LevelFileInfo *lfi)
2171 {
2172   if (lfi->type == LEVEL_FILE_TYPE_UNKNOWN)
2173     lfi->type = getFileTypeFromBasename(lfi->basename);
2174 }
2175
2176 static void setLevelFileInfo(struct LevelFileInfo *level_file_info, int nr)
2177 {
2178   /* always start with reliable default values */
2179   setFileInfoToDefaults(level_file_info);
2180
2181   level_file_info->nr = nr;     /* set requested level number */
2182
2183   determineLevelFileInfo_Filename(level_file_info);
2184   determineLevelFileInfo_Filetype(level_file_info);
2185 }
2186
2187 /* ------------------------------------------------------------------------- */
2188 /* functions for loading R'n'D level                                         */
2189 /* ------------------------------------------------------------------------- */
2190
2191 int getMappedElement(int element)
2192 {
2193   /* remap some (historic, now obsolete) elements */
2194
2195   switch (element)
2196   {
2197     case EL_PLAYER_OBSOLETE:
2198       element = EL_PLAYER_1;
2199       break;
2200
2201     case EL_KEY_OBSOLETE:
2202       element = EL_KEY_1;
2203       break;
2204
2205     case EL_EM_KEY_1_FILE_OBSOLETE:
2206       element = EL_EM_KEY_1;
2207       break;
2208
2209     case EL_EM_KEY_2_FILE_OBSOLETE:
2210       element = EL_EM_KEY_2;
2211       break;
2212
2213     case EL_EM_KEY_3_FILE_OBSOLETE:
2214       element = EL_EM_KEY_3;
2215       break;
2216
2217     case EL_EM_KEY_4_FILE_OBSOLETE:
2218       element = EL_EM_KEY_4;
2219       break;
2220
2221     case EL_ENVELOPE_OBSOLETE:
2222       element = EL_ENVELOPE_1;
2223       break;
2224
2225     case EL_SP_EMPTY:
2226       element = EL_EMPTY;
2227       break;
2228
2229     default:
2230       if (element >= NUM_FILE_ELEMENTS)
2231       {
2232         Error(ERR_WARN, "invalid level element %d", element);
2233
2234         element = EL_UNKNOWN;
2235       }
2236       break;
2237   }
2238
2239   return element;
2240 }
2241
2242 int getMappedElementByVersion(int element, int game_version)
2243 {
2244   /* remap some elements due to certain game version */
2245
2246   if (game_version <= VERSION_IDENT(2,2,0,0))
2247   {
2248     /* map game font elements */
2249     element = (element == EL_CHAR('[')  ? EL_CHAR_AUMLAUT :
2250                element == EL_CHAR('\\') ? EL_CHAR_OUMLAUT :
2251                element == EL_CHAR(']')  ? EL_CHAR_UUMLAUT :
2252                element == EL_CHAR('^')  ? EL_CHAR_COPYRIGHT : element);
2253   }
2254
2255   if (game_version < VERSION_IDENT(3,0,0,0))
2256   {
2257     /* map Supaplex gravity tube elements */
2258     element = (element == EL_SP_GRAVITY_PORT_LEFT  ? EL_SP_PORT_LEFT  :
2259                element == EL_SP_GRAVITY_PORT_RIGHT ? EL_SP_PORT_RIGHT :
2260                element == EL_SP_GRAVITY_PORT_UP    ? EL_SP_PORT_UP    :
2261                element == EL_SP_GRAVITY_PORT_DOWN  ? EL_SP_PORT_DOWN  :
2262                element);
2263   }
2264
2265   return element;
2266 }
2267
2268 static int LoadLevel_VERS(File *file, int chunk_size, struct LevelInfo *level)
2269 {
2270   level->file_version = getFileVersion(file);
2271   level->game_version = getFileVersion(file);
2272
2273   return chunk_size;
2274 }
2275
2276 static int LoadLevel_DATE(File *file, int chunk_size, struct LevelInfo *level)
2277 {
2278   level->creation_date.year  = getFile16BitBE(file);
2279   level->creation_date.month = getFile8Bit(file);
2280   level->creation_date.day   = getFile8Bit(file);
2281
2282   level->creation_date.src   = DATE_SRC_LEVELFILE;
2283
2284   return chunk_size;
2285 }
2286
2287 static int LoadLevel_HEAD(File *file, int chunk_size, struct LevelInfo *level)
2288 {
2289   int initial_player_stepsize;
2290   int initial_player_gravity;
2291   int i, x, y;
2292
2293   level->fieldx = getFile8Bit(file);
2294   level->fieldy = getFile8Bit(file);
2295
2296   level->time           = getFile16BitBE(file);
2297   level->gems_needed    = getFile16BitBE(file);
2298
2299   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
2300     level->name[i] = getFile8Bit(file);
2301   level->name[MAX_LEVEL_NAME_LEN] = 0;
2302
2303   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
2304     level->score[i] = getFile8Bit(file);
2305
2306   level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
2307   for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
2308     for (y = 0; y < 3; y++)
2309       for (x = 0; x < 3; x++)
2310         level->yamyam_content[i].e[x][y] = getMappedElement(getFile8Bit(file));
2311
2312   level->amoeba_speed           = getFile8Bit(file);
2313   level->time_magic_wall        = getFile8Bit(file);
2314   level->time_wheel             = getFile8Bit(file);
2315   level->amoeba_content         = getMappedElement(getFile8Bit(file));
2316
2317   initial_player_stepsize       = (getFile8Bit(file) == 1 ? STEPSIZE_FAST :
2318                                    STEPSIZE_NORMAL);
2319
2320   for (i = 0; i < MAX_PLAYERS; i++)
2321     level->initial_player_stepsize[i] = initial_player_stepsize;
2322
2323   initial_player_gravity        = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2324
2325   for (i = 0; i < MAX_PLAYERS; i++)
2326     level->initial_player_gravity[i] = initial_player_gravity;
2327
2328   level->encoding_16bit_field   = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2329   level->em_slippery_gems       = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2330
2331   level->use_custom_template    = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2332
2333   level->block_last_field       = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2334   level->sp_block_last_field    = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2335   level->can_move_into_acid_bits = getFile32BitBE(file);
2336   level->dont_collide_with_bits = getFile8Bit(file);
2337
2338   level->use_spring_bug         = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2339   level->use_step_counter       = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2340
2341   level->instant_relocation     = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2342   level->can_pass_to_walkable   = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2343   level->grow_into_diggable     = (getFile8Bit(file) == 1 ? TRUE : FALSE);
2344
2345   level->game_engine_type       = getFile8Bit(file);
2346
2347   ReadUnusedBytesFromFile(file, LEVEL_CHUNK_HEAD_UNUSED);
2348
2349   return chunk_size;
2350 }
2351
2352 static int LoadLevel_NAME(File *file, int chunk_size, struct LevelInfo *level)
2353 {
2354   int i;
2355
2356   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
2357     level->name[i] = getFile8Bit(file);
2358   level->name[MAX_LEVEL_NAME_LEN] = 0;
2359
2360   return chunk_size;
2361 }
2362
2363 static int LoadLevel_AUTH(File *file, int chunk_size, struct LevelInfo *level)
2364 {
2365   int i;
2366
2367   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
2368     level->author[i] = getFile8Bit(file);
2369   level->author[MAX_LEVEL_AUTHOR_LEN] = 0;
2370
2371   return chunk_size;
2372 }
2373
2374 static int LoadLevel_BODY(File *file, int chunk_size, struct LevelInfo *level)
2375 {
2376   int x, y;
2377   int chunk_size_expected = level->fieldx * level->fieldy;
2378
2379   /* Note: "chunk_size" was wrong before version 2.0 when elements are
2380      stored with 16-bit encoding (and should be twice as big then).
2381      Even worse, playfield data was stored 16-bit when only yamyam content
2382      contained 16-bit elements and vice versa. */
2383
2384   if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
2385     chunk_size_expected *= 2;
2386
2387   if (chunk_size_expected != chunk_size)
2388   {
2389     ReadUnusedBytesFromFile(file, chunk_size);
2390     return chunk_size_expected;
2391   }
2392
2393   for (y = 0; y < level->fieldy; y++)
2394     for (x = 0; x < level->fieldx; x++)
2395       level->field[x][y] =
2396         getMappedElement(level->encoding_16bit_field ? getFile16BitBE(file) :
2397                          getFile8Bit(file));
2398   return chunk_size;
2399 }
2400
2401 static int LoadLevel_CONT(File *file, int chunk_size, struct LevelInfo *level)
2402 {
2403   int i, x, y;
2404   int header_size = 4;
2405   int content_size = MAX_ELEMENT_CONTENTS * 3 * 3;
2406   int chunk_size_expected = header_size + content_size;
2407
2408   /* Note: "chunk_size" was wrong before version 2.0 when elements are
2409      stored with 16-bit encoding (and should be twice as big then).
2410      Even worse, playfield data was stored 16-bit when only yamyam content
2411      contained 16-bit elements and vice versa. */
2412
2413   if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
2414     chunk_size_expected += content_size;
2415
2416   if (chunk_size_expected != chunk_size)
2417   {
2418     ReadUnusedBytesFromFile(file, chunk_size);
2419     return chunk_size_expected;
2420   }
2421
2422   getFile8Bit(file);
2423   level->num_yamyam_contents = getFile8Bit(file);
2424   getFile8Bit(file);
2425   getFile8Bit(file);
2426
2427   /* correct invalid number of content fields -- should never happen */
2428   if (level->num_yamyam_contents < 1 ||
2429       level->num_yamyam_contents > MAX_ELEMENT_CONTENTS)
2430     level->num_yamyam_contents = STD_ELEMENT_CONTENTS;
2431
2432   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2433     for (y = 0; y < 3; y++)
2434       for (x = 0; x < 3; x++)
2435         level->yamyam_content[i].e[x][y] =
2436           getMappedElement(level->encoding_16bit_field ?
2437                            getFile16BitBE(file) : getFile8Bit(file));
2438   return chunk_size;
2439 }
2440
2441 static int LoadLevel_CNT2(File *file, int chunk_size, struct LevelInfo *level)
2442 {
2443   int i, x, y;
2444   int element;
2445   int num_contents;
2446   int content_array[MAX_ELEMENT_CONTENTS][3][3];
2447
2448   element = getMappedElement(getFile16BitBE(file));
2449   num_contents = getFile8Bit(file);
2450
2451   getFile8Bit(file);    /* content x size (unused) */
2452   getFile8Bit(file);    /* content y size (unused) */
2453
2454   ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT2_UNUSED);
2455
2456   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
2457     for (y = 0; y < 3; y++)
2458       for (x = 0; x < 3; x++)
2459         content_array[i][x][y] = getMappedElement(getFile16BitBE(file));
2460
2461   /* correct invalid number of content fields -- should never happen */
2462   if (num_contents < 1 || num_contents > MAX_ELEMENT_CONTENTS)
2463     num_contents = STD_ELEMENT_CONTENTS;
2464
2465   if (element == EL_YAMYAM)
2466   {
2467     level->num_yamyam_contents = num_contents;
2468
2469     for (i = 0; i < num_contents; i++)
2470       for (y = 0; y < 3; y++)
2471         for (x = 0; x < 3; x++)
2472           level->yamyam_content[i].e[x][y] = content_array[i][x][y];
2473   }
2474   else if (element == EL_BD_AMOEBA)
2475   {
2476     level->amoeba_content = content_array[0][0][0];
2477   }
2478   else
2479   {
2480     Error(ERR_WARN, "cannot load content for element '%d'", element);
2481   }
2482
2483   return chunk_size;
2484 }
2485
2486 static int LoadLevel_CNT3(File *file, int chunk_size, struct LevelInfo *level)
2487 {
2488   int i;
2489   int element;
2490   int envelope_nr;
2491   int envelope_len;
2492   int chunk_size_expected;
2493
2494   element = getMappedElement(getFile16BitBE(file));
2495   if (!IS_ENVELOPE(element))
2496     element = EL_ENVELOPE_1;
2497
2498   envelope_nr = element - EL_ENVELOPE_1;
2499
2500   envelope_len = getFile16BitBE(file);
2501
2502   level->envelope[envelope_nr].xsize = getFile8Bit(file);
2503   level->envelope[envelope_nr].ysize = getFile8Bit(file);
2504
2505   ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT3_UNUSED);
2506
2507   chunk_size_expected = LEVEL_CHUNK_CNT3_SIZE(envelope_len);
2508   if (chunk_size_expected != chunk_size)
2509   {
2510     ReadUnusedBytesFromFile(file, chunk_size - LEVEL_CHUNK_CNT3_HEADER);
2511     return chunk_size_expected;
2512   }
2513
2514   for (i = 0; i < envelope_len; i++)
2515     level->envelope[envelope_nr].text[i] = getFile8Bit(file);
2516
2517   return chunk_size;
2518 }
2519
2520 static int LoadLevel_CUS1(File *file, int chunk_size, struct LevelInfo *level)
2521 {
2522   int num_changed_custom_elements = getFile16BitBE(file);
2523   int chunk_size_expected = 2 + num_changed_custom_elements * 6;
2524   int i;
2525
2526   if (chunk_size_expected != chunk_size)
2527   {
2528     ReadUnusedBytesFromFile(file, chunk_size - 2);
2529     return chunk_size_expected;
2530   }
2531
2532   for (i = 0; i < num_changed_custom_elements; i++)
2533   {
2534     int element = getMappedElement(getFile16BitBE(file));
2535     int properties = getFile32BitBE(file);
2536
2537     if (IS_CUSTOM_ELEMENT(element))
2538       element_info[element].properties[EP_BITFIELD_BASE_NR] = properties;
2539     else
2540       Error(ERR_WARN, "invalid custom element number %d", element);
2541
2542     /* older game versions that wrote level files with CUS1 chunks used
2543        different default push delay values (not yet stored in level file) */
2544     element_info[element].push_delay_fixed = 2;
2545     element_info[element].push_delay_random = 8;
2546   }
2547
2548   return chunk_size;
2549 }
2550
2551 static int LoadLevel_CUS2(File *file, int chunk_size, struct LevelInfo *level)
2552 {
2553   int num_changed_custom_elements = getFile16BitBE(file);
2554   int chunk_size_expected = 2 + num_changed_custom_elements * 4;
2555   int i;
2556
2557   if (chunk_size_expected != chunk_size)
2558   {
2559     ReadUnusedBytesFromFile(file, chunk_size - 2);
2560     return chunk_size_expected;
2561   }
2562
2563   for (i = 0; i < num_changed_custom_elements; i++)
2564   {
2565     int element = getMappedElement(getFile16BitBE(file));
2566     int custom_target_element = getMappedElement(getFile16BitBE(file));
2567
2568     if (IS_CUSTOM_ELEMENT(element))
2569       element_info[element].change->target_element = custom_target_element;
2570     else
2571       Error(ERR_WARN, "invalid custom element number %d", element);
2572   }
2573
2574   return chunk_size;
2575 }
2576
2577 static int LoadLevel_CUS3(File *file, int chunk_size, struct LevelInfo *level)
2578 {
2579   int num_changed_custom_elements = getFile16BitBE(file);
2580   int chunk_size_expected = LEVEL_CHUNK_CUS3_SIZE(num_changed_custom_elements);
2581   int i, j, x, y;
2582
2583   if (chunk_size_expected != chunk_size)
2584   {
2585     ReadUnusedBytesFromFile(file, chunk_size - 2);
2586     return chunk_size_expected;
2587   }
2588
2589   for (i = 0; i < num_changed_custom_elements; i++)
2590   {
2591     int element = getMappedElement(getFile16BitBE(file));
2592     struct ElementInfo *ei = &element_info[element];
2593     unsigned int event_bits;
2594
2595     if (!IS_CUSTOM_ELEMENT(element))
2596     {
2597       Error(ERR_WARN, "invalid custom element number %d", element);
2598
2599       element = EL_INTERNAL_DUMMY;
2600     }
2601
2602     for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
2603       ei->description[j] = getFile8Bit(file);
2604     ei->description[MAX_ELEMENT_NAME_LEN] = 0;
2605
2606     ei->properties[EP_BITFIELD_BASE_NR] = getFile32BitBE(file);
2607
2608     /* some free bytes for future properties and padding */
2609     ReadUnusedBytesFromFile(file, 7);
2610
2611     ei->use_gfx_element = getFile8Bit(file);
2612     ei->gfx_element_initial = getMappedElement(getFile16BitBE(file));
2613
2614     ei->collect_score_initial = getFile8Bit(file);
2615     ei->collect_count_initial = getFile8Bit(file);
2616
2617     ei->push_delay_fixed = getFile16BitBE(file);
2618     ei->push_delay_random = getFile16BitBE(file);
2619     ei->move_delay_fixed = getFile16BitBE(file);
2620     ei->move_delay_random = getFile16BitBE(file);
2621
2622     ei->move_pattern = getFile16BitBE(file);
2623     ei->move_direction_initial = getFile8Bit(file);
2624     ei->move_stepsize = getFile8Bit(file);
2625
2626     for (y = 0; y < 3; y++)
2627       for (x = 0; x < 3; x++)
2628         ei->content.e[x][y] = getMappedElement(getFile16BitBE(file));
2629
2630     event_bits = getFile32BitBE(file);
2631     for (j = 0; j < NUM_CHANGE_EVENTS; j++)
2632       if (event_bits & (1 << j))
2633         ei->change->has_event[j] = TRUE;
2634
2635     ei->change->target_element = getMappedElement(getFile16BitBE(file));
2636
2637     ei->change->delay_fixed = getFile16BitBE(file);
2638     ei->change->delay_random = getFile16BitBE(file);
2639     ei->change->delay_frames = getFile16BitBE(file);
2640
2641     ei->change->initial_trigger_element= getMappedElement(getFile16BitBE(file));
2642
2643     ei->change->explode = getFile8Bit(file);
2644     ei->change->use_target_content = getFile8Bit(file);
2645     ei->change->only_if_complete = getFile8Bit(file);
2646     ei->change->use_random_replace = getFile8Bit(file);
2647
2648     ei->change->random_percentage = getFile8Bit(file);
2649     ei->change->replace_when = getFile8Bit(file);
2650
2651     for (y = 0; y < 3; y++)
2652       for (x = 0; x < 3; x++)
2653         ei->change->target_content.e[x][y] =
2654           getMappedElement(getFile16BitBE(file));
2655
2656     ei->slippery_type = getFile8Bit(file);
2657
2658     /* some free bytes for future properties and padding */
2659     ReadUnusedBytesFromFile(file, LEVEL_CPART_CUS3_UNUSED);
2660
2661     /* mark that this custom element has been modified */
2662     ei->modified_settings = TRUE;
2663   }
2664
2665   return chunk_size;
2666 }
2667
2668 static int LoadLevel_CUS4(File *file, int chunk_size, struct LevelInfo *level)
2669 {
2670   struct ElementInfo *ei;
2671   int chunk_size_expected;
2672   int element;
2673   int i, j, x, y;
2674
2675   /* ---------- custom element base property values (96 bytes) ------------- */
2676
2677   element = getMappedElement(getFile16BitBE(file));
2678
2679   if (!IS_CUSTOM_ELEMENT(element))
2680   {
2681     Error(ERR_WARN, "invalid custom element number %d", element);
2682
2683     ReadUnusedBytesFromFile(file, chunk_size - 2);
2684     return chunk_size;
2685   }
2686
2687   ei = &element_info[element];
2688
2689   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
2690     ei->description[i] = getFile8Bit(file);
2691   ei->description[MAX_ELEMENT_NAME_LEN] = 0;
2692
2693   ei->properties[EP_BITFIELD_BASE_NR] = getFile32BitBE(file);
2694
2695   ReadUnusedBytesFromFile(file, 4);     /* reserved for more base properties */
2696
2697   ei->num_change_pages = getFile8Bit(file);
2698
2699   chunk_size_expected = LEVEL_CHUNK_CUS4_SIZE(ei->num_change_pages);
2700   if (chunk_size_expected != chunk_size)
2701   {
2702     ReadUnusedBytesFromFile(file, chunk_size - 43);
2703     return chunk_size_expected;
2704   }
2705
2706   ei->ce_value_fixed_initial = getFile16BitBE(file);
2707   ei->ce_value_random_initial = getFile16BitBE(file);
2708   ei->use_last_ce_value = getFile8Bit(file);
2709
2710   ei->use_gfx_element = getFile8Bit(file);
2711   ei->gfx_element_initial = getMappedElement(getFile16BitBE(file));
2712
2713   ei->collect_score_initial = getFile8Bit(file);
2714   ei->collect_count_initial = getFile8Bit(file);
2715
2716   ei->drop_delay_fixed = getFile8Bit(file);
2717   ei->push_delay_fixed = getFile8Bit(file);
2718   ei->drop_delay_random = getFile8Bit(file);
2719   ei->push_delay_random = getFile8Bit(file);
2720   ei->move_delay_fixed = getFile16BitBE(file);
2721   ei->move_delay_random = getFile16BitBE(file);
2722
2723   /* bits 0 - 15 of "move_pattern" ... */
2724   ei->move_pattern = getFile16BitBE(file);
2725   ei->move_direction_initial = getFile8Bit(file);
2726   ei->move_stepsize = getFile8Bit(file);
2727
2728   ei->slippery_type = getFile8Bit(file);
2729
2730   for (y = 0; y < 3; y++)
2731     for (x = 0; x < 3; x++)
2732       ei->content.e[x][y] = getMappedElement(getFile16BitBE(file));
2733
2734   ei->move_enter_element = getMappedElement(getFile16BitBE(file));
2735   ei->move_leave_element = getMappedElement(getFile16BitBE(file));
2736   ei->move_leave_type = getFile8Bit(file);
2737
2738   /* ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible) */
2739   ei->move_pattern |= (getFile16BitBE(file) << 16);
2740
2741   ei->access_direction = getFile8Bit(file);
2742
2743   ei->explosion_delay = getFile8Bit(file);
2744   ei->ignition_delay = getFile8Bit(file);
2745   ei->explosion_type = getFile8Bit(file);
2746
2747   /* some free bytes for future custom property values and padding */
2748   ReadUnusedBytesFromFile(file, 1);
2749
2750   /* ---------- change page property values (48 bytes) --------------------- */
2751
2752   setElementChangePages(ei, ei->num_change_pages);
2753
2754   for (i = 0; i < ei->num_change_pages; i++)
2755   {
2756     struct ElementChangeInfo *change = &ei->change_page[i];
2757     unsigned int event_bits;
2758
2759     /* always start with reliable default values */
2760     setElementChangeInfoToDefaults(change);
2761
2762     /* bits 0 - 31 of "has_event[]" ... */
2763     event_bits = getFile32BitBE(file);
2764     for (j = 0; j < MIN(NUM_CHANGE_EVENTS, 32); j++)
2765       if (event_bits & (1 << j))
2766         change->has_event[j] = TRUE;
2767
2768     change->target_element = getMappedElement(getFile16BitBE(file));
2769
2770     change->delay_fixed = getFile16BitBE(file);
2771     change->delay_random = getFile16BitBE(file);
2772     change->delay_frames = getFile16BitBE(file);
2773
2774     change->initial_trigger_element = getMappedElement(getFile16BitBE(file));
2775
2776     change->explode = getFile8Bit(file);
2777     change->use_target_content = getFile8Bit(file);
2778     change->only_if_complete = getFile8Bit(file);
2779     change->use_random_replace = getFile8Bit(file);
2780
2781     change->random_percentage = getFile8Bit(file);
2782     change->replace_when = getFile8Bit(file);
2783
2784     for (y = 0; y < 3; y++)
2785       for (x = 0; x < 3; x++)
2786         change->target_content.e[x][y]= getMappedElement(getFile16BitBE(file));
2787
2788     change->can_change = getFile8Bit(file);
2789
2790     change->trigger_side = getFile8Bit(file);
2791
2792     change->trigger_player = getFile8Bit(file);
2793     change->trigger_page = getFile8Bit(file);
2794
2795     change->trigger_page = (change->trigger_page == CH_PAGE_ANY_FILE ?
2796                             CH_PAGE_ANY : (1 << change->trigger_page));
2797
2798     change->has_action = getFile8Bit(file);
2799     change->action_type = getFile8Bit(file);
2800     change->action_mode = getFile8Bit(file);
2801     change->action_arg = getFile16BitBE(file);
2802
2803     /* ... bits 32 - 39 of "has_event[]" (not nice, but downward compatible) */
2804     event_bits = getFile8Bit(file);
2805     for (j = 32; j < NUM_CHANGE_EVENTS; j++)
2806       if (event_bits & (1 << (j - 32)))
2807         change->has_event[j] = TRUE;
2808   }
2809
2810   /* mark this custom element as modified */
2811   ei->modified_settings = TRUE;
2812
2813   return chunk_size;
2814 }
2815
2816 static int LoadLevel_GRP1(File *file, int chunk_size, struct LevelInfo *level)
2817 {
2818   struct ElementInfo *ei;
2819   struct ElementGroupInfo *group;
2820   int element;
2821   int i;
2822
2823   element = getMappedElement(getFile16BitBE(file));
2824
2825   if (!IS_GROUP_ELEMENT(element))
2826   {
2827     Error(ERR_WARN, "invalid group element number %d", element);
2828
2829     ReadUnusedBytesFromFile(file, chunk_size - 2);
2830     return chunk_size;
2831   }
2832
2833   ei = &element_info[element];
2834
2835   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
2836     ei->description[i] = getFile8Bit(file);
2837   ei->description[MAX_ELEMENT_NAME_LEN] = 0;
2838
2839   group = element_info[element].group;
2840
2841   group->num_elements = getFile8Bit(file);
2842
2843   ei->use_gfx_element = getFile8Bit(file);
2844   ei->gfx_element_initial = getMappedElement(getFile16BitBE(file));
2845
2846   group->choice_mode = getFile8Bit(file);
2847
2848   /* some free bytes for future values and padding */
2849   ReadUnusedBytesFromFile(file, 3);
2850
2851   for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
2852     group->element[i] = getMappedElement(getFile16BitBE(file));
2853
2854   /* mark this group element as modified */
2855   element_info[element].modified_settings = TRUE;
2856
2857   return chunk_size;
2858 }
2859
2860 static int LoadLevel_MicroChunk(File *file, struct LevelFileConfigInfo *conf,
2861                                 int element, int real_element)
2862 {
2863   int micro_chunk_size = 0;
2864   int conf_type = getFile8Bit(file);
2865   int byte_mask = conf_type & CONF_MASK_BYTES;
2866   boolean element_found = FALSE;
2867   int i;
2868
2869   micro_chunk_size += 1;
2870
2871   if (byte_mask == CONF_MASK_MULTI_BYTES)
2872   {
2873     int num_bytes = getFile16BitBE(file);
2874     byte *buffer = checked_malloc(num_bytes);
2875
2876     ReadBytesFromFile(file, buffer, num_bytes);
2877
2878     for (i = 0; conf[i].data_type != -1; i++)
2879     {
2880       if (conf[i].element == element &&
2881           conf[i].conf_type == conf_type)
2882       {
2883         int data_type = conf[i].data_type;
2884         int num_entities = num_bytes / CONF_ENTITY_NUM_BYTES(data_type);
2885         int max_num_entities = conf[i].max_num_entities;
2886
2887         if (num_entities > max_num_entities)
2888         {
2889           Error(ERR_WARN,
2890                 "truncating number of entities for element %d from %d to %d",
2891                 element, num_entities, max_num_entities);
2892
2893           num_entities = max_num_entities;
2894         }
2895
2896         if (num_entities == 0 && (data_type == TYPE_ELEMENT_LIST ||
2897                                   data_type == TYPE_CONTENT_LIST))
2898         {
2899           /* for element and content lists, zero entities are not allowed */
2900           Error(ERR_WARN, "found empty list of entities for element %d",
2901                 element);
2902
2903           /* do not set "num_entities" here to prevent reading behind buffer */
2904
2905           *(int *)(conf[i].num_entities) = 1;   /* at least one is required */
2906         }
2907         else
2908         {
2909           *(int *)(conf[i].num_entities) = num_entities;
2910         }
2911
2912         element_found = TRUE;
2913
2914         if (data_type == TYPE_STRING)
2915         {
2916           char *string = (char *)(conf[i].value);
2917           int j;
2918
2919           for (j = 0; j < max_num_entities; j++)
2920             string[j] = (j < num_entities ? buffer[j] : '\0');
2921         }
2922         else if (data_type == TYPE_ELEMENT_LIST)
2923         {
2924           int *element_array = (int *)(conf[i].value);
2925           int j;
2926
2927           for (j = 0; j < num_entities; j++)
2928             element_array[j] =
2929               getMappedElement(CONF_ELEMENTS_ELEMENT(buffer, j));
2930         }
2931         else if (data_type == TYPE_CONTENT_LIST)
2932         {
2933           struct Content *content= (struct Content *)(conf[i].value);
2934           int c, x, y;
2935
2936           for (c = 0; c < num_entities; c++)
2937             for (y = 0; y < 3; y++)
2938               for (x = 0; x < 3; x++)
2939                 content[c].e[x][y] =
2940                   getMappedElement(CONF_CONTENTS_ELEMENT(buffer, c, x, y));
2941         }
2942         else
2943           element_found = FALSE;
2944
2945         break;
2946       }
2947     }
2948
2949     checked_free(buffer);
2950
2951     micro_chunk_size += 2 + num_bytes;
2952   }
2953   else          /* constant size configuration data (1, 2 or 4 bytes) */
2954   {
2955     int value = (byte_mask == CONF_MASK_1_BYTE ? getFile8Bit   (file) :
2956                  byte_mask == CONF_MASK_2_BYTE ? getFile16BitBE(file) :
2957                  byte_mask == CONF_MASK_4_BYTE ? getFile32BitBE(file) : 0);
2958
2959     for (i = 0; conf[i].data_type != -1; i++)
2960     {
2961       if (conf[i].element == element &&
2962           conf[i].conf_type == conf_type)
2963       {
2964         int data_type = conf[i].data_type;
2965
2966         if (data_type == TYPE_ELEMENT)
2967           value = getMappedElement(value);
2968
2969         if (data_type == TYPE_BOOLEAN)
2970           *(boolean *)(conf[i].value) = value;
2971         else
2972           *(int *)    (conf[i].value) = value;
2973
2974         element_found = TRUE;
2975
2976         break;
2977       }
2978     }
2979
2980     micro_chunk_size += CONF_VALUE_NUM_BYTES(byte_mask);
2981   }
2982
2983   if (!element_found)
2984   {
2985     char *error_conf_chunk_bytes =
2986       (byte_mask == CONF_MASK_1_BYTE ? "CONF_VALUE_8_BIT" :
2987        byte_mask == CONF_MASK_2_BYTE ? "CONF_VALUE_16_BIT" :
2988        byte_mask == CONF_MASK_4_BYTE ? "CONF_VALUE_32_BIT" :"CONF_VALUE_BYTES");
2989     int error_conf_chunk_token = conf_type & CONF_MASK_TOKEN;
2990     int error_element = real_element;
2991
2992     Error(ERR_WARN, "cannot load micro chunk '%s(%d)' value for element %d ['%s']",
2993           error_conf_chunk_bytes, error_conf_chunk_token,
2994           error_element, EL_NAME(error_element));
2995   }
2996
2997   return micro_chunk_size;
2998 }
2999
3000 static int LoadLevel_INFO(File *file, int chunk_size, struct LevelInfo *level)
3001 {
3002   int real_chunk_size = 0;
3003
3004   li = *level;          /* copy level data into temporary buffer */
3005
3006   while (!checkEndOfFile(file))
3007   {
3008     real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_INFO, -1, -1);
3009
3010     if (real_chunk_size >= chunk_size)
3011       break;
3012   }
3013
3014   *level = li;          /* copy temporary buffer back to level data */
3015
3016   return real_chunk_size;
3017 }
3018
3019 static int LoadLevel_CONF(File *file, int chunk_size, struct LevelInfo *level)
3020 {
3021   int real_chunk_size = 0;
3022
3023   li = *level;          /* copy level data into temporary buffer */
3024
3025   while (!checkEndOfFile(file))
3026   {
3027     int element = getMappedElement(getFile16BitBE(file));
3028
3029     real_chunk_size += 2;
3030     real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_CONF,
3031                                             element, element);
3032     if (real_chunk_size >= chunk_size)
3033       break;
3034   }
3035
3036   *level = li;          /* copy temporary buffer back to level data */
3037
3038   return real_chunk_size;
3039 }
3040
3041 static int LoadLevel_ELEM(File *file, int chunk_size, struct LevelInfo *level)
3042 {
3043   int real_chunk_size = 0;
3044
3045   li = *level;          /* copy level data into temporary buffer */
3046
3047   while (!checkEndOfFile(file))
3048   {
3049     int element = getMappedElement(getFile16BitBE(file));
3050
3051     real_chunk_size += 2;
3052     real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_ELEM,
3053                                             element, element);
3054     if (real_chunk_size >= chunk_size)
3055       break;
3056   }
3057
3058   *level = li;          /* copy temporary buffer back to level data */
3059
3060   return real_chunk_size;
3061 }
3062
3063 static int LoadLevel_NOTE(File *file, int chunk_size, struct LevelInfo *level)
3064 {
3065   int element = getMappedElement(getFile16BitBE(file));
3066   int envelope_nr = element - EL_ENVELOPE_1;
3067   int real_chunk_size = 2;
3068
3069   xx_envelope = level->envelope[envelope_nr];   /* copy into temporary buffer */
3070
3071   while (!checkEndOfFile(file))
3072   {
3073     real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_NOTE,
3074                                             -1, element);
3075
3076     if (real_chunk_size >= chunk_size)
3077       break;
3078   }
3079
3080   level->envelope[envelope_nr] = xx_envelope;   /* copy from temporary buffer */
3081
3082   return real_chunk_size;
3083 }
3084
3085 static int LoadLevel_CUSX(File *file, int chunk_size, struct LevelInfo *level)
3086 {
3087   int element = getMappedElement(getFile16BitBE(file));
3088   int real_chunk_size = 2;
3089   struct ElementInfo *ei = &element_info[element];
3090   int i;
3091
3092   xx_ei = *ei;          /* copy element data into temporary buffer */
3093
3094   xx_ei.num_change_pages = -1;
3095
3096   while (!checkEndOfFile(file))
3097   {
3098     real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_CUSX_base,
3099                                             -1, element);
3100     if (xx_ei.num_change_pages != -1)
3101       break;
3102
3103     if (real_chunk_size >= chunk_size)
3104       break;
3105   }
3106
3107   *ei = xx_ei;
3108
3109   if (ei->num_change_pages == -1)
3110   {
3111     Error(ERR_WARN, "LoadLevel_CUSX(): missing 'num_change_pages' for '%s'",
3112           EL_NAME(element));
3113
3114     ei->num_change_pages = 1;
3115
3116     setElementChangePages(ei, 1);
3117     setElementChangeInfoToDefaults(ei->change);
3118
3119     return real_chunk_size;
3120   }
3121
3122   /* initialize number of change pages stored for this custom element */
3123   setElementChangePages(ei, ei->num_change_pages);
3124   for (i = 0; i < ei->num_change_pages; i++)
3125     setElementChangeInfoToDefaults(&ei->change_page[i]);
3126
3127   /* start with reading properties for the first change page */
3128   xx_current_change_page = 0;
3129
3130   while (!checkEndOfFile(file))
3131   {
3132     struct ElementChangeInfo *change = &ei->change_page[xx_current_change_page];
3133
3134     xx_change = *change;        /* copy change data into temporary buffer */
3135
3136     resetEventBits();           /* reset bits; change page might have changed */
3137
3138     real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_CUSX_change,
3139                                             -1, element);
3140
3141     *change = xx_change;
3142
3143     setEventFlagsFromEventBits(change);
3144
3145     if (real_chunk_size >= chunk_size)
3146       break;
3147   }
3148
3149   return real_chunk_size;
3150 }
3151
3152 static int LoadLevel_GRPX(File *file, int chunk_size, struct LevelInfo *level)
3153 {
3154   int element = getMappedElement(getFile16BitBE(file));
3155   int real_chunk_size = 2;
3156   struct ElementInfo *ei = &element_info[element];
3157   struct ElementGroupInfo *group = ei->group;
3158
3159   xx_ei = *ei;          /* copy element data into temporary buffer */
3160   xx_group = *group;    /* copy group data into temporary buffer */
3161
3162   while (!checkEndOfFile(file))
3163   {
3164     real_chunk_size += LoadLevel_MicroChunk(file, chunk_config_GRPX,
3165                                             -1, element);
3166
3167     if (real_chunk_size >= chunk_size)
3168       break;
3169   }
3170
3171   *ei = xx_ei;
3172   *group = xx_group;
3173
3174   return real_chunk_size;
3175 }
3176
3177 static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
3178                                       struct LevelFileInfo *level_file_info,
3179                                       boolean level_info_only)
3180 {
3181   char *filename = level_file_info->filename;
3182   char cookie[MAX_LINE_LEN];
3183   char chunk_name[CHUNK_ID_LEN + 1];
3184   int chunk_size;
3185   File *file;
3186
3187   if (!(file = openFile(filename, MODE_READ)))
3188   {
3189     level->no_valid_file = TRUE;
3190     level->no_level_file = TRUE;
3191
3192     if (level_info_only)
3193       return;
3194
3195     Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
3196
3197     if (!setup.editor.use_template_for_new_levels)
3198       return;
3199
3200     /* if level file not found, try to initialize level data from template */
3201     filename = getGlobalLevelTemplateFilename();
3202
3203     if (!(file = openFile(filename, MODE_READ)))
3204       return;
3205
3206     /* default: for empty levels, use level template for custom elements */
3207     level->use_custom_template = TRUE;
3208
3209     level->no_valid_file = FALSE;
3210   }
3211
3212   getFileChunkBE(file, chunk_name, NULL);
3213   if (strEqual(chunk_name, "RND1"))
3214   {
3215     getFile32BitBE(file);               /* not used */
3216
3217     getFileChunkBE(file, chunk_name, NULL);
3218     if (!strEqual(chunk_name, "CAVE"))
3219     {
3220       level->no_valid_file = TRUE;
3221
3222       Error(ERR_WARN, "unknown format of level file '%s'", filename);
3223
3224       closeFile(file);
3225
3226       return;
3227     }
3228   }
3229   else  /* check for pre-2.0 file format with cookie string */
3230   {
3231     strcpy(cookie, chunk_name);
3232     if (getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4) == NULL)
3233       cookie[4] = '\0';
3234     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
3235       cookie[strlen(cookie) - 1] = '\0';
3236
3237     if (!checkCookieString(cookie, LEVEL_COOKIE_TMPL))
3238     {
3239       level->no_valid_file = TRUE;
3240
3241       Error(ERR_WARN, "unknown format of level file '%s'", filename);
3242
3243       closeFile(file);
3244
3245       return;
3246     }
3247
3248     if ((level->file_version = getFileVersionFromCookieString(cookie)) == -1)
3249     {
3250       level->no_valid_file = TRUE;
3251
3252       Error(ERR_WARN, "unsupported version of level file '%s'", filename);
3253
3254       closeFile(file);
3255
3256       return;
3257     }
3258
3259     /* pre-2.0 level files have no game version, so use file version here */
3260     level->game_version = level->file_version;
3261   }
3262
3263   if (level->file_version < FILE_VERSION_1_2)
3264   {
3265     /* level files from versions before 1.2.0 without chunk structure */
3266     LoadLevel_HEAD(file, LEVEL_CHUNK_HEAD_SIZE,         level);
3267     LoadLevel_BODY(file, level->fieldx * level->fieldy, level);
3268   }
3269   else
3270   {
3271     static struct
3272     {
3273       char *name;
3274       int size;
3275       int (*loader)(File *, int, struct LevelInfo *);
3276     }
3277     chunk_info[] =
3278     {
3279       { "VERS", LEVEL_CHUNK_VERS_SIZE,  LoadLevel_VERS },
3280       { "DATE", LEVEL_CHUNK_DATE_SIZE,  LoadLevel_DATE },
3281       { "HEAD", LEVEL_CHUNK_HEAD_SIZE,  LoadLevel_HEAD },
3282       { "NAME", LEVEL_CHUNK_NAME_SIZE,  LoadLevel_NAME },
3283       { "AUTH", LEVEL_CHUNK_AUTH_SIZE,  LoadLevel_AUTH },
3284       { "INFO", -1,                     LoadLevel_INFO },
3285       { "BODY", -1,                     LoadLevel_BODY },
3286       { "CONT", -1,                     LoadLevel_CONT },
3287       { "CNT2", LEVEL_CHUNK_CNT2_SIZE,  LoadLevel_CNT2 },
3288       { "CNT3", -1,                     LoadLevel_CNT3 },
3289       { "CUS1", -1,                     LoadLevel_CUS1 },
3290       { "CUS2", -1,                     LoadLevel_CUS2 },
3291       { "CUS3", -1,                     LoadLevel_CUS3 },
3292       { "CUS4", -1,                     LoadLevel_CUS4 },
3293       { "GRP1", -1,                     LoadLevel_GRP1 },
3294       { "CONF", -1,                     LoadLevel_CONF },
3295       { "ELEM", -1,                     LoadLevel_ELEM },
3296       { "NOTE", -1,                     LoadLevel_NOTE },
3297       { "CUSX", -1,                     LoadLevel_CUSX },
3298       { "GRPX", -1,                     LoadLevel_GRPX },
3299
3300       {  NULL,  0,                      NULL }
3301     };
3302
3303     while (getFileChunkBE(file, chunk_name, &chunk_size))
3304     {
3305       int i = 0;
3306
3307       while (chunk_info[i].name != NULL &&
3308              !strEqual(chunk_name, chunk_info[i].name))
3309         i++;
3310
3311       if (chunk_info[i].name == NULL)
3312       {
3313         Error(ERR_WARN, "unknown chunk '%s' in level file '%s'",
3314               chunk_name, filename);
3315         ReadUnusedBytesFromFile(file, chunk_size);
3316       }
3317       else if (chunk_info[i].size != -1 &&
3318                chunk_info[i].size != chunk_size)
3319       {
3320         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
3321               chunk_size, chunk_name, filename);
3322         ReadUnusedBytesFromFile(file, chunk_size);
3323       }
3324       else
3325       {
3326         /* call function to load this level chunk */
3327         int chunk_size_expected =
3328           (chunk_info[i].loader)(file, chunk_size, level);
3329
3330         /* the size of some chunks cannot be checked before reading other
3331            chunks first (like "HEAD" and "BODY") that contain some header
3332            information, so check them here */
3333         if (chunk_size_expected != chunk_size)
3334         {
3335           Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
3336                 chunk_size, chunk_name, filename);
3337         }
3338       }
3339     }
3340   }
3341
3342   closeFile(file);
3343 }
3344
3345
3346 /* ------------------------------------------------------------------------- */
3347 /* functions for loading EM level                                            */
3348 /* ------------------------------------------------------------------------- */
3349
3350 void CopyNativeLevel_RND_to_EM(struct LevelInfo *level)
3351 {
3352   static int ball_xy[8][2] =
3353   {
3354     { 0, 0 },
3355     { 1, 0 },
3356     { 2, 0 },
3357     { 0, 1 },
3358     { 2, 1 },
3359     { 0, 2 },
3360     { 1, 2 },
3361     { 2, 2 },
3362   };
3363   struct LevelInfo_EM *level_em = level->native_em_level;
3364   struct LEVEL *lev = level_em->lev;
3365   struct PLAYER **ply = level_em->ply;
3366   int i, j, x, y;
3367
3368   lev->width  = MIN(level->fieldx, EM_MAX_CAVE_WIDTH);
3369   lev->height = MIN(level->fieldy, EM_MAX_CAVE_HEIGHT);
3370
3371   lev->time_seconds     = level->time;
3372   lev->required_initial = level->gems_needed;
3373
3374   lev->emerald_score    = level->score[SC_EMERALD];
3375   lev->diamond_score    = level->score[SC_DIAMOND];
3376   lev->alien_score      = level->score[SC_ROBOT];
3377   lev->tank_score       = level->score[SC_SPACESHIP];
3378   lev->bug_score        = level->score[SC_BUG];
3379   lev->eater_score      = level->score[SC_YAMYAM];
3380   lev->nut_score        = level->score[SC_NUT];
3381   lev->dynamite_score   = level->score[SC_DYNAMITE];
3382   lev->key_score        = level->score[SC_KEY];
3383   lev->exit_score       = level->score[SC_TIME_BONUS];
3384
3385   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
3386     for (y = 0; y < 3; y++)
3387       for (x = 0; x < 3; x++)
3388         lev->eater_array[i][y * 3 + x] =
3389           map_element_RND_to_EM(level->yamyam_content[i].e[x][y]);
3390
3391   lev->amoeba_time              = level->amoeba_speed;
3392   lev->wonderwall_time_initial  = level->time_magic_wall;
3393   lev->wheel_time               = level->time_wheel;
3394
3395   lev->android_move_time        = level->android_move_time;
3396   lev->android_clone_time       = level->android_clone_time;
3397   lev->ball_random              = level->ball_random;
3398   lev->ball_state_initial       = level->ball_state_initial;
3399   lev->ball_time                = level->ball_time;
3400   lev->num_ball_arrays          = level->num_ball_contents;
3401
3402   lev->lenses_score             = level->lenses_score;
3403   lev->magnify_score            = level->magnify_score;
3404   lev->slurp_score              = level->slurp_score;
3405
3406   lev->lenses_time              = level->lenses_time;
3407   lev->magnify_time             = level->magnify_time;
3408
3409   lev->wind_direction_initial =
3410     map_direction_RND_to_EM(level->wind_direction_initial);
3411   lev->wind_cnt_initial = (level->wind_direction_initial != MV_NONE ?
3412                            lev->wind_time : 0);
3413
3414   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
3415     for (j = 0; j < 8; j++)
3416       lev->ball_array[i][j] =
3417         map_element_RND_to_EM(level->
3418                               ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]]);
3419
3420   map_android_clone_elements_RND_to_EM(level);
3421
3422   /* first fill the complete playfield with the default border element */
3423   for (y = 0; y < EM_MAX_CAVE_HEIGHT; y++)
3424     for (x = 0; x < EM_MAX_CAVE_WIDTH; x++)
3425       level_em->cave[x][y] = ZBORDER;
3426
3427   if (BorderElement == EL_STEELWALL)
3428   {
3429     for (y = 0; y < lev->height + 2; y++)
3430       for (x = 0; x < lev->width + 2; x++)
3431         level_em->cave[x + 1][y + 1] = map_element_RND_to_EM(EL_STEELWALL);
3432   }
3433
3434   /* then copy the real level contents from level file into the playfield */
3435   for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
3436   {
3437     int new_element = map_element_RND_to_EM(level->field[x][y]);
3438     int offset = (BorderElement == EL_STEELWALL ? 1 : 0);
3439     int xx = x + 1 + offset;
3440     int yy = y + 1 + offset;
3441
3442     if (level->field[x][y] == EL_AMOEBA_DEAD)
3443       new_element = map_element_RND_to_EM(EL_AMOEBA_WET);
3444
3445     level_em->cave[xx][yy] = new_element;
3446   }
3447
3448   for (i = 0; i < MAX_PLAYERS; i++)
3449   {
3450     ply[i]->x_initial = 0;
3451     ply[i]->y_initial = 0;
3452   }
3453
3454   /* initialize player positions and delete players from the playfield */
3455   for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
3456   {
3457     if (ELEM_IS_PLAYER(level->field[x][y]))
3458     {
3459       int player_nr = GET_PLAYER_NR(level->field[x][y]);
3460       int offset = (BorderElement == EL_STEELWALL ? 1 : 0);
3461       int xx = x + 1 + offset;
3462       int yy = y + 1 + offset;
3463
3464       ply[player_nr]->x_initial = xx;
3465       ply[player_nr]->y_initial = yy;
3466
3467       level_em->cave[xx][yy] = map_element_RND_to_EM(EL_EMPTY);
3468     }
3469   }
3470
3471   if (BorderElement == EL_STEELWALL)
3472   {
3473     lev->width  += 2;
3474     lev->height += 2;
3475   }
3476 }
3477
3478 void CopyNativeLevel_EM_to_RND(struct LevelInfo *level)
3479 {
3480   static int ball_xy[8][2] =
3481   {
3482     { 0, 0 },
3483     { 1, 0 },
3484     { 2, 0 },
3485     { 0, 1 },
3486     { 2, 1 },
3487     { 0, 2 },
3488     { 1, 2 },
3489     { 2, 2 },
3490   };
3491   struct LevelInfo_EM *level_em = level->native_em_level;
3492   struct LEVEL *lev = level_em->lev;
3493   struct PLAYER **ply = level_em->ply;
3494   int i, j, x, y;
3495
3496   level->fieldx = MIN(lev->width,  MAX_LEV_FIELDX);
3497   level->fieldy = MIN(lev->height, MAX_LEV_FIELDY);
3498
3499   level->time        = lev->time_seconds;
3500   level->gems_needed = lev->required_initial;
3501
3502   sprintf(level->name, "Level %d", level->file_info.nr);
3503
3504   level->score[SC_EMERALD]      = lev->emerald_score;
3505   level->score[SC_DIAMOND]      = lev->diamond_score;
3506   level->score[SC_ROBOT]        = lev->alien_score;
3507   level->score[SC_SPACESHIP]    = lev->tank_score;
3508   level->score[SC_BUG]          = lev->bug_score;
3509   level->score[SC_YAMYAM]       = lev->eater_score;
3510   level->score[SC_NUT]          = lev->nut_score;
3511   level->score[SC_DYNAMITE]     = lev->dynamite_score;
3512   level->score[SC_KEY]          = lev->key_score;
3513   level->score[SC_TIME_BONUS]   = lev->exit_score;
3514
3515   level->num_yamyam_contents = MAX_ELEMENT_CONTENTS;
3516
3517   for (i = 0; i < level->num_yamyam_contents; i++)
3518     for (y = 0; y < 3; y++)
3519       for (x = 0; x < 3; x++)
3520         level->yamyam_content[i].e[x][y] =
3521           map_element_EM_to_RND(lev->eater_array[i][y * 3 + x]);
3522
3523   level->amoeba_speed           = lev->amoeba_time;
3524   level->time_magic_wall        = lev->wonderwall_time_initial;
3525   level->time_wheel             = lev->wheel_time;
3526
3527   level->android_move_time      = lev->android_move_time;
3528   level->android_clone_time     = lev->android_clone_time;
3529   level->ball_random            = lev->ball_random;
3530   level->ball_state_initial     = lev->ball_state_initial;
3531   level->ball_time              = lev->ball_time;
3532   level->num_ball_contents      = lev->num_ball_arrays;
3533
3534   level->lenses_score           = lev->lenses_score;
3535   level->magnify_score          = lev->magnify_score;
3536   level->slurp_score            = lev->slurp_score;
3537
3538   level->lenses_time            = lev->lenses_time;
3539   level->magnify_time           = lev->magnify_time;
3540
3541   level->wind_direction_initial =
3542     map_direction_EM_to_RND(lev->wind_direction_initial);
3543
3544   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
3545     for (j = 0; j < 8; j++)
3546       level->ball_content[i].e[ball_xy[j][0]][ball_xy[j][1]] =
3547         map_element_EM_to_RND(lev->ball_array[i][j]);
3548
3549   map_android_clone_elements_EM_to_RND(level);
3550
3551   /* convert the playfield (some elements need special treatment) */
3552   for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
3553   {
3554     int new_element = map_element_EM_to_RND(level_em->cave[x + 1][y + 1]);
3555
3556     if (new_element == EL_AMOEBA_WET && level->amoeba_speed == 0)
3557       new_element = EL_AMOEBA_DEAD;
3558
3559     level->field[x][y] = new_element;
3560   }
3561
3562   for (i = 0; i < MAX_PLAYERS; i++)
3563   {
3564     /* in case of all players set to the same field, use the first player */
3565     int nr = MAX_PLAYERS - i - 1;
3566     int jx = ply[nr]->x_initial - 1;
3567     int jy = ply[nr]->y_initial - 1;
3568
3569     if (jx != -1 && jy != -1)
3570       level->field[jx][jy] = EL_PLAYER_1 + nr;
3571   }
3572 }
3573
3574
3575 /* ------------------------------------------------------------------------- */
3576 /* functions for loading SP level                                            */
3577 /* ------------------------------------------------------------------------- */
3578
3579 void CopyNativeLevel_RND_to_SP(struct LevelInfo *level)
3580 {
3581   struct LevelInfo_SP *level_sp = level->native_sp_level;
3582   LevelInfoType *header = &level_sp->header;
3583   int i, x, y;
3584
3585   level_sp->width  = level->fieldx;
3586   level_sp->height = level->fieldy;
3587
3588   for (x = 0; x < level->fieldx; x++)
3589     for (y = 0; y < level->fieldy; y++)
3590       level_sp->playfield[x][y] = map_element_RND_to_SP(level->field[x][y]);
3591
3592   header->InitialGravity = (level->initial_player_gravity[0] ? 1 : 0);
3593
3594   for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
3595     header->LevelTitle[i] = level->name[i];
3596   /* !!! NO STRING TERMINATION IN SUPAPLEX VB CODE YET -- FIX THIS !!! */
3597
3598   header->InfotronsNeeded = level->gems_needed;
3599
3600   header->SpecialPortCount = 0;
3601
3602   for (x = 0; x < level->fieldx; x++) for (y = 0; y < level->fieldy; y++)
3603   {
3604     boolean gravity_port_found = FALSE;
3605     boolean gravity_port_valid = FALSE;
3606     int gravity_port_flag;
3607     int gravity_port_base_element;
3608     int element = level->field[x][y];
3609
3610     if (element >= EL_SP_GRAVITY_ON_PORT_RIGHT &&
3611         element <= EL_SP_GRAVITY_ON_PORT_UP)
3612     {
3613       gravity_port_found = TRUE;
3614       gravity_port_valid = TRUE;
3615       gravity_port_flag = 1;
3616       gravity_port_base_element = EL_SP_GRAVITY_ON_PORT_RIGHT;
3617     }
3618     else if (element >= EL_SP_GRAVITY_OFF_PORT_RIGHT &&
3619              element <= EL_SP_GRAVITY_OFF_PORT_UP)
3620     {
3621       gravity_port_found = TRUE;
3622       gravity_port_valid = TRUE;
3623       gravity_port_flag = 0;
3624       gravity_port_base_element = EL_SP_GRAVITY_OFF_PORT_RIGHT;
3625     }
3626     else if (element >= EL_SP_GRAVITY_PORT_RIGHT &&
3627              element <= EL_SP_GRAVITY_PORT_UP)
3628     {
3629       /* change R'n'D style gravity inverting special port to normal port
3630          (there are no gravity inverting ports in native Supaplex engine) */
3631
3632       gravity_port_found = TRUE;
3633       gravity_port_valid = FALSE;
3634       gravity_port_base_element = EL_SP_GRAVITY_PORT_RIGHT;
3635     }
3636
3637     if (gravity_port_found)
3638     {
3639       if (gravity_port_valid &&
3640           header->SpecialPortCount < SP_MAX_SPECIAL_PORTS)
3641       {
3642         SpecialPortType *port = &header->SpecialPort[header->SpecialPortCount];
3643
3644         port->PortLocation = (y * level->fieldx + x) * 2;
3645         port->Gravity = gravity_port_flag;
3646
3647         element += EL_SP_GRAVITY_PORT_RIGHT - gravity_port_base_element;
3648
3649         header->SpecialPortCount++;
3650       }
3651       else
3652       {
3653         /* change special gravity port to normal port */
3654
3655         element += EL_SP_PORT_RIGHT - gravity_port_base_element;
3656       }
3657
3658       level_sp->playfield[x][y] = element - EL_SP_START;
3659     }
3660   }
3661 }
3662
3663 void CopyNativeLevel_SP_to_RND(struct LevelInfo *level)
3664 {
3665   struct LevelInfo_SP *level_sp = level->native_sp_level;
3666   LevelInfoType *header = &level_sp->header;
3667   int i, x, y;
3668
3669   level->fieldx = level_sp->width;
3670   level->fieldy = level_sp->height;
3671
3672   for (x = 0; x < level->fieldx; x++)
3673   {
3674     for (y = 0; y < level->fieldy; y++)
3675     {
3676       int element_old = level_sp->playfield[x][y];
3677       int element_new = getMappedElement(map_element_SP_to_RND(element_old));
3678
3679       if (element_new == EL_UNKNOWN)
3680         Error(ERR_WARN, "invalid element %d at position %d, %d",
3681               element_old, x, y);
3682
3683       level->field[x][y] = element_new;
3684     }
3685   }
3686
3687   for (i = 0; i < MAX_PLAYERS; i++)
3688     level->initial_player_gravity[i] =
3689       (header->InitialGravity == 1 ? TRUE : FALSE);
3690
3691   for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
3692     level->name[i] = header->LevelTitle[i];
3693   level->name[SP_LEVEL_NAME_LEN] = '\0';
3694
3695   level->gems_needed = header->InfotronsNeeded;
3696
3697   for (i = 0; i < header->SpecialPortCount; i++)
3698   {
3699     SpecialPortType *port = &header->SpecialPort[i];
3700     int port_location = port->PortLocation;
3701     int gravity = port->Gravity;
3702     int port_x, port_y, port_element;
3703
3704     port_x = (port_location / 2) % level->fieldx;
3705     port_y = (port_location / 2) / level->fieldx;
3706
3707     if (port_x < 0 || port_x >= level->fieldx ||
3708         port_y < 0 || port_y >= level->fieldy)
3709     {
3710       Error(ERR_WARN, "special port position (%d, %d) out of bounds",
3711             port_x, port_y);
3712
3713       continue;
3714     }
3715
3716     port_element = level->field[port_x][port_y];
3717
3718     if (port_element < EL_SP_GRAVITY_PORT_RIGHT ||
3719         port_element > EL_SP_GRAVITY_PORT_UP)
3720     {
3721       Error(ERR_WARN, "no special port at position (%d, %d)", port_x, port_y);
3722
3723       continue;
3724     }
3725
3726     /* change previous (wrong) gravity inverting special port to either
3727        gravity enabling special port or gravity disabling special port */
3728     level->field[port_x][port_y] +=
3729       (gravity == 1 ? EL_SP_GRAVITY_ON_PORT_RIGHT :
3730        EL_SP_GRAVITY_OFF_PORT_RIGHT) - EL_SP_GRAVITY_PORT_RIGHT;
3731   }
3732
3733   /* change special gravity ports without database entries to normal ports */
3734   for (x = 0; x < level->fieldx; x++)
3735     for (y = 0; y < level->fieldy; y++)
3736       if (level->field[x][y] >= EL_SP_GRAVITY_PORT_RIGHT &&
3737           level->field[x][y] <= EL_SP_GRAVITY_PORT_UP)
3738         level->field[x][y] += EL_SP_PORT_RIGHT - EL_SP_GRAVITY_PORT_RIGHT;
3739
3740   level->time = 0;                      /* no time limit */
3741   level->amoeba_speed = 0;
3742   level->time_magic_wall = 0;
3743   level->time_wheel = 0;
3744   level->amoeba_content = EL_EMPTY;
3745
3746 #if 1
3747   /* original Supaplex does not use score values -- use default values */
3748 #else
3749   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
3750     level->score[i] = 0;
3751 #endif
3752
3753   /* there are no yamyams in supaplex levels */
3754   for (i = 0; i < level->num_yamyam_contents; i++)
3755     for (x = 0; x < 3; x++)
3756       for (y = 0; y < 3; y++)
3757         level->yamyam_content[i].e[x][y] = EL_EMPTY;
3758 }
3759
3760 static void CopyNativeTape_RND_to_SP(struct LevelInfo *level)
3761 {
3762   struct LevelInfo_SP *level_sp = level->native_sp_level;
3763   struct DemoInfo_SP *demo = &level_sp->demo;
3764   int i, j;
3765
3766   /* always start with reliable default values */
3767   demo->is_available = FALSE;
3768   demo->length = 0;
3769
3770   if (TAPE_IS_EMPTY(tape))
3771     return;
3772
3773   demo->level_nr = tape.level_nr;       /* (currently not used) */
3774
3775   level_sp->header.DemoRandomSeed = tape.random_seed;
3776
3777   demo->length = 0;
3778
3779   for (i = 0; i < tape.length; i++)
3780   {
3781     int demo_action = map_key_RND_to_SP(tape.pos[i].action[0]);
3782     int demo_repeat = tape.pos[i].delay;
3783     int demo_entries = (demo_repeat + 15) / 16;
3784
3785     if (demo->length + demo_entries >= SP_MAX_TAPE_LEN)
3786     {
3787       Error(ERR_WARN, "tape truncated: size exceeds maximum SP demo size %d",
3788             SP_MAX_TAPE_LEN);
3789
3790       break;
3791     }
3792
3793     for (j = 0; j < demo_repeat / 16; j++)
3794       demo->data[demo->length++] = 0xf0 | demo_action;
3795
3796     if (demo_repeat % 16)
3797       demo->data[demo->length++] = ((demo_repeat % 16 - 1) << 4) | demo_action;
3798   }
3799
3800   demo->is_available = TRUE;
3801 }
3802
3803 static void setTapeInfoToDefaults();
3804
3805 static void CopyNativeTape_SP_to_RND(struct LevelInfo *level)
3806 {
3807   struct LevelInfo_SP *level_sp = level->native_sp_level;
3808   struct DemoInfo_SP *demo = &level_sp->demo;
3809   char *filename = level->file_info.filename;
3810   int i;
3811
3812   /* always start with reliable default values */
3813   setTapeInfoToDefaults();
3814
3815   if (!demo->is_available)
3816     return;
3817
3818   tape.level_nr = demo->level_nr;       /* (currently not used) */
3819   tape.random_seed = level_sp->header.DemoRandomSeed;
3820
3821   TapeSetDateFromEpochSeconds(getFileTimestampEpochSeconds(filename));
3822
3823   tape.length = 0;
3824   tape.pos[tape.length].delay = 0;
3825
3826   for (i = 0; i < demo->length; i++)
3827   {
3828     int demo_action = demo->data[i] & 0x0f;
3829     int demo_repeat = (demo->data[i] & 0xf0) >> 4;
3830     int tape_action = map_key_SP_to_RND(demo_action);
3831     int tape_repeat = demo_repeat + 1;
3832     int tape_entries = 1;       // one new tape entry may be added
3833
3834     if (tape.length + tape_entries >= MAX_TAPE_LEN)
3835     {
3836       Error(ERR_WARN, "SP demo truncated: size exceeds maximum tape size %d",
3837             MAX_TAPE_LEN);
3838
3839       break;
3840     }
3841
3842     if (tape.pos[tape.length].delay > 0)        /* already stored action */
3843     {
3844       if (tape.pos[tape.length].action[0] != tape_action ||
3845           tape.pos[tape.length].delay + tape_repeat >= 256)
3846       {
3847         tape.length++;
3848         tape.pos[tape.length].delay = 0;
3849       }
3850       else
3851       {
3852         tape.pos[tape.length].delay += tape_repeat;
3853       }
3854     }
3855
3856     if (tape.pos[tape.length].delay == 0)       /* store new action */
3857     {
3858       tape.pos[tape.length].action[0] = tape_action;
3859       tape.pos[tape.length].delay = tape_repeat;
3860     }
3861   }
3862
3863   tape.length++;
3864
3865   tape.length_frames  = GetTapeLengthFrames();
3866   tape.length_seconds = GetTapeLengthSeconds();
3867 }
3868
3869
3870 /* ------------------------------------------------------------------------- */
3871 /* functions for loading DC level                                            */
3872 /* ------------------------------------------------------------------------- */
3873
3874 #define DC_LEVEL_HEADER_SIZE            344
3875
3876 unsigned short getDecodedWord_DC(unsigned short data_encoded, boolean init)
3877 {
3878   static int last_data_encoded;
3879   static int offset1;
3880   static int offset2;
3881   int diff;
3882   int diff_hi, diff_lo;
3883   int data_hi, data_lo;
3884   unsigned short data_decoded;
3885
3886   if (init)
3887   {
3888     last_data_encoded = 0;
3889     offset1 = -1;
3890     offset2 = 0;
3891
3892     return 0;
3893   }
3894
3895   diff = data_encoded - last_data_encoded;
3896   diff_hi = diff & ~0xff;
3897   diff_lo = diff &  0xff;
3898
3899   offset2 += diff_lo;
3900
3901   data_hi = diff_hi - (offset1 << 8) + (offset2 & 0xff00);
3902   data_lo = (diff_lo + (data_hi >> 16)) & 0x00ff;
3903   data_hi = data_hi & 0xff00;
3904
3905   data_decoded = data_hi | data_lo;
3906
3907   last_data_encoded = data_encoded;
3908
3909   offset1 = (offset1 + 1) % 31;
3910   offset2 = offset2 & 0xff;
3911
3912   return data_decoded;
3913 }
3914
3915 int getMappedElement_DC(int element)
3916 {
3917   switch (element)
3918   {
3919     case 0x0000:
3920       element = EL_ROCK;
3921       break;
3922
3923       /* 0x0117 - 0x036e: (?) */
3924       /* EL_DIAMOND */
3925
3926       /* 0x042d - 0x0684: (?) */
3927       /* EL_EMERALD */
3928
3929     case 0x06f1:
3930       element = EL_NUT;
3931       break;
3932
3933     case 0x074c:
3934       element = EL_BOMB;
3935       break;
3936
3937     case 0x07a4:
3938       element = EL_PEARL;
3939       break;
3940
3941     case 0x0823:
3942       element = EL_CRYSTAL;
3943       break;
3944
3945     case 0x0e77:        /* quicksand (boulder) */
3946       element = EL_QUICKSAND_FAST_FULL;
3947       break;
3948
3949     case 0x0e99:        /* slow quicksand (boulder) */
3950       element = EL_QUICKSAND_FULL;
3951       break;
3952
3953     case 0x0ed2:
3954       element = EL_EM_EXIT_OPEN;
3955       break;
3956
3957     case 0x0ee3:
3958       element = EL_EM_EXIT_CLOSED;
3959       break;
3960
3961     case 0x0eeb:
3962       element = EL_EM_STEEL_EXIT_OPEN;
3963       break;
3964
3965     case 0x0efc:
3966       element = EL_EM_STEEL_EXIT_CLOSED;
3967       break;
3968
3969     case 0x0f4f:        /* dynamite (lit 1) */
3970       element = EL_EM_DYNAMITE_ACTIVE;
3971       break;
3972
3973     case 0x0f57:        /* dynamite (lit 2) */
3974       element = EL_EM_DYNAMITE_ACTIVE;
3975       break;
3976
3977     case 0x0f5f:        /* dynamite (lit 3) */
3978       element = EL_EM_DYNAMITE_ACTIVE;
3979       break;
3980
3981     case 0x0f67:        /* dynamite (lit 4) */
3982       element = EL_EM_DYNAMITE_ACTIVE;
3983       break;
3984
3985     case 0x0f81:
3986     case 0x0f82:
3987     case 0x0f83:
3988     case 0x0f84:
3989       element = EL_AMOEBA_WET;
3990       break;
3991
3992     case 0x0f85:
3993       element = EL_AMOEBA_DROP;
3994       break;
3995
3996     case 0x0fb9:
3997       element = EL_DC_MAGIC_WALL;
3998       break;
3999
4000     case 0x0fd0:
4001       element = EL_SPACESHIP_UP;
4002       break;
4003
4004     case 0x0fd9:
4005       element = EL_SPACESHIP_DOWN;
4006       break;
4007
4008     case 0x0ff1:
4009       element = EL_SPACESHIP_LEFT;
4010       break;
4011
4012     case 0x0ff9:
4013       element = EL_SPACESHIP_RIGHT;
4014       break;
4015
4016     case 0x1057:
4017       element = EL_BUG_UP;
4018       break;
4019
4020     case 0x1060:
4021       element = EL_BUG_DOWN;
4022       break;
4023
4024     case 0x1078:
4025       element = EL_BUG_LEFT;
4026       break;
4027
4028     case 0x1080:
4029       element = EL_BUG_RIGHT;
4030       break;
4031
4032     case 0x10de:
4033       element = EL_MOLE_UP;
4034       break;
4035
4036     case 0x10e7:
4037       element = EL_MOLE_DOWN;
4038       break;
4039
4040     case 0x10ff:
4041       element = EL_MOLE_LEFT;
4042       break;
4043
4044     case 0x1107:
4045       element = EL_MOLE_RIGHT;
4046       break;
4047
4048     case 0x11c0:
4049       element = EL_ROBOT;
4050       break;
4051
4052     case 0x13f5:
4053       element = EL_YAMYAM;
4054       break;
4055
4056     case 0x1425:
4057       element = EL_SWITCHGATE_OPEN;
4058       break;
4059
4060     case 0x1426:
4061       element = EL_SWITCHGATE_CLOSED;
4062       break;
4063
4064     case 0x1437:
4065       element = EL_DC_SWITCHGATE_SWITCH_UP;
4066       break;
4067
4068     case 0x143a:
4069       element = EL_TIMEGATE_CLOSED;
4070       break;
4071
4072     case 0x144c:        /* conveyor belt switch (green) */
4073       element = EL_CONVEYOR_BELT_3_SWITCH_MIDDLE;
4074       break;
4075
4076     case 0x144f:        /* conveyor belt switch (red) */
4077       element = EL_CONVEYOR_BELT_1_SWITCH_MIDDLE;
4078       break;
4079
4080     case 0x1452:        /* conveyor belt switch (blue) */
4081       element = EL_CONVEYOR_BELT_4_SWITCH_MIDDLE;
4082       break;
4083
4084     case 0x145b:
4085       element = EL_CONVEYOR_BELT_3_MIDDLE;
4086       break;
4087
4088     case 0x1463:
4089       element = EL_CONVEYOR_BELT_3_LEFT;
4090       break;
4091
4092     case 0x146b:
4093       element = EL_CONVEYOR_BELT_3_RIGHT;
4094       break;
4095
4096     case 0x1473:
4097       element = EL_CONVEYOR_BELT_1_MIDDLE;
4098       break;
4099
4100     case 0x147b:
4101       element = EL_CONVEYOR_BELT_1_LEFT;
4102       break;
4103
4104     case 0x1483:
4105       element = EL_CONVEYOR_BELT_1_RIGHT;
4106       break;
4107
4108     case 0x148b:
4109       element = EL_CONVEYOR_BELT_4_MIDDLE;
4110       break;
4111
4112     case 0x1493:
4113       element = EL_CONVEYOR_BELT_4_LEFT;
4114       break;
4115
4116     case 0x149b:
4117       element = EL_CONVEYOR_BELT_4_RIGHT;
4118       break;
4119
4120     case 0x14ac:
4121       element = EL_EXPANDABLE_WALL_HORIZONTAL;
4122       break;
4123
4124     case 0x14bd:
4125       element = EL_EXPANDABLE_WALL_VERTICAL;
4126       break;
4127
4128     case 0x14c6:
4129       element = EL_EXPANDABLE_WALL_ANY;
4130       break;
4131
4132     case 0x14ce:        /* growing steel wall (left/right) */
4133       element = EL_EXPANDABLE_STEELWALL_HORIZONTAL;
4134       break;
4135
4136     case 0x14df:        /* growing steel wall (up/down) */
4137       element = EL_EXPANDABLE_STEELWALL_VERTICAL;
4138       break;
4139
4140     case 0x14e8:        /* growing steel wall (up/down/left/right) */
4141       element = EL_EXPANDABLE_STEELWALL_ANY;
4142       break;
4143
4144     case 0x14e9:
4145       element = EL_SHIELD_DEADLY;
4146       break;
4147
4148     case 0x1501:
4149       element = EL_EXTRA_TIME;
4150       break;
4151
4152     case 0x154f:
4153       element = EL_ACID;
4154       break;
4155
4156     case 0x1577:
4157       element = EL_EMPTY_SPACE;
4158       break;
4159
4160     case 0x1578:        /* quicksand (empty) */
4161       element = EL_QUICKSAND_FAST_EMPTY;
4162       break;
4163
4164     case 0x1579:        /* slow quicksand (empty) */
4165       element = EL_QUICKSAND_EMPTY;
4166       break;
4167
4168       /* 0x157c - 0x158b: */
4169       /* EL_SAND */
4170
4171       /* 0x1590 - 0x159f: */
4172       /* EL_DC_LANDMINE */
4173
4174     case 0x15a0:
4175       element = EL_EM_DYNAMITE;
4176       break;
4177
4178     case 0x15a1:        /* key (red) */
4179       element = EL_EM_KEY_1;
4180       break;
4181
4182     case 0x15a2:        /* key (yellow) */
4183       element = EL_EM_KEY_2;
4184       break;
4185
4186     case 0x15a3:        /* key (blue) */
4187       element = EL_EM_KEY_4;
4188       break;
4189
4190     case 0x15a4:        /* key (green) */
4191       element = EL_EM_KEY_3;
4192       break;
4193
4194     case 0x15a5:        /* key (white) */
4195       element = EL_DC_KEY_WHITE;
4196       break;
4197
4198     case 0x15a6:
4199       element = EL_WALL_SLIPPERY;
4200       break;
4201
4202     case 0x15a7:
4203       element = EL_WALL;
4204       break;
4205
4206     case 0x15a8:        /* wall (not round) */
4207       element = EL_WALL;
4208       break;
4209
4210     case 0x15a9:        /* (blue) */
4211       element = EL_CHAR_A;
4212       break;
4213
4214     case 0x15aa:        /* (blue) */
4215       element = EL_CHAR_B;
4216       break;
4217
4218     case 0x15ab:        /* (blue) */
4219       element = EL_CHAR_C;
4220       break;
4221
4222     case 0x15ac:        /* (blue) */
4223       element = EL_CHAR_D;
4224       break;
4225
4226     case 0x15ad:        /* (blue) */
4227       element = EL_CHAR_E;
4228       break;
4229
4230     case 0x15ae:        /* (blue) */
4231       element = EL_CHAR_F;
4232       break;
4233
4234     case 0x15af:        /* (blue) */
4235       element = EL_CHAR_G;
4236       break;
4237
4238     case 0x15b0:        /* (blue) */
4239       element = EL_CHAR_H;
4240       break;
4241
4242     case 0x15b1:        /* (blue) */
4243       element = EL_CHAR_I;
4244       break;
4245
4246     case 0x15b2:        /* (blue) */
4247       element = EL_CHAR_J;
4248       break;
4249
4250     case 0x15b3:        /* (blue) */
4251       element = EL_CHAR_K;
4252       break;
4253
4254     case 0x15b4:        /* (blue) */
4255       element = EL_CHAR_L;
4256       break;
4257
4258     case 0x15b5:        /* (blue) */
4259       element = EL_CHAR_M;
4260       break;
4261
4262     case 0x15b6:        /* (blue) */
4263       element = EL_CHAR_N;
4264       break;
4265
4266     case 0x15b7:        /* (blue) */
4267       element = EL_CHAR_O;
4268       break;
4269
4270     case 0x15b8:        /* (blue) */
4271       element = EL_CHAR_P;
4272       break;
4273
4274     case 0x15b9:        /* (blue) */
4275       element = EL_CHAR_Q;
4276       break;
4277
4278     case 0x15ba:        /* (blue) */
4279       element = EL_CHAR_R;
4280       break;
4281
4282     case 0x15bb:        /* (blue) */
4283       element = EL_CHAR_S;
4284       break;
4285
4286     case 0x15bc:        /* (blue) */
4287       element = EL_CHAR_T;
4288       break;
4289
4290     case 0x15bd:        /* (blue) */
4291       element = EL_CHAR_U;
4292       break;
4293
4294     case 0x15be:        /* (blue) */
4295       element = EL_CHAR_V;
4296       break;
4297
4298     case 0x15bf:        /* (blue) */
4299       element = EL_CHAR_W;
4300       break;
4301
4302     case 0x15c0:        /* (blue) */
4303       element = EL_CHAR_X;
4304       break;
4305
4306     case 0x15c1:        /* (blue) */
4307       element = EL_CHAR_Y;
4308       break;
4309
4310     case 0x15c2:        /* (blue) */
4311       element = EL_CHAR_Z;
4312       break;
4313
4314     case 0x15c3:        /* (blue) */
4315       element = EL_CHAR_AUMLAUT;
4316       break;
4317
4318     case 0x15c4:        /* (blue) */
4319       element = EL_CHAR_OUMLAUT;
4320       break;
4321
4322     case 0x15c5:        /* (blue) */
4323       element = EL_CHAR_UUMLAUT;
4324       break;
4325
4326     case 0x15c6:        /* (blue) */
4327       element = EL_CHAR_0;
4328       break;
4329
4330     case 0x15c7:        /* (blue) */
4331       element = EL_CHAR_1;
4332       break;
4333
4334     case 0x15c8:        /* (blue) */
4335       element = EL_CHAR_2;
4336       break;
4337
4338     case 0x15c9:        /* (blue) */
4339       element = EL_CHAR_3;
4340       break;
4341
4342     case 0x15ca:        /* (blue) */
4343       element = EL_CHAR_4;
4344       break;
4345
4346     case 0x15cb:        /* (blue) */
4347       element = EL_CHAR_5;
4348       break;
4349
4350     case 0x15cc:        /* (blue) */
4351       element = EL_CHAR_6;
4352       break;
4353
4354     case 0x15cd:        /* (blue) */
4355       element = EL_CHAR_7;
4356       break;
4357
4358     case 0x15ce:        /* (blue) */
4359       element = EL_CHAR_8;
4360       break;
4361
4362     case 0x15cf:        /* (blue) */
4363       element = EL_CHAR_9;
4364       break;
4365
4366     case 0x15d0:        /* (blue) */
4367       element = EL_CHAR_PERIOD;
4368       break;
4369
4370     case 0x15d1:        /* (blue) */
4371       element = EL_CHAR_EXCLAM;
4372       break;
4373
4374     case 0x15d2:        /* (blue) */
4375       element = EL_CHAR_COLON;
4376       break;
4377
4378     case 0x15d3:        /* (blue) */
4379       element = EL_CHAR_LESS;
4380       break;
4381
4382     case 0x15d4:        /* (blue) */
4383       element = EL_CHAR_GREATER;
4384       break;
4385
4386     case 0x15d5:        /* (blue) */
4387       element = EL_CHAR_QUESTION;
4388       break;
4389
4390     case 0x15d6:        /* (blue) */
4391       element = EL_CHAR_COPYRIGHT;
4392       break;
4393
4394     case 0x15d7:        /* (blue) */
4395       element = EL_CHAR_UP;
4396       break;
4397
4398     case 0x15d8:        /* (blue) */
4399       element = EL_CHAR_DOWN;
4400       break;
4401
4402     case 0x15d9:        /* (blue) */
4403       element = EL_CHAR_BUTTON;
4404       break;
4405
4406     case 0x15da:        /* (blue) */
4407       element = EL_CHAR_PLUS;
4408       break;
4409
4410     case 0x15db:        /* (blue) */
4411       element = EL_CHAR_MINUS;
4412       break;
4413
4414     case 0x15dc:        /* (blue) */
4415       element = EL_CHAR_APOSTROPHE;
4416       break;
4417
4418     case 0x15dd:        /* (blue) */
4419       element = EL_CHAR_PARENLEFT;
4420       break;
4421
4422     case 0x15de:        /* (blue) */
4423       element = EL_CHAR_PARENRIGHT;
4424       break;
4425
4426     case 0x15df:        /* (green) */
4427       element = EL_CHAR_A;
4428       break;
4429
4430     case 0x15e0:        /* (green) */
4431       element = EL_CHAR_B;
4432       break;
4433
4434     case 0x15e1:        /* (green) */
4435       element = EL_CHAR_C;
4436       break;
4437
4438     case 0x15e2:        /* (green) */
4439       element = EL_CHAR_D;
4440       break;
4441
4442     case 0x15e3:        /* (green) */
4443       element = EL_CHAR_E;
4444       break;
4445
4446     case 0x15e4:        /* (green) */
4447       element = EL_CHAR_F;
4448       break;
4449
4450     case 0x15e5:        /* (green) */
4451       element = EL_CHAR_G;
4452       break;
4453
4454     case 0x15e6:        /* (green) */
4455       element = EL_CHAR_H;
4456       break;
4457
4458     case 0x15e7:        /* (green) */
4459       element = EL_CHAR_I;
4460       break;
4461
4462     case 0x15e8:        /* (green) */
4463       element = EL_CHAR_J;
4464       break;
4465
4466     case 0x15e9:        /* (green) */
4467       element = EL_CHAR_K;
4468       break;
4469
4470     case 0x15ea:        /* (green) */
4471       element = EL_CHAR_L;
4472       break;
4473
4474     case 0x15eb:        /* (green) */
4475       element = EL_CHAR_M;
4476       break;
4477
4478     case 0x15ec:        /* (green) */
4479       element = EL_CHAR_N;
4480       break;
4481
4482     case 0x15ed:        /* (green) */
4483       element = EL_CHAR_O;
4484       break;
4485
4486     case 0x15ee:        /* (green) */
4487       element = EL_CHAR_P;
4488       break;
4489
4490     case 0x15ef:        /* (green) */
4491       element = EL_CHAR_Q;
4492       break;
4493
4494     case 0x15f0:        /* (green) */
4495       element = EL_CHAR_R;
4496       break;
4497
4498     case 0x15f1:        /* (green) */
4499       element = EL_CHAR_S;
4500       break;
4501
4502     case 0x15f2:        /* (green) */
4503       element = EL_CHAR_T;
4504       break;
4505
4506     case 0x15f3:        /* (green) */
4507       element = EL_CHAR_U;
4508       break;
4509
4510     case 0x15f4:        /* (green) */
4511       element = EL_CHAR_V;
4512       break;
4513
4514     case 0x15f5:        /* (green) */
4515       element = EL_CHAR_W;
4516       break;
4517
4518     case 0x15f6:        /* (green) */
4519       element = EL_CHAR_X;
4520       break;
4521
4522     case 0x15f7:        /* (green) */
4523       element = EL_CHAR_Y;
4524       break;
4525
4526     case 0x15f8:        /* (green) */
4527       element = EL_CHAR_Z;
4528       break;
4529
4530     case 0x15f9:        /* (green) */
4531       element = EL_CHAR_AUMLAUT;
4532       break;
4533
4534     case 0x15fa:        /* (green) */
4535       element = EL_CHAR_OUMLAUT;
4536       break;
4537
4538     case 0x15fb:        /* (green) */
4539       element = EL_CHAR_UUMLAUT;
4540       break;
4541
4542     case 0x15fc:        /* (green) */
4543       element = EL_CHAR_0;
4544       break;
4545
4546     case 0x15fd:        /* (green) */
4547       element = EL_CHAR_1;
4548       break;
4549
4550     case 0x15fe:        /* (green) */
4551       element = EL_CHAR_2;
4552       break;
4553
4554     case 0x15ff:        /* (green) */
4555       element = EL_CHAR_3;
4556       break;
4557
4558     case 0x1600:        /* (green) */
4559       element = EL_CHAR_4;
4560       break;
4561
4562     case 0x1601:        /* (green) */
4563       element = EL_CHAR_5;
4564       break;
4565
4566     case 0x1602:        /* (green) */
4567       element = EL_CHAR_6;
4568       break;
4569
4570     case 0x1603:        /* (green) */
4571       element = EL_CHAR_7;
4572       break;
4573
4574     case 0x1604:        /* (green) */
4575       element = EL_CHAR_8;
4576       break;
4577
4578     case 0x1605:        /* (green) */
4579       element = EL_CHAR_9;
4580       break;
4581
4582     case 0x1606:        /* (green) */
4583       element = EL_CHAR_PERIOD;
4584       break;
4585
4586     case 0x1607:        /* (green) */
4587       element = EL_CHAR_EXCLAM;
4588       break;
4589
4590     case 0x1608:        /* (green) */
4591       element = EL_CHAR_COLON;
4592       break;
4593
4594     case 0x1609:        /* (green) */
4595       element = EL_CHAR_LESS;
4596       break;
4597
4598     case 0x160a:        /* (green) */
4599       element = EL_CHAR_GREATER;
4600       break;
4601
4602     case 0x160b:        /* (green) */
4603       element = EL_CHAR_QUESTION;
4604       break;
4605
4606     case 0x160c:        /* (green) */
4607       element = EL_CHAR_COPYRIGHT;
4608       break;
4609
4610     case 0x160d:        /* (green) */
4611       element = EL_CHAR_UP;
4612       break;
4613
4614     case 0x160e:        /* (green) */
4615       element = EL_CHAR_DOWN;
4616       break;
4617
4618     case 0x160f:        /* (green) */
4619       element = EL_CHAR_BUTTON;
4620       break;
4621
4622     case 0x1610:        /* (green) */
4623       element = EL_CHAR_PLUS;
4624       break;
4625
4626     case 0x1611:        /* (green) */
4627       element = EL_CHAR_MINUS;
4628       break;
4629
4630     case 0x1612:        /* (green) */
4631       element = EL_CHAR_APOSTROPHE;
4632       break;
4633
4634     case 0x1613:        /* (green) */
4635       element = EL_CHAR_PARENLEFT;
4636       break;
4637
4638     case 0x1614:        /* (green) */
4639       element = EL_CHAR_PARENRIGHT;
4640       break;
4641
4642     case 0x1615:        /* (blue steel) */
4643       element = EL_STEEL_CHAR_A;
4644       break;
4645
4646     case 0x1616:        /* (blue steel) */
4647       element = EL_STEEL_CHAR_B;
4648       break;
4649
4650     case 0x1617:        /* (blue steel) */
4651       element = EL_STEEL_CHAR_C;
4652       break;
4653
4654     case 0x1618:        /* (blue steel) */
4655       element = EL_STEEL_CHAR_D;
4656       break;
4657
4658     case 0x1619:        /* (blue steel) */
4659       element = EL_STEEL_CHAR_E;
4660       break;
4661
4662     case 0x161a:        /* (blue steel) */
4663       element = EL_STEEL_CHAR_F;
4664       break;
4665
4666     case 0x161b:        /* (blue steel) */
4667       element = EL_STEEL_CHAR_G;
4668       break;
4669
4670     case 0x161c:        /* (blue steel) */
4671       element = EL_STEEL_CHAR_H;
4672       break;
4673
4674     case 0x161d:        /* (blue steel) */
4675       element = EL_STEEL_CHAR_I;
4676       break;
4677
4678     case 0x161e:        /* (blue steel) */
4679       element = EL_STEEL_CHAR_J;
4680       break;
4681
4682     case 0x161f:        /* (blue steel) */
4683       element = EL_STEEL_CHAR_K;
4684       break;
4685
4686     case 0x1620:        /* (blue steel) */
4687       element = EL_STEEL_CHAR_L;
4688       break;
4689
4690     case 0x1621:        /* (blue steel) */
4691       element = EL_STEEL_CHAR_M;
4692       break;
4693
4694     case 0x1622:        /* (blue steel) */
4695       element = EL_STEEL_CHAR_N;
4696       break;
4697
4698     case 0x1623:        /* (blue steel) */
4699       element = EL_STEEL_CHAR_O;
4700       break;
4701
4702     case 0x1624:        /* (blue steel) */
4703       element = EL_STEEL_CHAR_P;
4704       break;
4705
4706     case 0x1625:        /* (blue steel) */
4707       element = EL_STEEL_CHAR_Q;
4708       break;
4709
4710     case 0x1626:        /* (blue steel) */
4711       element = EL_STEEL_CHAR_R;
4712       break;
4713
4714     case 0x1627:        /* (blue steel) */
4715       element = EL_STEEL_CHAR_S;
4716       break;
4717
4718     case 0x1628:        /* (blue steel) */
4719       element = EL_STEEL_CHAR_T;
4720       break;
4721
4722     case 0x1629:        /* (blue steel) */
4723       element = EL_STEEL_CHAR_U;
4724       break;
4725
4726     case 0x162a:        /* (blue steel) */
4727       element = EL_STEEL_CHAR_V;
4728       break;
4729
4730     case 0x162b:        /* (blue steel) */
4731       element = EL_STEEL_CHAR_W;
4732       break;
4733
4734     case 0x162c:        /* (blue steel) */
4735       element = EL_STEEL_CHAR_X;
4736       break;
4737
4738     case 0x162d:        /* (blue steel) */
4739       element = EL_STEEL_CHAR_Y;
4740       break;
4741
4742     case 0x162e:        /* (blue steel) */
4743       element = EL_STEEL_CHAR_Z;
4744       break;
4745
4746     case 0x162f:        /* (blue steel) */
4747       element = EL_STEEL_CHAR_AUMLAUT;
4748       break;
4749
4750     case 0x1630:        /* (blue steel) */
4751       element = EL_STEEL_CHAR_OUMLAUT;
4752       break;
4753
4754     case 0x1631:        /* (blue steel) */
4755       element = EL_STEEL_CHAR_UUMLAUT;
4756       break;
4757
4758     case 0x1632:        /* (blue steel) */
4759       element = EL_STEEL_CHAR_0;
4760       break;
4761
4762     case 0x1633:        /* (blue steel) */
4763       element = EL_STEEL_CHAR_1;
4764       break;
4765
4766     case 0x1634:        /* (blue steel) */
4767       element = EL_STEEL_CHAR_2;
4768       break;
4769
4770     case 0x1635:        /* (blue steel) */
4771       element = EL_STEEL_CHAR_3;
4772       break;
4773
4774     case 0x1636:        /* (blue steel) */
4775       element = EL_STEEL_CHAR_4;
4776       break;
4777
4778     case 0x1637:        /* (blue steel) */
4779       element = EL_STEEL_CHAR_5;
4780       break;
4781
4782     case 0x1638:        /* (blue steel) */
4783       element = EL_STEEL_CHAR_6;
4784       break;
4785
4786     case 0x1639:        /* (blue steel) */
4787       element = EL_STEEL_CHAR_7;
4788       break;
4789
4790     case 0x163a:        /* (blue steel) */
4791       element = EL_STEEL_CHAR_8;
4792       break;
4793
4794     case 0x163b:        /* (blue steel) */
4795       element = EL_STEEL_CHAR_9;
4796       break;
4797
4798     case 0x163c:        /* (blue steel) */
4799       element = EL_STEEL_CHAR_PERIOD;
4800       break;
4801
4802     case 0x163d:        /* (blue steel) */
4803       element = EL_STEEL_CHAR_EXCLAM;
4804       break;
4805
4806     case 0x163e:        /* (blue steel) */
4807       element = EL_STEEL_CHAR_COLON;
4808       break;
4809
4810     case 0x163f:        /* (blue steel) */
4811       element = EL_STEEL_CHAR_LESS;
4812       break;
4813
4814     case 0x1640:        /* (blue steel) */
4815       element = EL_STEEL_CHAR_GREATER;
4816       break;
4817
4818     case 0x1641:        /* (blue steel) */
4819       element = EL_STEEL_CHAR_QUESTION;
4820       break;
4821
4822     case 0x1642:        /* (blue steel) */
4823       element = EL_STEEL_CHAR_COPYRIGHT;
4824       break;
4825
4826     case 0x1643:        /* (blue steel) */
4827       element = EL_STEEL_CHAR_UP;
4828       break;
4829
4830     case 0x1644:        /* (blue steel) */
4831       element = EL_STEEL_CHAR_DOWN;
4832       break;
4833
4834     case 0x1645:        /* (blue steel) */
4835       element = EL_STEEL_CHAR_BUTTON;
4836       break;
4837
4838     case 0x1646:        /* (blue steel) */
4839       element = EL_STEEL_CHAR_PLUS;
4840       break;
4841
4842     case 0x1647:        /* (blue steel) */
4843       element = EL_STEEL_CHAR_MINUS;
4844       break;
4845
4846     case 0x1648:        /* (blue steel) */
4847       element = EL_STEEL_CHAR_APOSTROPHE;
4848       break;
4849
4850     case 0x1649:        /* (blue steel) */
4851       element = EL_STEEL_CHAR_PARENLEFT;
4852       break;
4853
4854     case 0x164a:        /* (blue steel) */
4855       element = EL_STEEL_CHAR_PARENRIGHT;
4856       break;
4857
4858     case 0x164b:        /* (green steel) */
4859       element = EL_STEEL_CHAR_A;
4860       break;
4861
4862     case 0x164c:        /* (green steel) */
4863       element = EL_STEEL_CHAR_B;
4864       break;
4865
4866     case 0x164d:        /* (green steel) */
4867       element = EL_STEEL_CHAR_C;
4868       break;
4869
4870     case 0x164e:        /* (green steel) */
4871       element = EL_STEEL_CHAR_D;
4872       break;
4873
4874     case 0x164f:        /* (green steel) */
4875       element = EL_STEEL_CHAR_E;
4876       break;
4877
4878     case 0x1650:        /* (green steel) */
4879       element = EL_STEEL_CHAR_F;
4880       break;
4881
4882     case 0x1651:        /* (green steel) */
4883       element = EL_STEEL_CHAR_G;
4884       break;
4885
4886     case 0x1652:        /* (green steel) */
4887       element = EL_STEEL_CHAR_H;
4888       break;
4889
4890     case 0x1653:        /* (green steel) */
4891       element = EL_STEEL_CHAR_I;
4892       break;
4893
4894     case 0x1654:        /* (green steel) */
4895       element = EL_STEEL_CHAR_J;
4896       break;
4897
4898     case 0x1655:        /* (green steel) */
4899       element = EL_STEEL_CHAR_K;
4900       break;
4901
4902     case 0x1656:        /* (green steel) */
4903       element = EL_STEEL_CHAR_L;
4904       break;
4905
4906     case 0x1657:        /* (green steel) */
4907       element = EL_STEEL_CHAR_M;
4908       break;
4909
4910     case 0x1658:        /* (green steel) */
4911       element = EL_STEEL_CHAR_N;
4912       break;
4913
4914     case 0x1659:        /* (green steel) */
4915       element = EL_STEEL_CHAR_O;
4916       break;
4917
4918     case 0x165a:        /* (green steel) */
4919       element = EL_STEEL_CHAR_P;
4920       break;
4921
4922     case 0x165b:        /* (green steel) */
4923       element = EL_STEEL_CHAR_Q;
4924       break;
4925
4926     case 0x165c:        /* (green steel) */
4927       element = EL_STEEL_CHAR_R;
4928       break;
4929
4930     case 0x165d:        /* (green steel) */
4931       element = EL_STEEL_CHAR_S;
4932       break;
4933
4934     case 0x165e:        /* (green steel) */
4935       element = EL_STEEL_CHAR_T;
4936       break;
4937
4938     case 0x165f:        /* (green steel) */
4939       element = EL_STEEL_CHAR_U;
4940       break;
4941
4942     case 0x1660:        /* (green steel) */
4943       element = EL_STEEL_CHAR_V;
4944       break;
4945
4946     case 0x1661:        /* (green steel) */
4947       element = EL_STEEL_CHAR_W;
4948       break;
4949
4950     case 0x1662:        /* (green steel) */
4951       element = EL_STEEL_CHAR_X;
4952       break;
4953
4954     case 0x1663:        /* (green steel) */
4955       element = EL_STEEL_CHAR_Y;
4956       break;
4957
4958     case 0x1664:        /* (green steel) */
4959       element = EL_STEEL_CHAR_Z;
4960       break;
4961
4962     case 0x1665:        /* (green steel) */
4963       element = EL_STEEL_CHAR_AUMLAUT;
4964       break;
4965
4966     case 0x1666:        /* (green steel) */
4967       element = EL_STEEL_CHAR_OUMLAUT;
4968       break;
4969
4970     case 0x1667:        /* (green steel) */
4971       element = EL_STEEL_CHAR_UUMLAUT;
4972       break;
4973
4974     case 0x1668:        /* (green steel) */
4975       element = EL_STEEL_CHAR_0;
4976       break;
4977
4978     case 0x1669:        /* (green steel) */
4979       element = EL_STEEL_CHAR_1;
4980       break;
4981
4982     case 0x166a:        /* (green steel) */
4983       element = EL_STEEL_CHAR_2;
4984       break;
4985
4986     case 0x166b:        /* (green steel) */
4987       element = EL_STEEL_CHAR_3;
4988       break;
4989
4990     case 0x166c:        /* (green steel) */
4991       element = EL_STEEL_CHAR_4;
4992       break;
4993
4994     case 0x166d:        /* (green steel) */
4995       element = EL_STEEL_CHAR_5;
4996       break;
4997
4998     case 0x166e:        /* (green steel) */
4999       element = EL_STEEL_CHAR_6;
5000       break;
5001
5002     case 0x166f:        /* (green steel) */
5003       element = EL_STEEL_CHAR_7;
5004       break;
5005
5006     case 0x1670:        /* (green steel) */
5007       element = EL_STEEL_CHAR_8;
5008       break;
5009
5010     case 0x1671:        /* (green steel) */
5011       element = EL_STEEL_CHAR_9;
5012       break;
5013
5014     case 0x1672:        /* (green steel) */
5015       element = EL_STEEL_CHAR_PERIOD;
5016       break;
5017
5018     case 0x1673:        /* (green steel) */
5019       element = EL_STEEL_CHAR_EXCLAM;
5020       break;
5021
5022     case 0x1674:        /* (green steel) */
5023       element = EL_STEEL_CHAR_COLON;
5024       break;
5025
5026     case 0x1675:        /* (green steel) */
5027       element = EL_STEEL_CHAR_LESS;
5028       break;
5029
5030     case 0x1676:        /* (green steel) */
5031       element = EL_STEEL_CHAR_GREATER;
5032       break;
5033
5034     case 0x1677:        /* (green steel) */
5035       element = EL_STEEL_CHAR_QUESTION;
5036       break;
5037
5038     case 0x1678:        /* (green steel) */
5039       element = EL_STEEL_CHAR_COPYRIGHT;
5040       break;
5041
5042     case 0x1679:        /* (green steel) */
5043       element = EL_STEEL_CHAR_UP;
5044       break;
5045
5046     case 0x167a:        /* (green steel) */
5047       element = EL_STEEL_CHAR_DOWN;
5048       break;
5049
5050     case 0x167b:        /* (green steel) */
5051       element = EL_STEEL_CHAR_BUTTON;
5052       break;
5053
5054     case 0x167c:        /* (green steel) */
5055       element = EL_STEEL_CHAR_PLUS;
5056       break;
5057
5058     case 0x167d:        /* (green steel) */
5059       element = EL_STEEL_CHAR_MINUS;
5060       break;
5061
5062     case 0x167e:        /* (green steel) */
5063       element = EL_STEEL_CHAR_APOSTROPHE;
5064       break;
5065
5066     case 0x167f:        /* (green steel) */
5067       element = EL_STEEL_CHAR_PARENLEFT;
5068       break;
5069
5070     case 0x1680:        /* (green steel) */
5071       element = EL_STEEL_CHAR_PARENRIGHT;
5072       break;
5073
5074     case 0x1681:        /* gate (red) */
5075       element = EL_EM_GATE_1;
5076       break;
5077
5078     case 0x1682:        /* secret gate (red) */
5079       element = EL_GATE_1_GRAY;
5080       break;
5081
5082     case 0x1683:        /* gate (yellow) */
5083       element = EL_EM_GATE_2;
5084       break;
5085
5086     case 0x1684:        /* secret gate (yellow) */
5087       element = EL_GATE_2_GRAY;
5088       break;
5089
5090     case 0x1685:        /* gate (blue) */
5091       element = EL_EM_GATE_4;
5092       break;
5093
5094     case 0x1686:        /* secret gate (blue) */
5095       element = EL_GATE_4_GRAY;
5096       break;
5097
5098     case 0x1687:        /* gate (green) */
5099       element = EL_EM_GATE_3;
5100       break;
5101
5102     case 0x1688:        /* secret gate (green) */
5103       element = EL_GATE_3_GRAY;
5104       break;
5105
5106     case 0x1689:        /* gate (white) */
5107       element = EL_DC_GATE_WHITE;
5108       break;
5109
5110     case 0x168a:        /* secret gate (white) */
5111       element = EL_DC_GATE_WHITE_GRAY;
5112       break;
5113
5114     case 0x168b:        /* secret gate (no key) */
5115       element = EL_DC_GATE_FAKE_GRAY;
5116       break;
5117
5118     case 0x168c:
5119       element = EL_ROBOT_WHEEL;
5120       break;
5121
5122     case 0x168d:
5123       element = EL_DC_TIMEGATE_SWITCH;
5124       break;
5125
5126     case 0x168e:
5127       element = EL_ACID_POOL_BOTTOM;
5128       break;
5129
5130     case 0x168f:
5131       element = EL_ACID_POOL_TOPLEFT;
5132       break;
5133
5134     case 0x1690:
5135       element = EL_ACID_POOL_TOPRIGHT;
5136       break;
5137
5138     case 0x1691:
5139       element = EL_ACID_POOL_BOTTOMLEFT;
5140       break;
5141
5142     case 0x1692:
5143       element = EL_ACID_POOL_BOTTOMRIGHT;
5144       break;
5145
5146     case 0x1693:
5147       element = EL_STEELWALL;
5148       break;
5149
5150     case 0x1694:
5151       element = EL_STEELWALL_SLIPPERY;
5152       break;
5153
5154     case 0x1695:        /* steel wall (not round) */
5155       element = EL_STEELWALL;
5156       break;
5157
5158     case 0x1696:        /* steel wall (left) */
5159       element = EL_DC_STEELWALL_1_LEFT;
5160       break;
5161
5162     case 0x1697:        /* steel wall (bottom) */
5163       element = EL_DC_STEELWALL_1_BOTTOM;
5164       break;
5165
5166     case 0x1698:        /* steel wall (right) */
5167       element = EL_DC_STEELWALL_1_RIGHT;
5168       break;
5169
5170     case 0x1699:        /* steel wall (top) */
5171       element = EL_DC_STEELWALL_1_TOP;
5172       break;
5173
5174     case 0x169a:        /* steel wall (left/bottom) */
5175       element = EL_DC_STEELWALL_1_BOTTOMLEFT;
5176       break;
5177
5178     case 0x169b:        /* steel wall (right/bottom) */
5179       element = EL_DC_STEELWALL_1_BOTTOMRIGHT;
5180       break;
5181
5182     case 0x169c:        /* steel wall (right/top) */
5183       element = EL_DC_STEELWALL_1_TOPRIGHT;
5184       break;
5185
5186     case 0x169d:        /* steel wall (left/top) */
5187       element = EL_DC_STEELWALL_1_TOPLEFT;
5188       break;
5189
5190     case 0x169e:        /* steel wall (right/bottom small) */
5191       element = EL_DC_STEELWALL_1_BOTTOMRIGHT_2;
5192       break;
5193
5194     case 0x169f:        /* steel wall (left/bottom small) */
5195       element = EL_DC_STEELWALL_1_BOTTOMLEFT_2;
5196       break;
5197
5198     case 0x16a0:        /* steel wall (right/top small) */
5199       element = EL_DC_STEELWALL_1_TOPRIGHT_2;
5200       break;
5201
5202     case 0x16a1:        /* steel wall (left/top small) */
5203       element = EL_DC_STEELWALL_1_TOPLEFT_2;
5204       break;
5205
5206     case 0x16a2:        /* steel wall (left/right) */
5207       element = EL_DC_STEELWALL_1_VERTICAL;
5208       break;
5209
5210     case 0x16a3:        /* steel wall (top/bottom) */
5211       element = EL_DC_STEELWALL_1_HORIZONTAL;
5212       break;
5213
5214     case 0x16a4:        /* steel wall 2 (left end) */
5215       element = EL_DC_STEELWALL_2_LEFT;
5216       break;
5217
5218     case 0x16a5:        /* steel wall 2 (right end) */
5219       element = EL_DC_STEELWALL_2_RIGHT;
5220       break;
5221
5222     case 0x16a6:        /* steel wall 2 (top end) */
5223       element = EL_DC_STEELWALL_2_TOP;
5224       break;
5225
5226     case 0x16a7:        /* steel wall 2 (bottom end) */
5227       element = EL_DC_STEELWALL_2_BOTTOM;
5228       break;
5229
5230     case 0x16a8:        /* steel wall 2 (left/right) */
5231       element = EL_DC_STEELWALL_2_HORIZONTAL;
5232       break;
5233
5234     case 0x16a9:        /* steel wall 2 (up/down) */
5235       element = EL_DC_STEELWALL_2_VERTICAL;
5236       break;
5237
5238     case 0x16aa:        /* steel wall 2 (mid) */
5239       element = EL_DC_STEELWALL_2_MIDDLE;
5240       break;
5241
5242     case 0x16ab:
5243       element = EL_SIGN_EXCLAMATION;
5244       break;
5245
5246     case 0x16ac:
5247       element = EL_SIGN_RADIOACTIVITY;
5248       break;
5249
5250     case 0x16ad:
5251       element = EL_SIGN_STOP;
5252       break;
5253
5254     case 0x16ae:
5255       element = EL_SIGN_WHEELCHAIR;
5256       break;
5257
5258     case 0x16af:
5259       element = EL_SIGN_PARKING;
5260       break;
5261
5262     case 0x16b0:
5263       element = EL_SIGN_NO_ENTRY;
5264       break;
5265
5266     case 0x16b1:
5267       element = EL_SIGN_HEART;
5268       break;
5269
5270     case 0x16b2:
5271       element = EL_SIGN_GIVE_WAY;
5272       break;
5273
5274     case 0x16b3:
5275       element = EL_SIGN_ENTRY_FORBIDDEN;
5276       break;
5277
5278     case 0x16b4:
5279       element = EL_SIGN_EMERGENCY_EXIT;
5280       break;
5281
5282     case 0x16b5:
5283       element = EL_SIGN_YIN_YANG;
5284       break;
5285
5286     case 0x16b6:
5287       element = EL_WALL_EMERALD;
5288       break;
5289
5290     case 0x16b7:
5291       element = EL_WALL_DIAMOND;
5292       break;
5293
5294     case 0x16b8:
5295       element = EL_WALL_PEARL;
5296       break;
5297
5298     case 0x16b9:
5299       element = EL_WALL_CRYSTAL;
5300       break;
5301
5302     case 0x16ba:
5303       element = EL_INVISIBLE_WALL;
5304       break;
5305
5306     case 0x16bb:
5307       element = EL_INVISIBLE_STEELWALL;
5308       break;
5309
5310       /* 0x16bc - 0x16cb: */
5311       /* EL_INVISIBLE_SAND */
5312
5313     case 0x16cc:
5314       element = EL_LIGHT_SWITCH;
5315       break;
5316
5317     case 0x16cd:
5318       element = EL_ENVELOPE_1;
5319       break;
5320
5321     default:
5322       if (element >= 0x0117 && element <= 0x036e)       /* (?) */
5323         element = EL_DIAMOND;
5324       else if (element >= 0x042d && element <= 0x0684)  /* (?) */
5325         element = EL_EMERALD;
5326       else if (element >= 0x157c && element <= 0x158b)
5327         element = EL_SAND;
5328       else if (element >= 0x1590 && element <= 0x159f)
5329         element = EL_DC_LANDMINE;
5330       else if (element >= 0x16bc && element <= 0x16cb)
5331         element = EL_INVISIBLE_SAND;
5332       else
5333       {
5334         Error(ERR_WARN, "unknown Diamond Caves element 0x%04x", element);
5335         element = EL_UNKNOWN;
5336       }
5337       break;
5338   }
5339
5340   return getMappedElement(element);
5341 }
5342
5343 static void LoadLevelFromFileStream_DC(File *file, struct LevelInfo *level,
5344                                        int nr)
5345 {
5346   byte header[DC_LEVEL_HEADER_SIZE];
5347   int envelope_size;
5348   int envelope_header_pos = 62;
5349   int envelope_content_pos = 94;
5350   int level_name_pos = 251;
5351   int level_author_pos = 292;
5352   int envelope_header_len;
5353   int envelope_content_len;
5354   int level_name_len;
5355   int level_author_len;
5356   int fieldx, fieldy;
5357   int num_yamyam_contents;
5358   int i, x, y;
5359
5360   getDecodedWord_DC(0, TRUE);           /* initialize DC2 decoding engine */
5361
5362   for (i = 0; i < DC_LEVEL_HEADER_SIZE / 2; i++)
5363   {
5364     unsigned short header_word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5365
5366     header[i * 2 + 0] = header_word >> 8;
5367     header[i * 2 + 1] = header_word & 0xff;
5368   }
5369
5370   /* read some values from level header to check level decoding integrity */
5371   fieldx = header[6] | (header[7] << 8);
5372   fieldy = header[8] | (header[9] << 8);
5373   num_yamyam_contents = header[60] | (header[61] << 8);
5374
5375   /* do some simple sanity checks to ensure that level was correctly decoded */
5376   if (fieldx < 1 || fieldx > 256 ||
5377       fieldy < 1 || fieldy > 256 ||
5378       num_yamyam_contents < 1 || num_yamyam_contents > 8)
5379   {
5380     level->no_valid_file = TRUE;
5381
5382     Error(ERR_WARN, "cannot decode level from stream -- using empty level");
5383
5384     return;
5385   }
5386
5387   /* maximum envelope header size is 31 bytes */
5388   envelope_header_len   = header[envelope_header_pos];
5389   /* maximum envelope content size is 110 (156?) bytes */
5390   envelope_content_len  = header[envelope_content_pos];
5391
5392   /* maximum level title size is 40 bytes */
5393   level_name_len        = MIN(header[level_name_pos],   MAX_LEVEL_NAME_LEN);
5394   /* maximum level author size is 30 (51?) bytes */
5395   level_author_len      = MIN(header[level_author_pos], MAX_LEVEL_AUTHOR_LEN);
5396
5397   envelope_size = 0;
5398
5399   for (i = 0; i < envelope_header_len; i++)
5400     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5401       level->envelope[0].text[envelope_size++] =
5402         header[envelope_header_pos + 1 + i];
5403
5404   if (envelope_header_len > 0 && envelope_content_len > 0)
5405   {
5406     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5407       level->envelope[0].text[envelope_size++] = '\n';
5408     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5409       level->envelope[0].text[envelope_size++] = '\n';
5410   }
5411
5412   for (i = 0; i < envelope_content_len; i++)
5413     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5414       level->envelope[0].text[envelope_size++] =
5415         header[envelope_content_pos + 1 + i];
5416
5417   level->envelope[0].text[envelope_size] = '\0';
5418
5419   level->envelope[0].xsize = MAX_ENVELOPE_XSIZE;
5420   level->envelope[0].ysize = 10;
5421   level->envelope[0].autowrap = TRUE;
5422   level->envelope[0].centered = TRUE;
5423
5424   for (i = 0; i < level_name_len; i++)
5425     level->name[i] = header[level_name_pos + 1 + i];
5426   level->name[level_name_len] = '\0';
5427
5428   for (i = 0; i < level_author_len; i++)
5429     level->author[i] = header[level_author_pos + 1 + i];
5430   level->author[level_author_len] = '\0';
5431
5432   num_yamyam_contents = header[60] | (header[61] << 8);
5433   level->num_yamyam_contents =
5434     MIN(MAX(MIN_ELEMENT_CONTENTS, num_yamyam_contents), MAX_ELEMENT_CONTENTS);
5435
5436   for (i = 0; i < num_yamyam_contents; i++)
5437   {
5438     for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
5439     {
5440       unsigned short word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5441       int element_dc = ((word & 0xff) << 8) | ((word >> 8) & 0xff);
5442
5443       if (i < MAX_ELEMENT_CONTENTS)
5444         level->yamyam_content[i].e[x][y] = getMappedElement_DC(element_dc);
5445     }
5446   }
5447
5448   fieldx = header[6] | (header[7] << 8);
5449   fieldy = header[8] | (header[9] << 8);
5450   level->fieldx = MIN(MAX(MIN_LEV_FIELDX, fieldx), MAX_LEV_FIELDX);
5451   level->fieldy = MIN(MAX(MIN_LEV_FIELDY, fieldy), MAX_LEV_FIELDY);
5452
5453   for (y = 0; y < fieldy; y++) for (x = 0; x < fieldx; x++)
5454   {
5455     unsigned short word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5456     int element_dc = ((word & 0xff) << 8) | ((word >> 8) & 0xff);
5457
5458     if (x < MAX_LEV_FIELDX && y < MAX_LEV_FIELDY)
5459       level->field[x][y] = getMappedElement_DC(element_dc);
5460   }
5461
5462   x = MIN(MAX(0, (header[10] | (header[11] << 8)) - 1), MAX_LEV_FIELDX - 1);
5463   y = MIN(MAX(0, (header[12] | (header[13] << 8)) - 1), MAX_LEV_FIELDY - 1);
5464   level->field[x][y] = EL_PLAYER_1;
5465
5466   x = MIN(MAX(0, (header[14] | (header[15] << 8)) - 1), MAX_LEV_FIELDX - 1);
5467   y = MIN(MAX(0, (header[16] | (header[17] << 8)) - 1), MAX_LEV_FIELDY - 1);
5468   level->field[x][y] = EL_PLAYER_2;
5469
5470   level->gems_needed            = header[18] | (header[19] << 8);
5471
5472   level->score[SC_EMERALD]      = header[20] | (header[21] << 8);
5473   level->score[SC_DIAMOND]      = header[22] | (header[23] << 8);
5474   level->score[SC_PEARL]        = header[24] | (header[25] << 8);
5475   level->score[SC_CRYSTAL]      = header[26] | (header[27] << 8);
5476   level->score[SC_NUT]          = header[28] | (header[29] << 8);
5477   level->score[SC_ROBOT]        = header[30] | (header[31] << 8);
5478   level->score[SC_SPACESHIP]    = header[32] | (header[33] << 8);
5479   level->score[SC_BUG]          = header[34] | (header[35] << 8);
5480   level->score[SC_YAMYAM]       = header[36] | (header[37] << 8);
5481   level->score[SC_DYNAMITE]     = header[38] | (header[39] << 8);
5482   level->score[SC_KEY]          = header[40] | (header[41] << 8);
5483   level->score[SC_TIME_BONUS]   = header[42] | (header[43] << 8);
5484
5485   level->time                   = header[44] | (header[45] << 8);
5486
5487   level->amoeba_speed           = header[46] | (header[47] << 8);
5488   level->time_light             = header[48] | (header[49] << 8);
5489   level->time_timegate          = header[50] | (header[51] << 8);
5490   level->time_wheel             = header[52] | (header[53] << 8);
5491   level->time_magic_wall        = header[54] | (header[55] << 8);
5492   level->extra_time             = header[56] | (header[57] << 8);
5493   level->shield_normal_time     = header[58] | (header[59] << 8);
5494
5495   /* Diamond Caves has the same (strange) behaviour as Emerald Mine that gems
5496      can slip down from flat walls, like normal walls and steel walls */
5497   level->em_slippery_gems = TRUE;
5498 }
5499
5500 static void LoadLevelFromFileInfo_DC(struct LevelInfo *level,
5501                                      struct LevelFileInfo *level_file_info,
5502                                      boolean level_info_only)
5503 {
5504   char *filename = level_file_info->filename;
5505   File *file;
5506   int num_magic_bytes = 8;
5507   char magic_bytes[num_magic_bytes + 1];
5508   int num_levels_to_skip = level_file_info->nr - leveldir_current->first_level;
5509
5510   if (!(file = openFile(filename, MODE_READ)))
5511   {
5512     level->no_valid_file = TRUE;
5513
5514     if (!level_info_only)
5515       Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
5516
5517     return;
5518   }
5519
5520   // fseek(file, 0x0000, SEEK_SET);
5521
5522   if (level_file_info->packed)
5523   {
5524     /* read "magic bytes" from start of file */
5525     if (getStringFromFile(file, magic_bytes, num_magic_bytes + 1) == NULL)
5526       magic_bytes[0] = '\0';
5527
5528     /* check "magic bytes" for correct file format */
5529     if (!strPrefix(magic_bytes, "DC2"))
5530     {
5531       level->no_valid_file = TRUE;
5532
5533       Error(ERR_WARN, "unknown DC level file '%s' -- using empty level",
5534             filename);
5535
5536       return;
5537     }
5538
5539     if (strPrefix(magic_bytes, "DC2Win95") ||
5540         strPrefix(magic_bytes, "DC2Win98"))
5541     {
5542       int position_first_level = 0x00fa;
5543       int extra_bytes = 4;
5544       int skip_bytes;
5545
5546       /* advance file stream to first level inside the level package */
5547       skip_bytes = position_first_level - num_magic_bytes - extra_bytes;
5548
5549       /* each block of level data is followed by block of non-level data */
5550       num_levels_to_skip *= 2;
5551
5552       /* at least skip header bytes, therefore use ">= 0" instead of "> 0" */
5553       while (num_levels_to_skip >= 0)
5554       {
5555         /* advance file stream to next level inside the level package */
5556         if (seekFile(file, skip_bytes, SEEK_CUR) != 0)
5557         {
5558           level->no_valid_file = TRUE;
5559
5560           Error(ERR_WARN, "cannot fseek in file '%s' -- using empty level",
5561                 filename);
5562
5563           return;
5564         }
5565
5566         /* skip apparently unused extra bytes following each level */
5567         ReadUnusedBytesFromFile(file, extra_bytes);
5568
5569         /* read size of next level in level package */
5570         skip_bytes = getFile32BitLE(file);
5571
5572         num_levels_to_skip--;
5573       }
5574     }
5575     else
5576     {
5577       level->no_valid_file = TRUE;
5578
5579       Error(ERR_WARN, "unknown DC2 level file '%s' -- using empty level",
5580             filename);
5581
5582       return;
5583     }
5584   }
5585
5586   LoadLevelFromFileStream_DC(file, level, level_file_info->nr);
5587
5588   closeFile(file);
5589 }
5590
5591
5592 /* ------------------------------------------------------------------------- */
5593 /* functions for loading SB level                                            */
5594 /* ------------------------------------------------------------------------- */
5595
5596 int getMappedElement_SB(int element_ascii, boolean use_ces)
5597 {
5598   static struct
5599   {
5600     int ascii;
5601     int sb;
5602     int ce;
5603   }
5604   sb_element_mapping[] =
5605   {
5606     { ' ', EL_EMPTY,                EL_CUSTOM_1 },  /* floor (space) */
5607     { '#', EL_STEELWALL,            EL_CUSTOM_2 },  /* wall */
5608     { '@', EL_PLAYER_1,             EL_CUSTOM_3 },  /* player */
5609     { '$', EL_SOKOBAN_OBJECT,       EL_CUSTOM_4 },  /* box */
5610     { '.', EL_SOKOBAN_FIELD_EMPTY,  EL_CUSTOM_5 },  /* goal square */
5611     { '*', EL_SOKOBAN_FIELD_FULL,   EL_CUSTOM_6 },  /* box on goal square */
5612     { '+', EL_SOKOBAN_FIELD_PLAYER, EL_CUSTOM_7 },  /* player on goal square */
5613     { '_', EL_INVISIBLE_STEELWALL,  EL_FROM_LEVEL_TEMPLATE },  /* floor beyond border */
5614
5615     { 0,   -1,                      -1          },
5616   };
5617
5618   int i;
5619
5620   for (i = 0; sb_element_mapping[i].ascii != 0; i++)
5621     if (element_ascii == sb_element_mapping[i].ascii)
5622       return (use_ces ? sb_element_mapping[i].ce : sb_element_mapping[i].sb);
5623
5624   return EL_UNDEFINED;
5625 }
5626
5627 static void LoadLevelFromFileInfo_SB(struct LevelInfo *level,
5628                                      struct LevelFileInfo *level_file_info,
5629                                      boolean level_info_only)
5630 {
5631   char *filename = level_file_info->filename;
5632   char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
5633   char last_comment[MAX_LINE_LEN];
5634   char level_name[MAX_LINE_LEN];
5635   char *line_ptr;
5636   File *file;
5637   int num_levels_to_skip = level_file_info->nr - leveldir_current->first_level;
5638   boolean read_continued_line = FALSE;
5639   boolean reading_playfield = FALSE;
5640   boolean got_valid_playfield_line = FALSE;
5641   boolean invalid_playfield_char = FALSE;
5642   boolean load_xsb_to_ces = check_special_flags("load_xsb_to_ces");
5643   int file_level_nr = 0;
5644   int line_nr = 0;
5645   int x = 0, y = 0;             /* initialized to make compilers happy */
5646
5647   last_comment[0] = '\0';
5648   level_name[0] = '\0';
5649
5650   if (!(file = openFile(filename, MODE_READ)))
5651   {
5652     level->no_valid_file = TRUE;
5653
5654     if (!level_info_only)
5655       Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
5656
5657     return;
5658   }
5659
5660   while (!checkEndOfFile(file))
5661   {
5662     /* level successfully read, but next level may follow here */
5663     if (!got_valid_playfield_line && reading_playfield)
5664     {
5665       /* read playfield from single level file -- skip remaining file */
5666       if (!level_file_info->packed)
5667         break;
5668
5669       if (file_level_nr >= num_levels_to_skip)
5670         break;
5671
5672       file_level_nr++;
5673
5674       last_comment[0] = '\0';
5675       level_name[0] = '\0';
5676
5677       reading_playfield = FALSE;
5678     }
5679
5680     got_valid_playfield_line = FALSE;
5681
5682     /* read next line of input file */
5683     if (!getStringFromFile(file, line, MAX_LINE_LEN))
5684       break;
5685
5686     /* check if line was completely read and is terminated by line break */
5687     if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
5688       line_nr++;
5689
5690     /* cut trailing line break (this can be newline and/or carriage return) */
5691     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
5692       if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
5693         *line_ptr = '\0';
5694
5695     /* copy raw input line for later use (mainly debugging output) */
5696     strcpy(line_raw, line);
5697
5698     if (read_continued_line)
5699     {
5700       /* append new line to existing line, if there is enough space */
5701       if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
5702         strcat(previous_line, line_ptr);
5703
5704       strcpy(line, previous_line);      /* copy storage buffer to line */
5705
5706       read_continued_line = FALSE;
5707     }
5708
5709     /* if the last character is '\', continue at next line */
5710     if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
5711     {
5712       line[strlen(line) - 1] = '\0';    /* cut off trailing backslash */
5713       strcpy(previous_line, line);      /* copy line to storage buffer */
5714
5715       read_continued_line = TRUE;
5716
5717       continue;
5718     }
5719
5720     /* skip empty lines */
5721     if (line[0] == '\0')
5722       continue;
5723
5724     /* extract comment text from comment line */
5725     if (line[0] == ';')
5726     {
5727       for (line_ptr = line; *line_ptr; line_ptr++)
5728         if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != ';')
5729           break;
5730
5731       strcpy(last_comment, line_ptr);
5732
5733       continue;
5734     }
5735
5736     /* extract level title text from line containing level title */
5737     if (line[0] == '\'')
5738     {
5739       strcpy(level_name, &line[1]);
5740
5741       if (strlen(level_name) > 0 && level_name[strlen(level_name) - 1] == '\'')
5742         level_name[strlen(level_name) - 1] = '\0';
5743
5744       continue;
5745     }
5746
5747     /* skip lines containing only spaces (or empty lines) */
5748     for (line_ptr = line; *line_ptr; line_ptr++)
5749       if (*line_ptr != ' ')
5750         break;
5751     if (*line_ptr == '\0')
5752       continue;
5753
5754     /* at this point, we have found a line containing part of a playfield */
5755
5756     got_valid_playfield_line = TRUE;
5757
5758     if (!reading_playfield)
5759     {
5760       reading_playfield = TRUE;
5761       invalid_playfield_char = FALSE;
5762
5763       for (x = 0; x < MAX_LEV_FIELDX; x++)
5764         for (y = 0; y < MAX_LEV_FIELDY; y++)
5765           level->field[x][y] = getMappedElement_SB(' ', load_xsb_to_ces);
5766
5767       level->fieldx = 0;
5768       level->fieldy = 0;
5769
5770       /* start with topmost tile row */
5771       y = 0;
5772     }
5773
5774     /* skip playfield line if larger row than allowed */
5775     if (y >= MAX_LEV_FIELDY)
5776       continue;
5777
5778     /* start with leftmost tile column */
5779     x = 0;
5780
5781     /* read playfield elements from line */
5782     for (line_ptr = line; *line_ptr; line_ptr++)
5783     {
5784       int mapped_sb_element = getMappedElement_SB(*line_ptr, load_xsb_to_ces);
5785
5786       /* stop parsing playfield line if larger column than allowed */
5787       if (x >= MAX_LEV_FIELDX)
5788         break;
5789
5790       if (mapped_sb_element == EL_UNDEFINED)
5791       {
5792         invalid_playfield_char = TRUE;
5793
5794         break;
5795       }
5796
5797       level->field[x][y] = mapped_sb_element;
5798
5799       /* continue with next tile column */
5800       x++;
5801
5802       level->fieldx = MAX(x, level->fieldx);
5803     }
5804
5805     if (invalid_playfield_char)
5806     {
5807       /* if first playfield line, treat invalid lines as comment lines */
5808       if (y == 0)
5809         reading_playfield = FALSE;
5810
5811       continue;
5812     }
5813
5814     /* continue with next tile row */
5815     y++;
5816   }
5817
5818   closeFile(file);
5819
5820   level->fieldy = y;
5821
5822   level->fieldx = MIN(MAX(MIN_LEV_FIELDX, level->fieldx), MAX_LEV_FIELDX);
5823   level->fieldy = MIN(MAX(MIN_LEV_FIELDY, level->fieldy), MAX_LEV_FIELDY);
5824
5825   if (!reading_playfield)
5826   {
5827     level->no_valid_file = TRUE;
5828
5829     Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
5830
5831     return;
5832   }
5833
5834   if (*level_name != '\0')
5835   {
5836     strncpy(level->name, level_name, MAX_LEVEL_NAME_LEN);
5837     level->name[MAX_LEVEL_NAME_LEN] = '\0';
5838   }
5839   else if (*last_comment != '\0')
5840   {
5841     strncpy(level->name, last_comment, MAX_LEVEL_NAME_LEN);
5842     level->name[MAX_LEVEL_NAME_LEN] = '\0';
5843   }
5844   else
5845   {
5846     sprintf(level->name, "--> Level %d <--", level_file_info->nr);
5847   }
5848
5849   /* set all empty fields beyond the border walls to invisible steel wall */
5850   for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
5851   {
5852     if ((x == 0 || x == level->fieldx - 1 ||
5853          y == 0 || y == level->fieldy - 1) &&
5854         level->field[x][y] == getMappedElement_SB(' ', load_xsb_to_ces))
5855       FloodFillLevel(x, y, getMappedElement_SB('_', load_xsb_to_ces),
5856                      level->field, level->fieldx, level->fieldy);
5857   }
5858
5859   /* set special level settings for Sokoban levels */
5860
5861   level->time = 0;
5862   level->use_step_counter = TRUE;
5863
5864   if (load_xsb_to_ces)
5865   {
5866     /* special global settings can now be set in level template */
5867
5868     level->use_custom_template = TRUE;
5869   }
5870 }
5871
5872
5873 /* ------------------------------------------------------------------------- */
5874 /* functions for handling native levels                                      */
5875 /* ------------------------------------------------------------------------- */
5876
5877 static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
5878                                      struct LevelFileInfo *level_file_info,
5879                                      boolean level_info_only)
5880 {
5881   if (!LoadNativeLevel_EM(level_file_info->filename, level_info_only))
5882     level->no_valid_file = TRUE;
5883 }
5884
5885 static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
5886                                      struct LevelFileInfo *level_file_info,
5887                                      boolean level_info_only)
5888 {
5889   int pos = 0;
5890
5891   /* determine position of requested level inside level package */
5892   if (level_file_info->packed)
5893     pos = level_file_info->nr - leveldir_current->first_level;
5894
5895   if (!LoadNativeLevel_SP(level_file_info->filename, pos, level_info_only))
5896     level->no_valid_file = TRUE;
5897 }
5898
5899 void CopyNativeLevel_RND_to_Native(struct LevelInfo *level)
5900 {
5901   if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
5902     CopyNativeLevel_RND_to_EM(level);
5903   else if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
5904     CopyNativeLevel_RND_to_SP(level);
5905 }
5906
5907 void CopyNativeLevel_Native_to_RND(struct LevelInfo *level)
5908 {
5909   if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
5910     CopyNativeLevel_EM_to_RND(level);
5911   else if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
5912     CopyNativeLevel_SP_to_RND(level);
5913 }
5914
5915 void SaveNativeLevel(struct LevelInfo *level)
5916 {
5917   if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
5918   {
5919     char *basename = getSingleLevelBasenameExt(level->file_info.nr, "sp");
5920     char *filename = getLevelFilenameFromBasename(basename);
5921
5922     CopyNativeLevel_RND_to_SP(level);
5923     CopyNativeTape_RND_to_SP(level);
5924
5925     SaveNativeLevel_SP(filename);
5926   }
5927 }
5928
5929
5930 /* ------------------------------------------------------------------------- */
5931 /* functions for loading generic level                                       */
5932 /* ------------------------------------------------------------------------- */
5933
5934 static void LoadLevelFromFileInfo(struct LevelInfo *level,
5935                                   struct LevelFileInfo *level_file_info,
5936                                   boolean level_info_only)
5937 {
5938   /* always start with reliable default values */
5939   setLevelInfoToDefaults(level, level_info_only, TRUE);
5940
5941   switch (level_file_info->type)
5942   {
5943     case LEVEL_FILE_TYPE_RND:
5944       LoadLevelFromFileInfo_RND(level, level_file_info, level_info_only);
5945       break;
5946
5947     case LEVEL_FILE_TYPE_EM:
5948       LoadLevelFromFileInfo_EM(level, level_file_info, level_info_only);
5949       level->game_engine_type = GAME_ENGINE_TYPE_EM;
5950       break;
5951
5952     case LEVEL_FILE_TYPE_SP:
5953       LoadLevelFromFileInfo_SP(level, level_file_info, level_info_only);
5954       level->game_engine_type = GAME_ENGINE_TYPE_SP;
5955       break;
5956
5957     case LEVEL_FILE_TYPE_DC:
5958       LoadLevelFromFileInfo_DC(level, level_file_info, level_info_only);
5959       break;
5960
5961     case LEVEL_FILE_TYPE_SB:
5962       LoadLevelFromFileInfo_SB(level, level_file_info, level_info_only);
5963       break;
5964
5965     default:
5966       LoadLevelFromFileInfo_RND(level, level_file_info, level_info_only);
5967       break;
5968   }
5969
5970   /* if level file is invalid, restore level structure to default values */
5971   if (level->no_valid_file)
5972     setLevelInfoToDefaults(level, level_info_only, FALSE);
5973
5974   if (level->game_engine_type == GAME_ENGINE_TYPE_UNKNOWN)
5975     level->game_engine_type = GAME_ENGINE_TYPE_RND;
5976
5977   if (level_file_info->type != LEVEL_FILE_TYPE_RND)
5978     CopyNativeLevel_Native_to_RND(level);
5979 }
5980
5981 void LoadLevelFromFilename(struct LevelInfo *level, char *filename)
5982 {
5983   static struct LevelFileInfo level_file_info;
5984
5985   /* always start with reliable default values */
5986   setFileInfoToDefaults(&level_file_info);
5987
5988   level_file_info.nr = 0;                       /* unknown level number */
5989   level_file_info.type = LEVEL_FILE_TYPE_RND;   /* no others supported yet */
5990   level_file_info.filename = filename;
5991
5992   LoadLevelFromFileInfo(level, &level_file_info, FALSE);
5993 }
5994
5995 static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
5996 {
5997   int i, j;
5998
5999   if (leveldir_current == NULL)         /* only when dumping level */
6000     return;
6001
6002   /* all engine modifications also valid for levels which use latest engine */
6003   if (level->game_version < VERSION_IDENT(3,2,0,5))
6004   {
6005     /* time bonus score was given for 10 s instead of 1 s before 3.2.0-5 */
6006     level->score[SC_TIME_BONUS] /= 10;
6007   }
6008
6009   if (leveldir_current->latest_engine)
6010   {
6011     /* ---------- use latest game engine ----------------------------------- */
6012
6013     /* For all levels which are forced to use the latest game engine version
6014        (normally all but user contributed, private and undefined levels), set
6015        the game engine version to the actual version; this allows for actual
6016        corrections in the game engine to take effect for existing, converted
6017        levels (from "classic" or other existing games) to make the emulation
6018        of the corresponding game more accurate, while (hopefully) not breaking
6019        existing levels created from other players. */
6020
6021     level->game_version = GAME_VERSION_ACTUAL;
6022
6023     /* Set special EM style gems behaviour: EM style gems slip down from
6024        normal, steel and growing wall. As this is a more fundamental change,
6025        it seems better to set the default behaviour to "off" (as it is more
6026        natural) and make it configurable in the level editor (as a property
6027        of gem style elements). Already existing converted levels (neither
6028        private nor contributed levels) are changed to the new behaviour. */
6029
6030     if (level->file_version < FILE_VERSION_2_0)
6031       level->em_slippery_gems = TRUE;
6032
6033     return;
6034   }
6035
6036   /* ---------- use game engine the level was created with ----------------- */
6037
6038   /* For all levels which are not forced to use the latest game engine
6039      version (normally user contributed, private and undefined levels),
6040      use the version of the game engine the levels were created for.
6041
6042      Since 2.0.1, the game engine version is now directly stored
6043      in the level file (chunk "VERS"), so there is no need anymore
6044      to set the game version from the file version (except for old,
6045      pre-2.0 levels, where the game version is still taken from the
6046      file format version used to store the level -- see above). */
6047
6048   /* player was faster than enemies in 1.0.0 and before */
6049   if (level->file_version == FILE_VERSION_1_0)
6050     for (i = 0; i < MAX_PLAYERS; i++)
6051       level->initial_player_stepsize[i] = STEPSIZE_FAST;
6052
6053   /* default behaviour for EM style gems was "slippery" only in 2.0.1 */
6054   if (level->game_version == VERSION_IDENT(2,0,1,0))
6055     level->em_slippery_gems = TRUE;
6056
6057   /* springs could be pushed over pits before (pre-release version) 2.2.0 */
6058   if (level->game_version < VERSION_IDENT(2,2,0,0))
6059     level->use_spring_bug = TRUE;
6060
6061   if (level->game_version < VERSION_IDENT(3,2,0,5))
6062   {
6063     /* time orb caused limited time in endless time levels before 3.2.0-5 */
6064     level->use_time_orb_bug = TRUE;
6065
6066     /* default behaviour for snapping was "no snap delay" before 3.2.0-5 */
6067     level->block_snap_field = FALSE;
6068
6069     /* extra time score was same value as time left score before 3.2.0-5 */
6070     level->extra_time_score = level->score[SC_TIME_BONUS];
6071   }
6072
6073   if (level->game_version < VERSION_IDENT(3,2,0,7))
6074   {
6075     /* default behaviour for snapping was "not continuous" before 3.2.0-7 */
6076     level->continuous_snapping = FALSE;
6077   }
6078
6079   /* only few elements were able to actively move into acid before 3.1.0 */
6080   /* trigger settings did not exist before 3.1.0; set to default "any" */
6081   if (level->game_version < VERSION_IDENT(3,1,0,0))
6082   {
6083     /* correct "can move into acid" settings (all zero in old levels) */
6084
6085     level->can_move_into_acid_bits = 0; /* nothing can move into acid */
6086     level->dont_collide_with_bits = 0; /* nothing is deadly when colliding */
6087
6088     setMoveIntoAcidProperty(level, EL_ROBOT,     TRUE);
6089     setMoveIntoAcidProperty(level, EL_SATELLITE, TRUE);
6090     setMoveIntoAcidProperty(level, EL_PENGUIN,   TRUE);
6091     setMoveIntoAcidProperty(level, EL_BALLOON,   TRUE);
6092
6093     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6094       SET_PROPERTY(EL_CUSTOM_START + i, EP_CAN_MOVE_INTO_ACID, TRUE);
6095
6096     /* correct trigger settings (stored as zero == "none" in old levels) */
6097
6098     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6099     {
6100       int element = EL_CUSTOM_START + i;
6101       struct ElementInfo *ei = &element_info[element];
6102
6103       for (j = 0; j < ei->num_change_pages; j++)
6104       {
6105         struct ElementChangeInfo *change = &ei->change_page[j];
6106
6107         change->trigger_player = CH_PLAYER_ANY;
6108         change->trigger_page = CH_PAGE_ANY;
6109       }
6110     }
6111   }
6112
6113   /* try to detect and fix "Snake Bite" levels, which are broken with 3.2.0 */
6114   {
6115     int element = EL_CUSTOM_256;
6116     struct ElementInfo *ei = &element_info[element];
6117     struct ElementChangeInfo *change = &ei->change_page[0];
6118
6119     /* This is needed to fix a problem that was caused by a bugfix in function
6120        game.c/CreateFieldExt() introduced with 3.2.0 that corrects the behaviour
6121        when a custom element changes to EL_SOKOBAN_FIELD_PLAYER (before, it did
6122        not replace walkable elements, but instead just placed the player on it,
6123        without placing the Sokoban field under the player). Unfortunately, this
6124        breaks "Snake Bite" style levels when the snake is halfway through a door
6125        that just closes (the snake head is still alive and can be moved in this
6126        case). This can be fixed by replacing the EL_SOKOBAN_FIELD_PLAYER by the
6127        player (without Sokoban element) which then gets killed as designed). */
6128
6129     if ((strncmp(leveldir_current->identifier, "snake_bite", 10) == 0 ||
6130          strncmp(ei->description, "pause b4 death", 14) == 0) &&
6131         change->target_element == EL_SOKOBAN_FIELD_PLAYER)
6132       change->target_element = EL_PLAYER_1;
6133   }
6134
6135   /* try to detect and fix "Zelda" style levels, which are broken with 3.2.5 */
6136   if (level->game_version < VERSION_IDENT(3,2,5,0))
6137   {
6138     /* This is needed to fix a problem that was caused by a bugfix in function
6139        game.c/CheckTriggeredElementChangeExt() introduced with 3.2.5 that
6140        corrects the behaviour when a custom element changes to another custom
6141        element with a higher element number that has change actions defined.
6142        Normally, only one change per frame is allowed for custom elements.
6143        Therefore, it is checked if a custom element already changed in the
6144        current frame; if it did, subsequent changes are suppressed.
6145        Unfortunately, this is only checked for element changes, but not for
6146        change actions, which are still executed. As the function above loops
6147        through all custom elements from lower to higher, an element change
6148        resulting in a lower CE number won't be checked again, while a target
6149        element with a higher number will also be checked, and potential change
6150        actions will get executed for this CE, too (which is wrong), while
6151        further changes are ignored (which is correct). As this bugfix breaks
6152        Zelda II (and introduces graphical bugs to Zelda I, and also breaks a
6153        few other levels like Alan Bond's "FMV"), allow the previous, incorrect
6154        behaviour for existing levels and tapes that make use of this bug */
6155
6156     level->use_action_after_change_bug = TRUE;
6157   }
6158
6159   /* not centering level after relocating player was default only in 3.2.3 */
6160   if (level->game_version == VERSION_IDENT(3,2,3,0))    /* (no pre-releases) */
6161     level->shifted_relocation = TRUE;
6162
6163   /* EM style elements always chain-exploded in R'n'D engine before 3.2.6 */
6164   if (level->game_version < VERSION_IDENT(3,2,6,0))
6165     level->em_explodes_by_fire = TRUE;
6166 }
6167
6168 static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
6169 {
6170   int i, j, x, y;
6171
6172   /* map custom element change events that have changed in newer versions
6173      (these following values were accidentally changed in version 3.0.1)
6174      (this seems to be needed only for 'ab_levelset3' and 'ab_levelset4') */
6175   if (level->game_version <= VERSION_IDENT(3,0,0,0))
6176   {
6177     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6178     {
6179       int element = EL_CUSTOM_START + i;
6180
6181       /* order of checking and copying events to be mapped is important */
6182       /* (do not change the start and end value -- they are constant) */
6183       for (j = CE_BY_OTHER_ACTION; j >= CE_VALUE_GETS_ZERO; j--)
6184       {
6185         if (HAS_CHANGE_EVENT(element, j - 2))
6186         {
6187           SET_CHANGE_EVENT(element, j - 2, FALSE);
6188           SET_CHANGE_EVENT(element, j, TRUE);
6189         }
6190       }
6191
6192       /* order of checking and copying events to be mapped is important */
6193       /* (do not change the start and end value -- they are constant) */
6194       for (j = CE_PLAYER_COLLECTS_X; j >= CE_HITTING_SOMETHING; j--)
6195       {
6196         if (HAS_CHANGE_EVENT(element, j - 1))
6197         {
6198           SET_CHANGE_EVENT(element, j - 1, FALSE);
6199           SET_CHANGE_EVENT(element, j, TRUE);
6200         }
6201       }
6202     }
6203   }
6204
6205   /* initialize "can_change" field for old levels with only one change page */
6206   if (level->game_version <= VERSION_IDENT(3,0,2,0))
6207   {
6208     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6209     {
6210       int element = EL_CUSTOM_START + i;
6211
6212       if (CAN_CHANGE(element))
6213         element_info[element].change->can_change = TRUE;
6214     }
6215   }
6216
6217   /* correct custom element values (for old levels without these options) */
6218   if (level->game_version < VERSION_IDENT(3,1,1,0))
6219   {
6220     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6221     {
6222       int element = EL_CUSTOM_START + i;
6223       struct ElementInfo *ei = &element_info[element];
6224
6225       if (ei->access_direction == MV_NO_DIRECTION)
6226         ei->access_direction = MV_ALL_DIRECTIONS;
6227     }
6228   }
6229
6230   /* correct custom element values (fix invalid values for all versions) */
6231   if (1)
6232   {
6233     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6234     {
6235       int element = EL_CUSTOM_START + i;
6236       struct ElementInfo *ei = &element_info[element];
6237
6238       for (j = 0; j < ei->num_change_pages; j++)
6239       {
6240         struct ElementChangeInfo *change = &ei->change_page[j];
6241
6242         if (change->trigger_player == CH_PLAYER_NONE)
6243           change->trigger_player = CH_PLAYER_ANY;
6244
6245         if (change->trigger_side == CH_SIDE_NONE)
6246           change->trigger_side = CH_SIDE_ANY;
6247       }
6248     }
6249   }
6250
6251   /* initialize "can_explode" field for old levels which did not store this */
6252   /* !!! CHECK THIS -- "<= 3,1,0,0" IS PROBABLY WRONG !!! */
6253   if (level->game_version <= VERSION_IDENT(3,1,0,0))
6254   {
6255     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6256     {
6257       int element = EL_CUSTOM_START + i;
6258
6259       if (EXPLODES_1X1_OLD(element))
6260         element_info[element].explosion_type = EXPLODES_1X1;
6261
6262       SET_PROPERTY(element, EP_CAN_EXPLODE, (EXPLODES_BY_FIRE(element) ||
6263                                              EXPLODES_SMASHED(element) ||
6264                                              EXPLODES_IMPACT(element)));
6265     }
6266   }
6267
6268   /* correct previously hard-coded move delay values for maze runner style */
6269   if (level->game_version < VERSION_IDENT(3,1,1,0))
6270   {
6271     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6272     {
6273       int element = EL_CUSTOM_START + i;
6274
6275       if (element_info[element].move_pattern & MV_MAZE_RUNNER_STYLE)
6276       {
6277         /* previously hard-coded and therefore ignored */
6278         element_info[element].move_delay_fixed = 9;
6279         element_info[element].move_delay_random = 0;
6280       }
6281     }
6282   }
6283
6284   /* map elements that have changed in newer versions */
6285   level->amoeba_content = getMappedElementByVersion(level->amoeba_content,
6286                                                     level->game_version);
6287   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6288     for (x = 0; x < 3; x++)
6289       for (y = 0; y < 3; y++)
6290         level->yamyam_content[i].e[x][y] =
6291           getMappedElementByVersion(level->yamyam_content[i].e[x][y],
6292                                     level->game_version);
6293
6294   /* initialize element properties for level editor etc. */
6295   InitElementPropertiesEngine(level->game_version);
6296   InitElementPropertiesAfterLoading(level->game_version);
6297   InitElementPropertiesGfxElement();
6298 }
6299
6300 static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename)
6301 {
6302   int x, y;
6303
6304   /* map elements that have changed in newer versions */
6305   for (y = 0; y < level->fieldy; y++)
6306     for (x = 0; x < level->fieldx; x++)
6307       level->field[x][y] = getMappedElementByVersion(level->field[x][y],
6308                                                      level->game_version);
6309
6310   /* clear unused playfield data (nicer if level gets resized in editor) */
6311   for (x = 0; x < MAX_LEV_FIELDX; x++)
6312     for (y = 0; y < MAX_LEV_FIELDY; y++)
6313       if (x >= level->fieldx || y >= level->fieldy)
6314         level->field[x][y] = EL_EMPTY;
6315
6316   /* copy elements to runtime playfield array */
6317   for (x = 0; x < MAX_LEV_FIELDX; x++)
6318     for (y = 0; y < MAX_LEV_FIELDY; y++)
6319       Feld[x][y] = level->field[x][y];
6320
6321   /* initialize level size variables for faster access */
6322   lev_fieldx = level->fieldx;
6323   lev_fieldy = level->fieldy;
6324
6325   /* determine border element for this level */
6326   if (level->file_info.type == LEVEL_FILE_TYPE_DC)
6327     BorderElement = EL_EMPTY;   /* (in editor, SetBorderElement() is used) */
6328   else
6329     SetBorderElement();
6330 }
6331
6332 static void LoadLevel_InitNativeEngines(struct LevelInfo *level,char *filename)
6333 {
6334   struct LevelFileInfo *level_file_info = &level->file_info;
6335
6336   if (level_file_info->type == LEVEL_FILE_TYPE_RND)
6337     CopyNativeLevel_RND_to_Native(level);
6338 }
6339
6340 void LoadLevelTemplate(int nr)
6341 {
6342   char *filename;
6343
6344   setLevelFileInfo(&level_template.file_info, nr);
6345   filename = level_template.file_info.filename;
6346
6347   LoadLevelFromFileInfo(&level_template, &level_template.file_info, FALSE);
6348
6349   LoadLevel_InitVersion(&level_template, filename);
6350   LoadLevel_InitElements(&level_template, filename);
6351
6352   ActivateLevelTemplate();
6353 }
6354
6355 void LoadLevel(int nr)
6356 {
6357   char *filename;
6358
6359   setLevelFileInfo(&level.file_info, nr);
6360   filename = level.file_info.filename;
6361
6362   LoadLevelFromFileInfo(&level, &level.file_info, FALSE);
6363
6364   if (level.use_custom_template)
6365     LoadLevelTemplate(-1);
6366
6367   LoadLevel_InitVersion(&level, filename);
6368   LoadLevel_InitElements(&level, filename);
6369   LoadLevel_InitPlayfield(&level, filename);
6370
6371   LoadLevel_InitNativeEngines(&level, filename);
6372 }
6373
6374 void LoadLevelInfoOnly(int nr)
6375 {
6376   setLevelFileInfo(&level.file_info, nr);
6377
6378   LoadLevelFromFileInfo(&level, &level.file_info, TRUE);
6379 }
6380
6381 static int SaveLevel_VERS(FILE *file, struct LevelInfo *level)
6382 {
6383   int chunk_size = 0;
6384
6385   chunk_size += putFileVersion(file, level->file_version);
6386   chunk_size += putFileVersion(file, level->game_version);
6387
6388   return chunk_size;
6389 }
6390
6391 static int SaveLevel_DATE(FILE *file, struct LevelInfo *level)
6392 {
6393   int chunk_size = 0;
6394
6395   chunk_size += putFile16BitBE(file, level->creation_date.year);
6396   chunk_size += putFile8Bit(file,    level->creation_date.month);
6397   chunk_size += putFile8Bit(file,    level->creation_date.day);
6398
6399   return chunk_size;
6400 }
6401
6402 #if ENABLE_HISTORIC_CHUNKS
6403 static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
6404 {
6405   int i, x, y;
6406
6407   putFile8Bit(file, level->fieldx);
6408   putFile8Bit(file, level->fieldy);
6409
6410   putFile16BitBE(file, level->time);
6411   putFile16BitBE(file, level->gems_needed);
6412
6413   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
6414     putFile8Bit(file, level->name[i]);
6415
6416   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
6417     putFile8Bit(file, level->score[i]);
6418
6419   for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
6420     for (y = 0; y < 3; y++)
6421       for (x = 0; x < 3; x++)
6422         putFile8Bit(file, (level->encoding_16bit_yamyam ? EL_EMPTY :
6423                            level->yamyam_content[i].e[x][y]));
6424   putFile8Bit(file, level->amoeba_speed);
6425   putFile8Bit(file, level->time_magic_wall);
6426   putFile8Bit(file, level->time_wheel);
6427   putFile8Bit(file, (level->encoding_16bit_amoeba ? EL_EMPTY :
6428                      level->amoeba_content));
6429   putFile8Bit(file, (level->initial_player_stepsize == STEPSIZE_FAST ? 1 : 0));
6430   putFile8Bit(file, (level->initial_gravity ? 1 : 0));
6431   putFile8Bit(file, (level->encoding_16bit_field ? 1 : 0));
6432   putFile8Bit(file, (level->em_slippery_gems ? 1 : 0));
6433
6434   putFile8Bit(file, (level->use_custom_template ? 1 : 0));
6435
6436   putFile8Bit(file, (level->block_last_field ? 1 : 0));
6437   putFile8Bit(file, (level->sp_block_last_field ? 1 : 0));
6438   putFile32BitBE(file, level->can_move_into_acid_bits);
6439   putFile8Bit(file, level->dont_collide_with_bits);
6440
6441   putFile8Bit(file, (level->use_spring_bug ? 1 : 0));
6442   putFile8Bit(file, (level->use_step_counter ? 1 : 0));
6443
6444   putFile8Bit(file, (level->instant_relocation ? 1 : 0));
6445   putFile8Bit(file, (level->can_pass_to_walkable ? 1 : 0));
6446   putFile8Bit(file, (level->grow_into_diggable ? 1 : 0));
6447
6448   putFile8Bit(file, level->game_engine_type);
6449
6450   WriteUnusedBytesToFile(file, LEVEL_CHUNK_HEAD_UNUSED);
6451 }
6452 #endif
6453
6454 static int SaveLevel_NAME(FILE *file, struct LevelInfo *level)
6455 {
6456   int chunk_size = 0;
6457   int i;
6458
6459   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
6460     chunk_size += putFile8Bit(file, level->name[i]);
6461
6462   return chunk_size;
6463 }
6464
6465 static int SaveLevel_AUTH(FILE *file, struct LevelInfo *level)
6466 {
6467   int chunk_size = 0;
6468   int i;
6469
6470   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
6471     chunk_size += putFile8Bit(file, level->author[i]);
6472
6473   return chunk_size;
6474 }
6475
6476 #if ENABLE_HISTORIC_CHUNKS
6477 static int SaveLevel_BODY(FILE *file, struct LevelInfo *level)
6478 {
6479   int chunk_size = 0;
6480   int x, y;
6481
6482   for (y = 0; y < level->fieldy; y++)
6483     for (x = 0; x < level->fieldx; x++)
6484       if (level->encoding_16bit_field)
6485         chunk_size += putFile16BitBE(file, level->field[x][y]);
6486       else
6487         chunk_size += putFile8Bit(file, level->field[x][y]);
6488
6489   return chunk_size;
6490 }
6491 #endif
6492
6493 static int SaveLevel_BODY(FILE *file, struct LevelInfo *level)
6494 {
6495   int chunk_size = 0;
6496   int x, y;
6497
6498   for (y = 0; y < level->fieldy; y++)
6499     for (x = 0; x < level->fieldx; x++)
6500       chunk_size += putFile16BitBE(file, level->field[x][y]);
6501
6502   return chunk_size;
6503 }
6504
6505 #if ENABLE_HISTORIC_CHUNKS
6506 static void SaveLevel_CONT(FILE *file, struct LevelInfo *level)
6507 {
6508   int i, x, y;
6509
6510   putFile8Bit(file, EL_YAMYAM);
6511   putFile8Bit(file, level->num_yamyam_contents);
6512   putFile8Bit(file, 0);
6513   putFile8Bit(file, 0);
6514
6515   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6516     for (y = 0; y < 3; y++)
6517       for (x = 0; x < 3; x++)
6518         if (level->encoding_16bit_field)
6519           putFile16BitBE(file, level->yamyam_content[i].e[x][y]);
6520         else
6521           putFile8Bit(file, level->yamyam_content[i].e[x][y]);
6522 }
6523 #endif
6524
6525 #if ENABLE_HISTORIC_CHUNKS
6526 static void SaveLevel_CNT2(FILE *file, struct LevelInfo *level, int element)
6527 {
6528   int i, x, y;
6529   int num_contents, content_xsize, content_ysize;
6530   int content_array[MAX_ELEMENT_CONTENTS][3][3];
6531
6532   if (element == EL_YAMYAM)
6533   {
6534     num_contents = level->num_yamyam_contents;
6535     content_xsize = 3;
6536     content_ysize = 3;
6537
6538     for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6539       for (y = 0; y < 3; y++)
6540         for (x = 0; x < 3; x++)
6541           content_array[i][x][y] = level->yamyam_content[i].e[x][y];
6542   }
6543   else if (element == EL_BD_AMOEBA)
6544   {
6545     num_contents = 1;
6546     content_xsize = 1;
6547     content_ysize = 1;
6548
6549     for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6550       for (y = 0; y < 3; y++)
6551         for (x = 0; x < 3; x++)
6552           content_array[i][x][y] = EL_EMPTY;
6553     content_array[0][0][0] = level->amoeba_content;
6554   }
6555   else
6556   {
6557     /* chunk header already written -- write empty chunk data */
6558     WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_SIZE);
6559
6560     Error(ERR_WARN, "cannot save content for element '%d'", element);
6561     return;
6562   }
6563
6564   putFile16BitBE(file, element);
6565   putFile8Bit(file, num_contents);
6566   putFile8Bit(file, content_xsize);
6567   putFile8Bit(file, content_ysize);
6568
6569   WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_UNUSED);
6570
6571   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6572     for (y = 0; y < 3; y++)
6573       for (x = 0; x < 3; x++)
6574         putFile16BitBE(file, content_array[i][x][y]);
6575 }
6576 #endif
6577
6578 #if ENABLE_HISTORIC_CHUNKS
6579 static int SaveLevel_CNT3(FILE *file, struct LevelInfo *level, int element)
6580 {
6581   int envelope_nr = element - EL_ENVELOPE_1;
6582   int envelope_len = strlen(level->envelope_text[envelope_nr]) + 1;
6583   int chunk_size = 0;
6584   int i;
6585
6586   chunk_size += putFile16BitBE(file, element);
6587   chunk_size += putFile16BitBE(file, envelope_len);
6588   chunk_size += putFile8Bit(file, level->envelope_xsize[envelope_nr]);
6589   chunk_size += putFile8Bit(file, level->envelope_ysize[envelope_nr]);
6590
6591   WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT3_UNUSED);
6592   chunk_size += LEVEL_CHUNK_CNT3_UNUSED;
6593
6594   for (i = 0; i < envelope_len; i++)
6595     chunk_size += putFile8Bit(file, level->envelope_text[envelope_nr][i]);
6596
6597   return chunk_size;
6598 }
6599 #endif
6600
6601 #if ENABLE_HISTORIC_CHUNKS
6602 static void SaveLevel_CUS1(FILE *file, struct LevelInfo *level,
6603                            int num_changed_custom_elements)
6604 {
6605   int i, check = 0;
6606
6607   putFile16BitBE(file, num_changed_custom_elements);
6608
6609   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6610   {
6611     int element = EL_CUSTOM_START + i;
6612
6613     struct ElementInfo *ei = &element_info[element];
6614
6615     if (ei->properties[EP_BITFIELD_BASE_NR] != EP_BITMASK_DEFAULT)
6616     {
6617       if (check < num_changed_custom_elements)
6618       {
6619         putFile16BitBE(file, element);
6620         putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
6621       }
6622
6623       check++;
6624     }
6625   }
6626
6627   if (check != num_changed_custom_elements)     /* should not happen */
6628     Error(ERR_WARN, "inconsistent number of custom element properties");
6629 }
6630 #endif
6631
6632 #if ENABLE_HISTORIC_CHUNKS
6633 static void SaveLevel_CUS2(FILE *file, struct LevelInfo *level,
6634                            int num_changed_custom_elements)
6635 {
6636   int i, check = 0;
6637
6638   putFile16BitBE(file, num_changed_custom_elements);
6639
6640   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6641   {
6642     int element = EL_CUSTOM_START + i;
6643
6644     if (element_info[element].change->target_element != EL_EMPTY_SPACE)
6645     {
6646       if (check < num_changed_custom_elements)
6647       {
6648         putFile16BitBE(file, element);
6649         putFile16BitBE(file, element_info[element].change->target_element);
6650       }
6651
6652       check++;
6653     }
6654   }
6655
6656   if (check != num_changed_custom_elements)     /* should not happen */
6657     Error(ERR_WARN, "inconsistent number of custom target elements");
6658 }
6659 #endif
6660
6661 #if ENABLE_HISTORIC_CHUNKS
6662 static void SaveLevel_CUS3(FILE *file, struct LevelInfo *level,
6663                            int num_changed_custom_elements)
6664 {
6665   int i, j, x, y, check = 0;
6666
6667   putFile16BitBE(file, num_changed_custom_elements);
6668
6669   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6670   {
6671     int element = EL_CUSTOM_START + i;
6672     struct ElementInfo *ei = &element_info[element];
6673
6674     if (ei->modified_settings)
6675     {
6676       if (check < num_changed_custom_elements)
6677       {
6678         putFile16BitBE(file, element);
6679
6680         for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
6681           putFile8Bit(file, ei->description[j]);
6682
6683         putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
6684
6685         /* some free bytes for future properties and padding */
6686         WriteUnusedBytesToFile(file, 7);
6687
6688         putFile8Bit(file, ei->use_gfx_element);
6689         putFile16BitBE(file, ei->gfx_element_initial);
6690
6691         putFile8Bit(file, ei->collect_score_initial);
6692         putFile8Bit(file, ei->collect_count_initial);
6693
6694         putFile16BitBE(file, ei->push_delay_fixed);
6695         putFile16BitBE(file, ei->push_delay_random);
6696         putFile16BitBE(file, ei->move_delay_fixed);
6697         putFile16BitBE(file, ei->move_delay_random);
6698
6699         putFile16BitBE(file, ei->move_pattern);
6700         putFile8Bit(file, ei->move_direction_initial);
6701         putFile8Bit(file, ei->move_stepsize);
6702
6703         for (y = 0; y < 3; y++)
6704           for (x = 0; x < 3; x++)
6705             putFile16BitBE(file, ei->content.e[x][y]);
6706
6707         putFile32BitBE(file, ei->change->events);
6708
6709         putFile16BitBE(file, ei->change->target_element);
6710
6711         putFile16BitBE(file, ei->change->delay_fixed);
6712         putFile16BitBE(file, ei->change->delay_random);
6713         putFile16BitBE(file, ei->change->delay_frames);
6714
6715         putFile16BitBE(file, ei->change->initial_trigger_element);
6716
6717         putFile8Bit(file, ei->change->explode);
6718         putFile8Bit(file, ei->change->use_target_content);
6719         putFile8Bit(file, ei->change->only_if_complete);
6720         putFile8Bit(file, ei->change->use_random_replace);
6721
6722         putFile8Bit(file, ei->change->random_percentage);
6723         putFile8Bit(file, ei->change->replace_when);
6724
6725         for (y = 0; y < 3; y++)
6726           for (x = 0; x < 3; x++)
6727             putFile16BitBE(file, ei->change->content.e[x][y]);
6728
6729         putFile8Bit(file, ei->slippery_type);
6730
6731         /* some free bytes for future properties and padding */
6732         WriteUnusedBytesToFile(file, LEVEL_CPART_CUS3_UNUSED);
6733       }
6734
6735       check++;
6736     }
6737   }
6738
6739   if (check != num_changed_custom_elements)     /* should not happen */
6740     Error(ERR_WARN, "inconsistent number of custom element properties");
6741 }
6742 #endif
6743
6744 #if ENABLE_HISTORIC_CHUNKS
6745 static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
6746 {
6747   struct ElementInfo *ei = &element_info[element];
6748   int i, j, x, y;
6749
6750   /* ---------- custom element base property values (96 bytes) ------------- */
6751
6752   putFile16BitBE(file, element);
6753
6754   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
6755     putFile8Bit(file, ei->description[i]);
6756
6757   putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
6758
6759   WriteUnusedBytesToFile(file, 4);      /* reserved for more base properties */
6760
6761   putFile8Bit(file, ei->num_change_pages);
6762
6763   putFile16BitBE(file, ei->ce_value_fixed_initial);
6764   putFile16BitBE(file, ei->ce_value_random_initial);
6765   putFile8Bit(file, ei->use_last_ce_value);
6766
6767   putFile8Bit(file, ei->use_gfx_element);
6768   putFile16BitBE(file, ei->gfx_element_initial);
6769
6770   putFile8Bit(file, ei->collect_score_initial);
6771   putFile8Bit(file, ei->collect_count_initial);
6772
6773   putFile8Bit(file, ei->drop_delay_fixed);
6774   putFile8Bit(file, ei->push_delay_fixed);
6775   putFile8Bit(file, ei->drop_delay_random);
6776   putFile8Bit(file, ei->push_delay_random);
6777   putFile16BitBE(file, ei->move_delay_fixed);
6778   putFile16BitBE(file, ei->move_delay_random);
6779
6780   /* bits 0 - 15 of "move_pattern" ... */
6781   putFile16BitBE(file, ei->move_pattern & 0xffff);
6782   putFile8Bit(file, ei->move_direction_initial);
6783   putFile8Bit(file, ei->move_stepsize);
6784
6785   putFile8Bit(file, ei->slippery_type);
6786
6787   for (y = 0; y < 3; y++)
6788     for (x = 0; x < 3; x++)
6789       putFile16BitBE(file, ei->content.e[x][y]);
6790
6791   putFile16BitBE(file, ei->move_enter_element);
6792   putFile16BitBE(file, ei->move_leave_element);
6793   putFile8Bit(file, ei->move_leave_type);
6794
6795   /* ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible) */
6796   putFile16BitBE(file, (ei->move_pattern >> 16) & 0xffff);
6797
6798   putFile8Bit(file, ei->access_direction);
6799
6800   putFile8Bit(file, ei->explosion_delay);
6801   putFile8Bit(file, ei->ignition_delay);
6802   putFile8Bit(file, ei->explosion_type);
6803
6804   /* some free bytes for future custom property values and padding */
6805   WriteUnusedBytesToFile(file, 1);
6806
6807   /* ---------- change page property values (48 bytes) --------------------- */
6808
6809   for (i = 0; i < ei->num_change_pages; i++)
6810   {
6811     struct ElementChangeInfo *change = &ei->change_page[i];
6812     unsigned int event_bits;
6813
6814     /* bits 0 - 31 of "has_event[]" ... */
6815     event_bits = 0;
6816     for (j = 0; j < MIN(NUM_CHANGE_EVENTS, 32); j++)
6817       if (change->has_event[j])
6818         event_bits |= (1 << j);
6819     putFile32BitBE(file, event_bits);
6820
6821     putFile16BitBE(file, change->target_element);
6822
6823     putFile16BitBE(file, change->delay_fixed);
6824     putFile16BitBE(file, change->delay_random);
6825     putFile16BitBE(file, change->delay_frames);
6826
6827     putFile16BitBE(file, change->initial_trigger_element);
6828
6829     putFile8Bit(file, change->explode);
6830     putFile8Bit(file, change->use_target_content);
6831     putFile8Bit(file, change->only_if_complete);
6832     putFile8Bit(file, change->use_random_replace);
6833
6834     putFile8Bit(file, change->random_percentage);
6835     putFile8Bit(file, change->replace_when);
6836
6837     for (y = 0; y < 3; y++)
6838       for (x = 0; x < 3; x++)
6839         putFile16BitBE(file, change->target_content.e[x][y]);
6840
6841     putFile8Bit(file, change->can_change);
6842
6843     putFile8Bit(file, change->trigger_side);
6844
6845     putFile8Bit(file, change->trigger_player);
6846     putFile8Bit(file, (change->trigger_page == CH_PAGE_ANY ? CH_PAGE_ANY_FILE :
6847                        log_2(change->trigger_page)));
6848
6849     putFile8Bit(file, change->has_action);
6850     putFile8Bit(file, change->action_type);
6851     putFile8Bit(file, change->action_mode);
6852     putFile16BitBE(file, change->action_arg);
6853
6854     /* ... bits 32 - 39 of "has_event[]" (not nice, but downward compatible) */
6855     event_bits = 0;
6856     for (j = 32; j < NUM_CHANGE_EVENTS; j++)
6857       if (change->has_event[j])
6858         event_bits |= (1 << (j - 32));
6859     putFile8Bit(file, event_bits);
6860   }
6861 }
6862 #endif
6863
6864 #if ENABLE_HISTORIC_CHUNKS
6865 static void SaveLevel_GRP1(FILE *file, struct LevelInfo *level, int element)
6866 {
6867   struct ElementInfo *ei = &element_info[element];
6868   struct ElementGroupInfo *group = ei->group;
6869   int i;
6870
6871   putFile16BitBE(file, element);
6872
6873   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
6874     putFile8Bit(file, ei->description[i]);
6875
6876   putFile8Bit(file, group->num_elements);
6877
6878   putFile8Bit(file, ei->use_gfx_element);
6879   putFile16BitBE(file, ei->gfx_element_initial);
6880
6881   putFile8Bit(file, group->choice_mode);
6882
6883   /* some free bytes for future values and padding */
6884   WriteUnusedBytesToFile(file, 3);
6885
6886   for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
6887     putFile16BitBE(file, group->element[i]);
6888 }
6889 #endif
6890
6891 static int SaveLevel_MicroChunk(FILE *file, struct LevelFileConfigInfo *entry,
6892                                 boolean write_element)
6893 {
6894   int save_type = entry->save_type;
6895   int data_type = entry->data_type;
6896   int conf_type = entry->conf_type;
6897   int byte_mask = conf_type & CONF_MASK_BYTES;
6898   int element = entry->element;
6899   int default_value = entry->default_value;
6900   int num_bytes = 0;
6901   boolean modified = FALSE;
6902
6903   if (byte_mask != CONF_MASK_MULTI_BYTES)
6904   {
6905     void *value_ptr = entry->value;
6906     int value = (data_type == TYPE_BOOLEAN ? *(boolean *)value_ptr :
6907                  *(int *)value_ptr);
6908
6909     /* check if any settings have been modified before saving them */
6910     if (value != default_value)
6911       modified = TRUE;
6912
6913     /* do not save if explicitly told or if unmodified default settings */
6914     if ((save_type == SAVE_CONF_NEVER) ||
6915         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6916       return 0;
6917
6918     if (write_element)
6919       num_bytes += putFile16BitBE(file, element);
6920
6921     num_bytes += putFile8Bit(file, conf_type);
6922     num_bytes += (byte_mask == CONF_MASK_1_BYTE ? putFile8Bit   (file, value) :
6923                   byte_mask == CONF_MASK_2_BYTE ? putFile16BitBE(file, value) :
6924                   byte_mask == CONF_MASK_4_BYTE ? putFile32BitBE(file, value) :
6925                   0);
6926   }
6927   else if (data_type == TYPE_STRING)
6928   {
6929     char *default_string = entry->default_string;
6930     char *string = (char *)(entry->value);
6931     int string_length = strlen(string);
6932     int i;
6933
6934     /* check if any settings have been modified before saving them */
6935     if (!strEqual(string, default_string))
6936       modified = TRUE;
6937
6938     /* do not save if explicitly told or if unmodified default settings */
6939     if ((save_type == SAVE_CONF_NEVER) ||
6940         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6941       return 0;
6942
6943     if (write_element)
6944       num_bytes += putFile16BitBE(file, element);
6945
6946     num_bytes += putFile8Bit(file, conf_type);
6947     num_bytes += putFile16BitBE(file, string_length);
6948
6949     for (i = 0; i < string_length; i++)
6950       num_bytes += putFile8Bit(file, string[i]);
6951   }
6952   else if (data_type == TYPE_ELEMENT_LIST)
6953   {
6954     int *element_array = (int *)(entry->value);
6955     int num_elements = *(int *)(entry->num_entities);
6956     int i;
6957
6958     /* check if any settings have been modified before saving them */
6959     for (i = 0; i < num_elements; i++)
6960       if (element_array[i] != default_value)
6961         modified = TRUE;
6962
6963     /* do not save if explicitly told or if unmodified default settings */
6964     if ((save_type == SAVE_CONF_NEVER) ||
6965         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6966       return 0;
6967
6968     if (write_element)
6969       num_bytes += putFile16BitBE(file, element);
6970
6971     num_bytes += putFile8Bit(file, conf_type);
6972     num_bytes += putFile16BitBE(file, num_elements * CONF_ELEMENT_NUM_BYTES);
6973
6974     for (i = 0; i < num_elements; i++)
6975       num_bytes += putFile16BitBE(file, element_array[i]);
6976   }
6977   else if (data_type == TYPE_CONTENT_LIST)
6978   {
6979     struct Content *content = (struct Content *)(entry->value);
6980     int num_contents = *(int *)(entry->num_entities);
6981     int i, x, y;
6982
6983     /* check if any settings have been modified before saving them */
6984     for (i = 0; i < num_contents; i++)
6985       for (y = 0; y < 3; y++)
6986         for (x = 0; x < 3; x++)
6987           if (content[i].e[x][y] != default_value)
6988             modified = TRUE;
6989
6990     /* do not save if explicitly told or if unmodified default settings */
6991     if ((save_type == SAVE_CONF_NEVER) ||
6992         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6993       return 0;
6994
6995     if (write_element)
6996       num_bytes += putFile16BitBE(file, element);
6997
6998     num_bytes += putFile8Bit(file, conf_type);
6999     num_bytes += putFile16BitBE(file, num_contents * CONF_CONTENT_NUM_BYTES);
7000
7001     for (i = 0; i < num_contents; i++)
7002       for (y = 0; y < 3; y++)
7003         for (x = 0; x < 3; x++)
7004           num_bytes += putFile16BitBE(file, content[i].e[x][y]);
7005   }
7006
7007   return num_bytes;
7008 }
7009
7010 static int SaveLevel_INFO(FILE *file, struct LevelInfo *level)
7011 {
7012   int chunk_size = 0;
7013   int i;
7014
7015   li = *level;          /* copy level data into temporary buffer */
7016
7017   for (i = 0; chunk_config_INFO[i].data_type != -1; i++)
7018     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_INFO[i], FALSE);
7019
7020   return chunk_size;
7021 }
7022
7023 static int SaveLevel_ELEM(FILE *file, struct LevelInfo *level)
7024 {
7025   int chunk_size = 0;
7026   int i;
7027
7028   li = *level;          /* copy level data into temporary buffer */
7029
7030   for (i = 0; chunk_config_ELEM[i].data_type != -1; i++)
7031     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_ELEM[i], TRUE);
7032
7033   return chunk_size;
7034 }
7035
7036 static int SaveLevel_NOTE(FILE *file, struct LevelInfo *level, int element)
7037 {
7038   int envelope_nr = element - EL_ENVELOPE_1;
7039   int chunk_size = 0;
7040   int i;
7041
7042   chunk_size += putFile16BitBE(file, element);
7043
7044   /* copy envelope data into temporary buffer */
7045   xx_envelope = level->envelope[envelope_nr];
7046
7047   for (i = 0; chunk_config_NOTE[i].data_type != -1; i++)
7048     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_NOTE[i], FALSE);
7049
7050   return chunk_size;
7051 }
7052
7053 static int SaveLevel_CUSX(FILE *file, struct LevelInfo *level, int element)
7054 {
7055   struct ElementInfo *ei = &element_info[element];
7056   int chunk_size = 0;
7057   int i, j;
7058
7059   chunk_size += putFile16BitBE(file, element);
7060
7061   xx_ei = *ei;          /* copy element data into temporary buffer */
7062
7063   /* set default description string for this specific element */
7064   strcpy(xx_default_description, getDefaultElementDescription(ei));
7065
7066   for (i = 0; chunk_config_CUSX_base[i].data_type != -1; i++)
7067     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_CUSX_base[i], FALSE);
7068
7069   for (i = 0; i < ei->num_change_pages; i++)
7070   {
7071     struct ElementChangeInfo *change = &ei->change_page[i];
7072
7073     xx_current_change_page = i;
7074
7075     xx_change = *change;        /* copy change data into temporary buffer */
7076
7077     resetEventBits();
7078     setEventBitsFromEventFlags(change);
7079
7080     for (j = 0; chunk_config_CUSX_change[j].data_type != -1; j++)
7081       chunk_size += SaveLevel_MicroChunk(file, &chunk_config_CUSX_change[j],
7082                                          FALSE);
7083   }
7084
7085   return chunk_size;
7086 }
7087
7088 static int SaveLevel_GRPX(FILE *file, struct LevelInfo *level, int element)
7089 {
7090   struct ElementInfo *ei = &element_info[element];
7091   struct ElementGroupInfo *group = ei->group;
7092   int chunk_size = 0;
7093   int i;
7094
7095   chunk_size += putFile16BitBE(file, element);
7096
7097   xx_ei = *ei;          /* copy element data into temporary buffer */
7098   xx_group = *group;    /* copy group data into temporary buffer */
7099
7100   /* set default description string for this specific element */
7101   strcpy(xx_default_description, getDefaultElementDescription(ei));
7102
7103   for (i = 0; chunk_config_GRPX[i].data_type != -1; i++)
7104     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_GRPX[i], FALSE);
7105
7106   return chunk_size;
7107 }
7108
7109 static void SaveLevelFromFilename(struct LevelInfo *level, char *filename,
7110                                   boolean save_as_template)
7111 {
7112   int chunk_size;
7113   int i;
7114   FILE *file;
7115
7116   if (!(file = fopen(filename, MODE_WRITE)))
7117   {
7118     Error(ERR_WARN, "cannot save level file '%s'", filename);
7119     return;
7120   }
7121
7122   level->file_version = FILE_VERSION_ACTUAL;
7123   level->game_version = GAME_VERSION_ACTUAL;
7124
7125   level->creation_date = getCurrentDate();
7126
7127   putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
7128   putFileChunkBE(file, "CAVE", CHUNK_SIZE_NONE);
7129
7130   chunk_size = SaveLevel_VERS(NULL, level);
7131   putFileChunkBE(file, "VERS", chunk_size);
7132   SaveLevel_VERS(file, level);
7133
7134   chunk_size = SaveLevel_DATE(NULL, level);
7135   putFileChunkBE(file, "DATE", chunk_size);
7136   SaveLevel_DATE(file, level);
7137
7138   chunk_size = SaveLevel_NAME(NULL, level);
7139   putFileChunkBE(file, "NAME", chunk_size);
7140   SaveLevel_NAME(file, level);
7141
7142   chunk_size = SaveLevel_AUTH(NULL, level);
7143   putFileChunkBE(file, "AUTH", chunk_size);
7144   SaveLevel_AUTH(file, level);
7145
7146   chunk_size = SaveLevel_INFO(NULL, level);
7147   putFileChunkBE(file, "INFO", chunk_size);
7148   SaveLevel_INFO(file, level);
7149
7150   chunk_size = SaveLevel_BODY(NULL, level);
7151   putFileChunkBE(file, "BODY", chunk_size);
7152   SaveLevel_BODY(file, level);
7153
7154   chunk_size = SaveLevel_ELEM(NULL, level);
7155   if (chunk_size > LEVEL_CHUNK_ELEM_UNCHANGED)          /* save if changed */
7156   {
7157     putFileChunkBE(file, "ELEM", chunk_size);
7158     SaveLevel_ELEM(file, level);
7159   }
7160
7161   for (i = 0; i < NUM_ENVELOPES; i++)
7162   {
7163     int element = EL_ENVELOPE_1 + i;
7164
7165     chunk_size = SaveLevel_NOTE(NULL, level, element);
7166     if (chunk_size > LEVEL_CHUNK_NOTE_UNCHANGED)        /* save if changed */
7167     {
7168       putFileChunkBE(file, "NOTE", chunk_size);
7169       SaveLevel_NOTE(file, level, element);
7170     }
7171   }
7172
7173   /* if not using template level, check for non-default custom/group elements */
7174   if (!level->use_custom_template || save_as_template)
7175   {
7176     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7177     {
7178       int element = EL_CUSTOM_START + i;
7179
7180       chunk_size = SaveLevel_CUSX(NULL, level, element);
7181       if (chunk_size > LEVEL_CHUNK_CUSX_UNCHANGED)      /* save if changed */
7182       {
7183         putFileChunkBE(file, "CUSX", chunk_size);
7184         SaveLevel_CUSX(file, level, element);
7185       }
7186     }
7187
7188     for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
7189     {
7190       int element = EL_GROUP_START + i;
7191
7192       chunk_size = SaveLevel_GRPX(NULL, level, element);
7193       if (chunk_size > LEVEL_CHUNK_GRPX_UNCHANGED)      /* save if changed */
7194       {
7195         putFileChunkBE(file, "GRPX", chunk_size);
7196         SaveLevel_GRPX(file, level, element);
7197       }
7198     }
7199   }
7200
7201   fclose(file);
7202
7203   SetFilePermissions(filename, PERMS_PRIVATE);
7204 }
7205
7206 void SaveLevel(int nr)
7207 {
7208   char *filename = getDefaultLevelFilename(nr);
7209
7210   SaveLevelFromFilename(&level, filename, FALSE);
7211 }
7212
7213 void SaveLevelTemplate()
7214 {
7215   char *filename = getLocalLevelTemplateFilename();
7216
7217   SaveLevelFromFilename(&level, filename, TRUE);
7218 }
7219
7220 boolean SaveLevelChecked(int nr)
7221 {
7222   char *filename = getDefaultLevelFilename(nr);
7223   boolean new_level = !fileExists(filename);
7224   boolean level_saved = FALSE;
7225
7226   if (new_level || Request("Save this level and kill the old?", REQ_ASK))
7227   {
7228     SaveLevel(nr);
7229
7230     if (new_level)
7231       Request("Level saved!", REQ_CONFIRM);
7232
7233     level_saved = TRUE;
7234   }
7235
7236   return level_saved;
7237 }
7238
7239 void DumpLevel(struct LevelInfo *level)
7240 {
7241   if (level->no_level_file || level->no_valid_file)
7242   {
7243     Error(ERR_WARN, "cannot dump -- no valid level file found");
7244
7245     return;
7246   }
7247
7248   PrintLine("-", 79);
7249   Print("Level xxx (file version %08d, game version %08d)\n",
7250         level->file_version, level->game_version);
7251   PrintLine("-", 79);
7252
7253   Print("Level author: '%s'\n", level->author);
7254   Print("Level title:  '%s'\n", level->name);
7255   Print("\n");
7256   Print("Playfield size: %d x %d\n", level->fieldx, level->fieldy);
7257   Print("\n");
7258   Print("Level time:  %d seconds\n", level->time);
7259   Print("Gems needed: %d\n", level->gems_needed);
7260   Print("\n");
7261   Print("Time for magic wall: %d seconds\n", level->time_magic_wall);
7262   Print("Time for wheel:      %d seconds\n", level->time_wheel);
7263   Print("Time for light:      %d seconds\n", level->time_light);
7264   Print("Time for timegate:   %d seconds\n", level->time_timegate);
7265   Print("\n");
7266   Print("Amoeba speed: %d\n", level->amoeba_speed);
7267   Print("\n");
7268
7269   Print("EM style slippery gems:      %s\n", (level->em_slippery_gems ? "yes" : "no"));
7270   Print("Player blocks last field:    %s\n", (level->block_last_field ? "yes" : "no"));
7271   Print("SP player blocks last field: %s\n", (level->sp_block_last_field ? "yes" : "no"));
7272   Print("use spring bug: %s\n", (level->use_spring_bug ? "yes" : "no"));
7273   Print("use step counter: %s\n", (level->use_step_counter ? "yes" : "no"));
7274
7275   PrintLine("-", 79);
7276 }
7277
7278
7279 /* ========================================================================= */
7280 /* tape file functions                                                       */
7281 /* ========================================================================= */
7282
7283 static void setTapeInfoToDefaults()
7284 {
7285   int i;
7286
7287   /* always start with reliable default values (empty tape) */
7288   TapeErase();
7289
7290   /* default values (also for pre-1.2 tapes) with only the first player */
7291   tape.player_participates[0] = TRUE;
7292   for (i = 1; i < MAX_PLAYERS; i++)
7293     tape.player_participates[i] = FALSE;
7294
7295   /* at least one (default: the first) player participates in every tape */
7296   tape.num_participating_players = 1;
7297
7298   tape.level_nr = level_nr;
7299   tape.counter = 0;
7300   tape.changed = FALSE;
7301
7302   tape.recording = FALSE;
7303   tape.playing = FALSE;
7304   tape.pausing = FALSE;
7305
7306   tape.no_valid_file = FALSE;
7307 }
7308
7309 static int LoadTape_VERS(File *file, int chunk_size, struct TapeInfo *tape)
7310 {
7311   tape->file_version = getFileVersion(file);
7312   tape->game_version = getFileVersion(file);
7313
7314   return chunk_size;
7315 }
7316
7317 static int LoadTape_HEAD(File *file, int chunk_size, struct TapeInfo *tape)
7318 {
7319   int i;
7320
7321   tape->random_seed = getFile32BitBE(file);
7322   tape->date        = getFile32BitBE(file);
7323   tape->length      = getFile32BitBE(file);
7324
7325   /* read header fields that are new since version 1.2 */
7326   if (tape->file_version >= FILE_VERSION_1_2)
7327   {
7328     byte store_participating_players = getFile8Bit(file);
7329     int engine_version;
7330
7331     /* since version 1.2, tapes store which players participate in the tape */
7332     tape->num_participating_players = 0;
7333     for (i = 0; i < MAX_PLAYERS; i++)
7334     {
7335       tape->player_participates[i] = FALSE;
7336
7337       if (store_participating_players & (1 << i))
7338       {
7339         tape->player_participates[i] = TRUE;
7340         tape->num_participating_players++;
7341       }
7342     }
7343
7344     ReadUnusedBytesFromFile(file, TAPE_CHUNK_HEAD_UNUSED);
7345
7346     engine_version = getFileVersion(file);
7347     if (engine_version > 0)
7348       tape->engine_version = engine_version;
7349     else
7350       tape->engine_version = tape->game_version;
7351   }
7352
7353   return chunk_size;
7354 }
7355
7356 static int LoadTape_INFO(File *file, int chunk_size, struct TapeInfo *tape)
7357 {
7358   int level_identifier_size;
7359   int i;
7360
7361   level_identifier_size = getFile16BitBE(file);
7362
7363   tape->level_identifier =
7364     checked_realloc(tape->level_identifier, level_identifier_size);
7365
7366   for (i = 0; i < level_identifier_size; i++)
7367     tape->level_identifier[i] = getFile8Bit(file);
7368
7369   tape->level_nr = getFile16BitBE(file);
7370
7371   chunk_size = 2 + level_identifier_size + 2;
7372
7373   return chunk_size;
7374 }
7375
7376 static int LoadTape_BODY(File *file, int chunk_size, struct TapeInfo *tape)
7377 {
7378   int i, j;
7379   int chunk_size_expected =
7380     (tape->num_participating_players + 1) * tape->length;
7381
7382   if (chunk_size_expected != chunk_size)
7383   {
7384     ReadUnusedBytesFromFile(file, chunk_size);
7385     return chunk_size_expected;
7386   }
7387
7388   for (i = 0; i < tape->length; i++)
7389   {
7390     if (i >= MAX_TAPE_LEN)
7391       break;
7392
7393     for (j = 0; j < MAX_PLAYERS; j++)
7394     {
7395       tape->pos[i].action[j] = MV_NONE;
7396
7397       if (tape->player_participates[j])
7398         tape->pos[i].action[j] = getFile8Bit(file);
7399     }
7400
7401     tape->pos[i].delay = getFile8Bit(file);
7402
7403     if (tape->file_version == FILE_VERSION_1_0)
7404     {
7405       /* eliminate possible diagonal moves in old tapes */
7406       /* this is only for backward compatibility */
7407
7408       byte joy_dir[4] = { JOY_LEFT, JOY_RIGHT, JOY_UP, JOY_DOWN };
7409       byte action = tape->pos[i].action[0];
7410       int k, num_moves = 0;
7411
7412       for (k = 0; k<4; k++)
7413       {
7414         if (action & joy_dir[k])
7415         {
7416           tape->pos[i + num_moves].action[0] = joy_dir[k];
7417           if (num_moves > 0)
7418             tape->pos[i + num_moves].delay = 0;
7419           num_moves++;
7420         }
7421       }
7422
7423       if (num_moves > 1)
7424       {
7425         num_moves--;
7426         i += num_moves;
7427         tape->length += num_moves;
7428       }
7429     }
7430     else if (tape->file_version < FILE_VERSION_2_0)
7431     {
7432       /* convert pre-2.0 tapes to new tape format */
7433
7434       if (tape->pos[i].delay > 1)
7435       {
7436         /* action part */
7437         tape->pos[i + 1] = tape->pos[i];
7438         tape->pos[i + 1].delay = 1;
7439
7440         /* delay part */
7441         for (j = 0; j < MAX_PLAYERS; j++)
7442           tape->pos[i].action[j] = MV_NONE;
7443         tape->pos[i].delay--;
7444
7445         i++;
7446         tape->length++;
7447       }
7448     }
7449
7450     if (checkEndOfFile(file))
7451       break;
7452   }
7453
7454   if (i != tape->length)
7455     chunk_size = (tape->num_participating_players + 1) * i;
7456
7457   return chunk_size;
7458 }
7459
7460 void LoadTape_SokobanSolution(char *filename)
7461 {
7462   File *file;
7463   int move_delay = TILESIZE / level.initial_player_stepsize[0];
7464
7465   if (!(file = openFile(filename, MODE_READ)))
7466   {
7467     tape.no_valid_file = TRUE;
7468
7469     return;
7470   }
7471
7472   while (!checkEndOfFile(file))
7473   {
7474     unsigned char c = getByteFromFile(file);
7475
7476     if (checkEndOfFile(file))
7477       break;
7478
7479     switch (c)
7480     {
7481       case 'u':
7482       case 'U':
7483         tape.pos[tape.length].action[0] = MV_UP;
7484         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7485         tape.length++;
7486         break;
7487
7488       case 'd':
7489       case 'D':
7490         tape.pos[tape.length].action[0] = MV_DOWN;
7491         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7492         tape.length++;
7493         break;
7494
7495       case 'l':
7496       case 'L':
7497         tape.pos[tape.length].action[0] = MV_LEFT;
7498         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7499         tape.length++;
7500         break;
7501
7502       case 'r':
7503       case 'R':
7504         tape.pos[tape.length].action[0] = MV_RIGHT;
7505         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7506         tape.length++;
7507         break;
7508
7509       case '\n':
7510       case '\r':
7511       case '\t':
7512       case ' ':
7513         /* ignore white-space characters */
7514         break;
7515
7516       default:
7517         tape.no_valid_file = TRUE;
7518
7519         Error(ERR_WARN, "unsupported Sokoban solution file '%s' ['%d']", filename, c);
7520
7521         break;
7522     }
7523   }
7524
7525   closeFile(file);
7526
7527   if (tape.no_valid_file)
7528     return;
7529
7530   tape.length_frames  = GetTapeLengthFrames();
7531   tape.length_seconds = GetTapeLengthSeconds();
7532 }
7533
7534 void LoadTapeFromFilename(char *filename)
7535 {
7536   char cookie[MAX_LINE_LEN];
7537   char chunk_name[CHUNK_ID_LEN + 1];
7538   File *file;
7539   int chunk_size;
7540
7541   /* always start with reliable default values */
7542   setTapeInfoToDefaults();
7543
7544   if (strSuffix(filename, ".sln"))
7545   {
7546     LoadTape_SokobanSolution(filename);
7547
7548     return;
7549   }
7550
7551   if (!(file = openFile(filename, MODE_READ)))
7552   {
7553     tape.no_valid_file = TRUE;
7554
7555     return;
7556   }
7557
7558   getFileChunkBE(file, chunk_name, NULL);
7559   if (strEqual(chunk_name, "RND1"))
7560   {
7561     getFile32BitBE(file);               /* not used */
7562
7563     getFileChunkBE(file, chunk_name, NULL);
7564     if (!strEqual(chunk_name, "TAPE"))
7565     {
7566       tape.no_valid_file = TRUE;
7567
7568       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
7569
7570       closeFile(file);
7571
7572       return;
7573     }
7574   }
7575   else  /* check for pre-2.0 file format with cookie string */
7576   {
7577     strcpy(cookie, chunk_name);
7578     if (getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4) == NULL)
7579       cookie[4] = '\0';
7580     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
7581       cookie[strlen(cookie) - 1] = '\0';
7582
7583     if (!checkCookieString(cookie, TAPE_COOKIE_TMPL))
7584     {
7585       tape.no_valid_file = TRUE;
7586
7587       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
7588
7589       closeFile(file);
7590
7591       return;
7592     }
7593
7594     if ((tape.file_version = getFileVersionFromCookieString(cookie)) == -1)
7595     {
7596       tape.no_valid_file = TRUE;
7597
7598       Error(ERR_WARN, "unsupported version of tape file '%s'", filename);
7599
7600       closeFile(file);
7601
7602       return;
7603     }
7604
7605     /* pre-2.0 tape files have no game version, so use file version here */
7606     tape.game_version = tape.file_version;
7607   }
7608
7609   if (tape.file_version < FILE_VERSION_1_2)
7610   {
7611     /* tape files from versions before 1.2.0 without chunk structure */
7612     LoadTape_HEAD(file, TAPE_CHUNK_HEAD_SIZE, &tape);
7613     LoadTape_BODY(file, 2 * tape.length,      &tape);
7614   }
7615   else
7616   {
7617     static struct
7618     {
7619       char *name;
7620       int size;
7621       int (*loader)(File *, int, struct TapeInfo *);
7622     }
7623     chunk_info[] =
7624     {
7625       { "VERS", TAPE_CHUNK_VERS_SIZE,   LoadTape_VERS },
7626       { "HEAD", TAPE_CHUNK_HEAD_SIZE,   LoadTape_HEAD },
7627       { "INFO", -1,                     LoadTape_INFO },
7628       { "BODY", -1,                     LoadTape_BODY },
7629       {  NULL,  0,                      NULL }
7630     };
7631
7632     while (getFileChunkBE(file, chunk_name, &chunk_size))
7633     {
7634       int i = 0;
7635
7636       while (chunk_info[i].name != NULL &&
7637              !strEqual(chunk_name, chunk_info[i].name))
7638         i++;
7639
7640       if (chunk_info[i].name == NULL)
7641       {
7642         Error(ERR_WARN, "unknown chunk '%s' in tape file '%s'",
7643               chunk_name, filename);
7644         ReadUnusedBytesFromFile(file, chunk_size);
7645       }
7646       else if (chunk_info[i].size != -1 &&
7647                chunk_info[i].size != chunk_size)
7648       {
7649         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
7650               chunk_size, chunk_name, filename);
7651         ReadUnusedBytesFromFile(file, chunk_size);
7652       }
7653       else
7654       {
7655         /* call function to load this tape chunk */
7656         int chunk_size_expected =
7657           (chunk_info[i].loader)(file, chunk_size, &tape);
7658
7659         /* the size of some chunks cannot be checked before reading other
7660            chunks first (like "HEAD" and "BODY") that contain some header
7661            information, so check them here */
7662         if (chunk_size_expected != chunk_size)
7663         {
7664           Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
7665                 chunk_size, chunk_name, filename);
7666         }
7667       }
7668     }
7669   }
7670
7671   closeFile(file);
7672
7673   tape.length_frames  = GetTapeLengthFrames();
7674   tape.length_seconds = GetTapeLengthSeconds();
7675
7676 #if 0
7677   printf("::: tape file version: %d\n",   tape.file_version);
7678   printf("::: tape game version: %d\n",   tape.game_version);
7679   printf("::: tape engine version: %d\n", tape.engine_version);
7680 #endif
7681 }
7682
7683 void LoadTape(int nr)
7684 {
7685   char *filename = getTapeFilename(nr);
7686
7687   LoadTapeFromFilename(filename);
7688 }
7689
7690 void LoadSolutionTape(int nr)
7691 {
7692   char *filename = getSolutionTapeFilename(nr);
7693
7694   LoadTapeFromFilename(filename);
7695
7696   if (TAPE_IS_EMPTY(tape) &&
7697       level.game_engine_type == GAME_ENGINE_TYPE_SP &&
7698       level.native_sp_level->demo.is_available)
7699     CopyNativeTape_SP_to_RND(&level);
7700 }
7701
7702 static void SaveTape_VERS(FILE *file, struct TapeInfo *tape)
7703 {
7704   putFileVersion(file, tape->file_version);
7705   putFileVersion(file, tape->game_version);
7706 }
7707
7708 static void SaveTape_HEAD(FILE *file, struct TapeInfo *tape)
7709 {
7710   int i;
7711   byte store_participating_players = 0;
7712
7713   /* set bits for participating players for compact storage */
7714   for (i = 0; i < MAX_PLAYERS; i++)
7715     if (tape->player_participates[i])
7716       store_participating_players |= (1 << i);
7717
7718   putFile32BitBE(file, tape->random_seed);
7719   putFile32BitBE(file, tape->date);
7720   putFile32BitBE(file, tape->length);
7721
7722   putFile8Bit(file, store_participating_players);
7723
7724   /* unused bytes not at the end here for 4-byte alignment of engine_version */
7725   WriteUnusedBytesToFile(file, TAPE_CHUNK_HEAD_UNUSED);
7726
7727   putFileVersion(file, tape->engine_version);
7728 }
7729
7730 static void SaveTape_INFO(FILE *file, struct TapeInfo *tape)
7731 {
7732   int level_identifier_size = strlen(tape->level_identifier) + 1;
7733   int i;
7734
7735   putFile16BitBE(file, level_identifier_size);
7736
7737   for (i = 0; i < level_identifier_size; i++)
7738     putFile8Bit(file, tape->level_identifier[i]);
7739
7740   putFile16BitBE(file, tape->level_nr);
7741 }
7742
7743 static void SaveTape_BODY(FILE *file, struct TapeInfo *tape)
7744 {
7745   int i, j;
7746
7747   for (i = 0; i < tape->length; i++)
7748   {
7749     for (j = 0; j < MAX_PLAYERS; j++)
7750       if (tape->player_participates[j])
7751         putFile8Bit(file, tape->pos[i].action[j]);
7752
7753     putFile8Bit(file, tape->pos[i].delay);
7754   }
7755 }
7756
7757 void SaveTape(int nr)
7758 {
7759   char *filename = getTapeFilename(nr);
7760   FILE *file;
7761   int num_participating_players = 0;
7762   int info_chunk_size;
7763   int body_chunk_size;
7764   int i;
7765
7766   InitTapeDirectory(leveldir_current->subdir);
7767
7768   if (!(file = fopen(filename, MODE_WRITE)))
7769   {
7770     Error(ERR_WARN, "cannot save level recording file '%s'", filename);
7771     return;
7772   }
7773
7774   tape.file_version = FILE_VERSION_ACTUAL;
7775   tape.game_version = GAME_VERSION_ACTUAL;
7776
7777   /* count number of participating players  */
7778   for (i = 0; i < MAX_PLAYERS; i++)
7779     if (tape.player_participates[i])
7780       num_participating_players++;
7781
7782   info_chunk_size = 2 + (strlen(tape.level_identifier) + 1) + 2;
7783   body_chunk_size = (num_participating_players + 1) * tape.length;
7784
7785   putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
7786   putFileChunkBE(file, "TAPE", CHUNK_SIZE_NONE);
7787
7788   putFileChunkBE(file, "VERS", TAPE_CHUNK_VERS_SIZE);
7789   SaveTape_VERS(file, &tape);
7790
7791   putFileChunkBE(file, "HEAD", TAPE_CHUNK_HEAD_SIZE);
7792   SaveTape_HEAD(file, &tape);
7793
7794   putFileChunkBE(file, "INFO", info_chunk_size);
7795   SaveTape_INFO(file, &tape);
7796
7797   putFileChunkBE(file, "BODY", body_chunk_size);
7798   SaveTape_BODY(file, &tape);
7799
7800   fclose(file);
7801
7802   SetFilePermissions(filename, PERMS_PRIVATE);
7803
7804   tape.changed = FALSE;
7805 }
7806
7807 boolean SaveTapeChecked(int nr)
7808 {
7809   char *filename = getTapeFilename(nr);
7810   boolean new_tape = !fileExists(filename);
7811   boolean tape_saved = FALSE;
7812
7813   if (new_tape || Request("Replace old tape?", REQ_ASK))
7814   {
7815     SaveTape(nr);
7816
7817     if (new_tape)
7818       Request("Tape saved!", REQ_CONFIRM);
7819
7820     tape_saved = TRUE;
7821   }
7822
7823   return tape_saved;
7824 }
7825
7826 void DumpTape(struct TapeInfo *tape)
7827 {
7828   int tape_frame_counter;
7829   int i, j;
7830
7831   if (tape->no_valid_file)
7832   {
7833     Error(ERR_WARN, "cannot dump -- no valid tape file found");
7834
7835     return;
7836   }
7837
7838   PrintLine("-", 79);
7839   Print("Tape of Level %03d (file version %08d, game version %08d)\n",
7840         tape->level_nr, tape->file_version, tape->game_version);
7841   Print("                  (effective engine version %08d)\n",
7842         tape->engine_version);
7843   Print("Level series identifier: '%s'\n", tape->level_identifier);
7844   PrintLine("-", 79);
7845
7846   tape_frame_counter = 0;
7847
7848   for (i = 0; i < tape->length; i++)
7849   {
7850     if (i >= MAX_TAPE_LEN)
7851       break;
7852
7853     Print("%04d: ", i);
7854
7855     for (j = 0; j < MAX_PLAYERS; j++)
7856     {
7857       if (tape->player_participates[j])
7858       {
7859         int action = tape->pos[i].action[j];
7860
7861         Print("%d:%02x ", j, action);
7862         Print("[%c%c%c%c|%c%c] - ",
7863               (action & JOY_LEFT ? '<' : ' '),
7864               (action & JOY_RIGHT ? '>' : ' '),
7865               (action & JOY_UP ? '^' : ' '),
7866               (action & JOY_DOWN ? 'v' : ' '),
7867               (action & JOY_BUTTON_1 ? '1' : ' '),
7868               (action & JOY_BUTTON_2 ? '2' : ' '));
7869       }
7870     }
7871
7872     Print("(%03d) ", tape->pos[i].delay);
7873     Print("[%05d]\n", tape_frame_counter);
7874
7875     tape_frame_counter += tape->pos[i].delay;
7876   }
7877
7878   PrintLine("-", 79);
7879 }
7880
7881
7882 /* ========================================================================= */
7883 /* score file functions                                                      */
7884 /* ========================================================================= */
7885
7886 void LoadScore(int nr)
7887 {
7888   int i;
7889   char *filename = getScoreFilename(nr);
7890   char cookie[MAX_LINE_LEN];
7891   char line[MAX_LINE_LEN];
7892   char *line_ptr;
7893   FILE *file;
7894
7895   /* always start with reliable default values */
7896   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
7897   {
7898     strcpy(highscore[i].Name, EMPTY_PLAYER_NAME);
7899     highscore[i].Score = 0;
7900   }
7901
7902   if (!(file = fopen(filename, MODE_READ)))
7903     return;
7904
7905   /* check file identifier */
7906   if (fgets(cookie, MAX_LINE_LEN, file) == NULL)
7907     cookie[0] = '\0';
7908   if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
7909     cookie[strlen(cookie) - 1] = '\0';
7910
7911   if (!checkCookieString(cookie, SCORE_COOKIE))
7912   {
7913     Error(ERR_WARN, "unknown format of score file '%s'", filename);
7914     fclose(file);
7915     return;
7916   }
7917
7918   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
7919   {
7920     if (fscanf(file, "%d", &highscore[i].Score) == EOF)
7921       Error(ERR_WARN, "fscanf() failed; %s", strerror(errno));
7922     if (fgets(line, MAX_LINE_LEN, file) == NULL)
7923       line[0] = '\0';
7924
7925     if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
7926       line[strlen(line) - 1] = '\0';
7927
7928     for (line_ptr = line; *line_ptr; line_ptr++)
7929     {
7930       if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != '\0')
7931       {
7932         strncpy(highscore[i].Name, line_ptr, MAX_PLAYER_NAME_LEN);
7933         highscore[i].Name[MAX_PLAYER_NAME_LEN] = '\0';
7934         break;
7935       }
7936     }
7937   }
7938
7939   fclose(file);
7940 }
7941
7942 void SaveScore(int nr)
7943 {
7944   int i;
7945   int permissions = (program.global_scores ? PERMS_PUBLIC : PERMS_PRIVATE);
7946   char *filename = getScoreFilename(nr);
7947   FILE *file;
7948
7949   InitScoreDirectory(leveldir_current->subdir);
7950
7951   if (!(file = fopen(filename, MODE_WRITE)))
7952   {
7953     Error(ERR_WARN, "cannot save score for level %d", nr);
7954     return;
7955   }
7956
7957   fprintf(file, "%s\n\n", SCORE_COOKIE);
7958
7959   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
7960     fprintf(file, "%d %s\n", highscore[i].Score, highscore[i].Name);
7961
7962   fclose(file);
7963
7964   SetFilePermissions(filename, permissions);
7965 }
7966
7967
7968 /* ========================================================================= */
7969 /* setup file functions                                                      */
7970 /* ========================================================================= */
7971
7972 #define TOKEN_STR_PLAYER_PREFIX                 "player_"
7973
7974 /* global setup */
7975 #define SETUP_TOKEN_PLAYER_NAME                 0
7976 #define SETUP_TOKEN_SOUND                       1
7977 #define SETUP_TOKEN_SOUND_LOOPS                 2
7978 #define SETUP_TOKEN_SOUND_MUSIC                 3
7979 #define SETUP_TOKEN_SOUND_SIMPLE                4
7980 #define SETUP_TOKEN_TOONS                       5
7981 #define SETUP_TOKEN_SCROLL_DELAY                6
7982 #define SETUP_TOKEN_SCROLL_DELAY_VALUE          7
7983 #define SETUP_TOKEN_ENGINE_SNAPSHOT_MODE        8
7984 #define SETUP_TOKEN_ENGINE_SNAPSHOT_MEMORY      9
7985 #define SETUP_TOKEN_FADE_SCREENS                10
7986 #define SETUP_TOKEN_AUTORECORD                  11
7987 #define SETUP_TOKEN_SHOW_TITLESCREEN            12
7988 #define SETUP_TOKEN_QUICK_DOORS                 13
7989 #define SETUP_TOKEN_TEAM_MODE                   14
7990 #define SETUP_TOKEN_HANDICAP                    15
7991 #define SETUP_TOKEN_SKIP_LEVELS                 16
7992 #define SETUP_TOKEN_INCREMENT_LEVELS            17
7993 #define SETUP_TOKEN_TIME_LIMIT                  18
7994 #define SETUP_TOKEN_FULLSCREEN                  19
7995 #define SETUP_TOKEN_WINDOW_SCALING_PERCENT      20
7996 #define SETUP_TOKEN_WINDOW_SCALING_QUALITY      21
7997 #define SETUP_TOKEN_SCREEN_RENDERING_MODE       22
7998 #define SETUP_TOKEN_ASK_ON_ESCAPE               23
7999 #define SETUP_TOKEN_ASK_ON_ESCAPE_EDITOR        24
8000 #define SETUP_TOKEN_QUICK_SWITCH                25
8001 #define SETUP_TOKEN_INPUT_ON_FOCUS              26
8002 #define SETUP_TOKEN_PREFER_AGA_GRAPHICS         27
8003 #define SETUP_TOKEN_GAME_FRAME_DELAY            28
8004 #define SETUP_TOKEN_SP_SHOW_BORDER_ELEMENTS     29
8005 #define SETUP_TOKEN_SMALL_GAME_GRAPHICS         30
8006 #define SETUP_TOKEN_SHOW_SNAPSHOT_BUTTONS       31
8007 #define SETUP_TOKEN_GRAPHICS_SET                32
8008 #define SETUP_TOKEN_SOUNDS_SET                  33
8009 #define SETUP_TOKEN_MUSIC_SET                   34
8010 #define SETUP_TOKEN_OVERRIDE_LEVEL_GRAPHICS     35
8011 #define SETUP_TOKEN_OVERRIDE_LEVEL_SOUNDS       36
8012 #define SETUP_TOKEN_OVERRIDE_LEVEL_MUSIC        37
8013 #define SETUP_TOKEN_VOLUME_SIMPLE               38
8014 #define SETUP_TOKEN_VOLUME_LOOPS                39
8015 #define SETUP_TOKEN_VOLUME_MUSIC                40
8016 #define SETUP_TOKEN_TOUCH_CONTROL_TYPE          41
8017 #define SETUP_TOKEN_TOUCH_MOVE_DISTANCE         42
8018 #define SETUP_TOKEN_TOUCH_DROP_DISTANCE         43
8019
8020 #define NUM_GLOBAL_SETUP_TOKENS                 44
8021
8022 /* editor setup */
8023 #define SETUP_TOKEN_EDITOR_EL_CLASSIC           0
8024 #define SETUP_TOKEN_EDITOR_EL_CUSTOM            1
8025 #define SETUP_TOKEN_EDITOR_EL_USER_DEFINED      2
8026 #define SETUP_TOKEN_EDITOR_EL_DYNAMIC           3
8027 #define SETUP_TOKEN_EDITOR_EL_HEADLINES         4
8028 #define SETUP_TOKEN_EDITOR_SHOW_ELEMENT_TOKEN   5
8029
8030 #define NUM_EDITOR_SETUP_TOKENS                 6
8031
8032 /* editor cascade setup */
8033 #define SETUP_TOKEN_EDITOR_CASCADE_BD           0
8034 #define SETUP_TOKEN_EDITOR_CASCADE_EM           1
8035 #define SETUP_TOKEN_EDITOR_CASCADE_EMC          2
8036 #define SETUP_TOKEN_EDITOR_CASCADE_RND          3
8037 #define SETUP_TOKEN_EDITOR_CASCADE_SB           4
8038 #define SETUP_TOKEN_EDITOR_CASCADE_SP           5
8039 #define SETUP_TOKEN_EDITOR_CASCADE_DC           6
8040 #define SETUP_TOKEN_EDITOR_CASCADE_DX           7
8041 #define SETUP_TOKEN_EDITOR_CASCADE_TEXT         8
8042 #define SETUP_TOKEN_EDITOR_CASCADE_STEELTEXT    9
8043 #define SETUP_TOKEN_EDITOR_CASCADE_CE           10
8044 #define SETUP_TOKEN_EDITOR_CASCADE_GE           11
8045 #define SETUP_TOKEN_EDITOR_CASCADE_REF          12
8046 #define SETUP_TOKEN_EDITOR_CASCADE_USER         13
8047 #define SETUP_TOKEN_EDITOR_CASCADE_DYNAMIC      14
8048
8049 #define NUM_EDITOR_CASCADE_SETUP_TOKENS         15
8050
8051 /* shortcut setup */
8052 #define SETUP_TOKEN_SHORTCUT_SAVE_GAME          0
8053 #define SETUP_TOKEN_SHORTCUT_LOAD_GAME          1
8054 #define SETUP_TOKEN_SHORTCUT_TOGGLE_PAUSE       2
8055 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_1     3
8056 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_2     4
8057 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_3     5
8058 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_4     6
8059 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_ALL   7
8060 #define SETUP_TOKEN_SHORTCUT_TAPE_EJECT         8
8061 #define SETUP_TOKEN_SHORTCUT_TAPE_EXTRA         9
8062 #define SETUP_TOKEN_SHORTCUT_TAPE_STOP          10
8063 #define SETUP_TOKEN_SHORTCUT_TAPE_PAUSE         11
8064 #define SETUP_TOKEN_SHORTCUT_TAPE_RECORD        12
8065 #define SETUP_TOKEN_SHORTCUT_TAPE_PLAY          13
8066 #define SETUP_TOKEN_SHORTCUT_SOUND_SIMPLE       14
8067 #define SETUP_TOKEN_SHORTCUT_SOUND_LOOPS        15
8068 #define SETUP_TOKEN_SHORTCUT_SOUND_MUSIC        16
8069 #define SETUP_TOKEN_SHORTCUT_SNAP_LEFT          17
8070 #define SETUP_TOKEN_SHORTCUT_SNAP_RIGHT         18
8071 #define SETUP_TOKEN_SHORTCUT_SNAP_UP            19
8072 #define SETUP_TOKEN_SHORTCUT_SNAP_DOWN          20
8073
8074 #define NUM_SHORTCUT_SETUP_TOKENS               21
8075
8076 /* player setup */
8077 #define SETUP_TOKEN_PLAYER_USE_JOYSTICK         0
8078 #define SETUP_TOKEN_PLAYER_JOY_DEVICE_NAME      1
8079 #define SETUP_TOKEN_PLAYER_JOY_XLEFT            2
8080 #define SETUP_TOKEN_PLAYER_JOY_XMIDDLE          3
8081 #define SETUP_TOKEN_PLAYER_JOY_XRIGHT           4
8082 #define SETUP_TOKEN_PLAYER_JOY_YUPPER           5
8083 #define SETUP_TOKEN_PLAYER_JOY_YMIDDLE          6
8084 #define SETUP_TOKEN_PLAYER_JOY_YLOWER           7
8085 #define SETUP_TOKEN_PLAYER_JOY_SNAP             8
8086 #define SETUP_TOKEN_PLAYER_JOY_DROP             9
8087 #define SETUP_TOKEN_PLAYER_KEY_LEFT             10
8088 #define SETUP_TOKEN_PLAYER_KEY_RIGHT            11
8089 #define SETUP_TOKEN_PLAYER_KEY_UP               12
8090 #define SETUP_TOKEN_PLAYER_KEY_DOWN             13
8091 #define SETUP_TOKEN_PLAYER_KEY_SNAP             14
8092 #define SETUP_TOKEN_PLAYER_KEY_DROP             15
8093
8094 #define NUM_PLAYER_SETUP_TOKENS                 16
8095
8096 /* system setup */
8097 #define SETUP_TOKEN_SYSTEM_SDL_VIDEODRIVER      0
8098 #define SETUP_TOKEN_SYSTEM_SDL_AUDIODRIVER      1
8099 #define SETUP_TOKEN_SYSTEM_AUDIO_FRAGMENT_SIZE  2
8100
8101 #define NUM_SYSTEM_SETUP_TOKENS                 3
8102
8103 /* internal setup */
8104 #define SETUP_TOKEN_INT_PROGRAM_TITLE           0
8105 #define SETUP_TOKEN_INT_PROGRAM_VERSION         1
8106 #define SETUP_TOKEN_INT_PROGRAM_AUTHOR          2
8107 #define SETUP_TOKEN_INT_PROGRAM_EMAIL           3
8108 #define SETUP_TOKEN_INT_PROGRAM_WEBSITE         4
8109 #define SETUP_TOKEN_INT_PROGRAM_COPYRIGHT       5
8110 #define SETUP_TOKEN_INT_PROGRAM_COMPANY         6
8111 #define SETUP_TOKEN_INT_PROGRAM_ICON_FILE       7
8112 #define SETUP_TOKEN_INT_DEFAULT_GRAPHICS_SET    8
8113 #define SETUP_TOKEN_INT_DEFAULT_SOUNDS_SET      9
8114 #define SETUP_TOKEN_INT_DEFAULT_MUSIC_SET       10
8115 #define SETUP_TOKEN_INT_FALLBACK_GRAPHICS_FILE  11
8116 #define SETUP_TOKEN_INT_FALLBACK_SOUNDS_FILE    12
8117 #define SETUP_TOKEN_INT_FALLBACK_MUSIC_FILE     13
8118 #define SETUP_TOKEN_INT_DEFAULT_LEVEL_SERIES    14
8119 #define SETUP_TOKEN_INT_CHOOSE_FROM_TOP_LEVELDIR 15
8120 #define SETUP_TOKEN_INT_SHOW_SCALING_IN_TITLE   16
8121 #define SETUP_TOKEN_INT_DEFAULT_WINDOW_WIDTH    17
8122 #define SETUP_TOKEN_INT_DEFAULT_WINDOW_HEIGHT   18
8123
8124 #define NUM_INTERNAL_SETUP_TOKENS               19
8125
8126 /* debug setup */
8127 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_0         0
8128 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_1         1
8129 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_2         2
8130 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_3         3
8131 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_4         4
8132 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_5         5
8133 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_6         6
8134 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_7         7
8135 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_8         8
8136 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_9         9
8137 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_0     10
8138 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_1     11
8139 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_2     12
8140 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_3     13
8141 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_4     14
8142 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_5     15
8143 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_6     16
8144 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_7     17
8145 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_8     18
8146 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_9     19
8147 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_USE_MOD_KEY 20
8148 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_GAME_ONLY 21
8149 #define SETUP_TOKEN_DEBUG_SHOW_FRAMES_PER_SECOND 22
8150
8151 #define NUM_DEBUG_SETUP_TOKENS                  23
8152
8153 /* options setup */
8154 #define SETUP_TOKEN_OPTIONS_VERBOSE             0
8155
8156 #define NUM_OPTIONS_SETUP_TOKENS                1
8157
8158
8159 static struct SetupInfo si;
8160 static struct SetupEditorInfo sei;
8161 static struct SetupEditorCascadeInfo seci;
8162 static struct SetupShortcutInfo ssi;
8163 static struct SetupInputInfo sii;
8164 static struct SetupSystemInfo syi;
8165 static struct SetupInternalInfo sxi;
8166 static struct SetupDebugInfo sdi;
8167 static struct OptionInfo soi;
8168
8169 static struct TokenInfo global_setup_tokens[] =
8170 {
8171   { TYPE_STRING, &si.player_name,             "player_name"             },
8172   { TYPE_SWITCH, &si.sound,                   "sound"                   },
8173   { TYPE_SWITCH, &si.sound_loops,             "repeating_sound_loops"   },
8174   { TYPE_SWITCH, &si.sound_music,             "background_music"        },
8175   { TYPE_SWITCH, &si.sound_simple,            "simple_sound_effects"    },
8176   { TYPE_SWITCH, &si.toons,                   "toons"                   },
8177   { TYPE_SWITCH, &si.scroll_delay,            "scroll_delay"            },
8178   { TYPE_INTEGER,&si.scroll_delay_value,      "scroll_delay_value"      },
8179   { TYPE_STRING, &si.engine_snapshot_mode,    "engine_snapshot_mode"    },
8180   { TYPE_INTEGER,&si.engine_snapshot_memory,  "engine_snapshot_memory"  },
8181   { TYPE_SWITCH, &si.fade_screens,            "fade_screens"            },
8182   { TYPE_SWITCH, &si.autorecord,              "automatic_tape_recording"},
8183   { TYPE_SWITCH, &si.show_titlescreen,        "show_titlescreen"        },
8184   { TYPE_SWITCH, &si.quick_doors,             "quick_doors"             },
8185   { TYPE_SWITCH, &si.team_mode,               "team_mode"               },
8186   { TYPE_SWITCH, &si.handicap,                "handicap"                },
8187   { TYPE_SWITCH, &si.skip_levels,             "skip_levels"             },
8188   { TYPE_SWITCH, &si.increment_levels,        "increment_levels"        },
8189   { TYPE_SWITCH, &si.time_limit,              "time_limit"              },
8190   { TYPE_SWITCH, &si.fullscreen,              "fullscreen"              },
8191   { TYPE_INTEGER,&si.window_scaling_percent,  "window_scaling_percent"  },
8192   { TYPE_STRING, &si.window_scaling_quality,  "window_scaling_quality"  },
8193   { TYPE_STRING, &si.screen_rendering_mode,   "screen_rendering_mode"   },
8194   { TYPE_SWITCH, &si.ask_on_escape,           "ask_on_escape"           },
8195   { TYPE_SWITCH, &si.ask_on_escape_editor,    "ask_on_escape_editor"    },
8196   { TYPE_SWITCH, &si.quick_switch,            "quick_player_switch"     },
8197   { TYPE_SWITCH, &si.input_on_focus,          "input_on_focus"          },
8198   { TYPE_SWITCH, &si.prefer_aga_graphics,     "prefer_aga_graphics"     },
8199   { TYPE_INTEGER,&si.game_frame_delay,        "game_frame_delay"        },
8200   { TYPE_SWITCH, &si.sp_show_border_elements, "sp_show_border_elements" },
8201   { TYPE_SWITCH, &si.small_game_graphics,     "small_game_graphics"     },
8202   { TYPE_SWITCH, &si.show_snapshot_buttons,   "show_snapshot_buttons"   },
8203   { TYPE_STRING, &si.graphics_set,            "graphics_set"            },
8204   { TYPE_STRING, &si.sounds_set,              "sounds_set"              },
8205   { TYPE_STRING, &si.music_set,               "music_set"               },
8206   { TYPE_SWITCH3,&si.override_level_graphics, "override_level_graphics" },
8207   { TYPE_SWITCH3,&si.override_level_sounds,   "override_level_sounds"   },
8208   { TYPE_SWITCH3,&si.override_level_music,    "override_level_music"    },
8209   { TYPE_INTEGER,&si.volume_simple,           "volume_simple"           },
8210   { TYPE_INTEGER,&si.volume_loops,            "volume_loops"            },
8211   { TYPE_INTEGER,&si.volume_music,            "volume_music"            },
8212   { TYPE_STRING, &si.touch.control_type,      "touch.control_type"      },
8213   { TYPE_INTEGER,&si.touch.move_distance,     "touch.move_distance"     },
8214   { TYPE_INTEGER,&si.touch.drop_distance,     "touch.drop_distance"     },
8215 };
8216
8217 static struct TokenInfo editor_setup_tokens[] =
8218 {
8219   { TYPE_SWITCH, &sei.el_classic,       "editor.el_classic"             },
8220   { TYPE_SWITCH, &sei.el_custom,        "editor.el_custom"              },
8221   { TYPE_SWITCH, &sei.el_user_defined,  "editor.el_user_defined"        },
8222   { TYPE_SWITCH, &sei.el_dynamic,       "editor.el_dynamic"             },
8223   { TYPE_SWITCH, &sei.el_headlines,     "editor.el_headlines"           },
8224   { TYPE_SWITCH, &sei.show_element_token,"editor.show_element_token"    },
8225 };
8226
8227 static struct TokenInfo editor_cascade_setup_tokens[] =
8228 {
8229   { TYPE_SWITCH, &seci.el_bd,           "editor.cascade.el_bd"          },
8230   { TYPE_SWITCH, &seci.el_em,           "editor.cascade.el_em"          },
8231   { TYPE_SWITCH, &seci.el_emc,          "editor.cascade.el_emc"         },
8232   { TYPE_SWITCH, &seci.el_rnd,          "editor.cascade.el_rnd"         },
8233   { TYPE_SWITCH, &seci.el_sb,           "editor.cascade.el_sb"          },
8234   { TYPE_SWITCH, &seci.el_sp,           "editor.cascade.el_sp"          },
8235   { TYPE_SWITCH, &seci.el_dc,           "editor.cascade.el_dc"          },
8236   { TYPE_SWITCH, &seci.el_dx,           "editor.cascade.el_dx"          },
8237   { TYPE_SWITCH, &seci.el_chars,        "editor.cascade.el_chars"       },
8238   { TYPE_SWITCH, &seci.el_steel_chars,  "editor.cascade.el_steel_chars" },
8239   { TYPE_SWITCH, &seci.el_ce,           "editor.cascade.el_ce"          },
8240   { TYPE_SWITCH, &seci.el_ge,           "editor.cascade.el_ge"          },
8241   { TYPE_SWITCH, &seci.el_ref,          "editor.cascade.el_ref"         },
8242   { TYPE_SWITCH, &seci.el_user,         "editor.cascade.el_user"        },
8243   { TYPE_SWITCH, &seci.el_dynamic,      "editor.cascade.el_dynamic"     },
8244 };
8245
8246 static struct TokenInfo shortcut_setup_tokens[] =
8247 {
8248   { TYPE_KEY_X11, &ssi.save_game,       "shortcut.save_game"            },
8249   { TYPE_KEY_X11, &ssi.load_game,       "shortcut.load_game"            },
8250   { TYPE_KEY_X11, &ssi.toggle_pause,    "shortcut.toggle_pause"         },
8251   { TYPE_KEY_X11, &ssi.focus_player[0], "shortcut.focus_player_1"       },
8252   { TYPE_KEY_X11, &ssi.focus_player[1], "shortcut.focus_player_2"       },
8253   { TYPE_KEY_X11, &ssi.focus_player[2], "shortcut.focus_player_3"       },
8254   { TYPE_KEY_X11, &ssi.focus_player[3], "shortcut.focus_player_4"       },
8255   { TYPE_KEY_X11, &ssi.focus_player_all,"shortcut.focus_player_all"     },
8256   { TYPE_KEY_X11, &ssi.tape_eject,      "shortcut.tape_eject"           },
8257   { TYPE_KEY_X11, &ssi.tape_extra,      "shortcut.tape_extra"           },
8258   { TYPE_KEY_X11, &ssi.tape_stop,       "shortcut.tape_stop"            },
8259   { TYPE_KEY_X11, &ssi.tape_pause,      "shortcut.tape_pause"           },
8260   { TYPE_KEY_X11, &ssi.tape_record,     "shortcut.tape_record"          },
8261   { TYPE_KEY_X11, &ssi.tape_play,       "shortcut.tape_play"            },
8262   { TYPE_KEY_X11, &ssi.sound_simple,    "shortcut.sound_simple"         },
8263   { TYPE_KEY_X11, &ssi.sound_loops,     "shortcut.sound_loops"          },
8264   { TYPE_KEY_X11, &ssi.sound_music,     "shortcut.sound_music"          },
8265   { TYPE_KEY_X11, &ssi.snap_left,       "shortcut.snap_left"            },
8266   { TYPE_KEY_X11, &ssi.snap_right,      "shortcut.snap_right"           },
8267   { TYPE_KEY_X11, &ssi.snap_up,         "shortcut.snap_up"              },
8268   { TYPE_KEY_X11, &ssi.snap_down,       "shortcut.snap_down"            },
8269 };
8270
8271 static struct TokenInfo player_setup_tokens[] =
8272 {
8273   { TYPE_BOOLEAN, &sii.use_joystick,    ".use_joystick"                 },
8274   { TYPE_STRING,  &sii.joy.device_name, ".joy.device_name"              },
8275   { TYPE_INTEGER, &sii.joy.xleft,       ".joy.xleft"                    },
8276   { TYPE_INTEGER, &sii.joy.xmiddle,     ".joy.xmiddle"                  },
8277   { TYPE_INTEGER, &sii.joy.xright,      ".joy.xright"                   },
8278   { TYPE_INTEGER, &sii.joy.yupper,      ".joy.yupper"                   },
8279   { TYPE_INTEGER, &sii.joy.ymiddle,     ".joy.ymiddle"                  },
8280   { TYPE_INTEGER, &sii.joy.ylower,      ".joy.ylower"                   },
8281   { TYPE_INTEGER, &sii.joy.snap,        ".joy.snap_field"               },
8282   { TYPE_INTEGER, &sii.joy.drop,        ".joy.place_bomb"               },
8283   { TYPE_KEY_X11, &sii.key.left,        ".key.move_left"                },
8284   { TYPE_KEY_X11, &sii.key.right,       ".key.move_right"               },
8285   { TYPE_KEY_X11, &sii.key.up,          ".key.move_up"                  },
8286   { TYPE_KEY_X11, &sii.key.down,        ".key.move_down"                },
8287   { TYPE_KEY_X11, &sii.key.snap,        ".key.snap_field"               },
8288   { TYPE_KEY_X11, &sii.key.drop,        ".key.place_bomb"               },
8289 };
8290
8291 static struct TokenInfo system_setup_tokens[] =
8292 {
8293   { TYPE_STRING,  &syi.sdl_videodriver,    "system.sdl_videodriver"     },
8294   { TYPE_STRING,  &syi.sdl_audiodriver,    "system.sdl_audiodriver"     },
8295   { TYPE_INTEGER, &syi.audio_fragment_size,"system.audio_fragment_size" },
8296 };
8297
8298 static struct TokenInfo internal_setup_tokens[] =
8299 {
8300   { TYPE_STRING, &sxi.program_title,            "program_title"         },
8301   { TYPE_STRING, &sxi.program_version,          "program_version"       },
8302   { TYPE_STRING, &sxi.program_author,           "program_author"        },
8303   { TYPE_STRING, &sxi.program_email,            "program_email"         },
8304   { TYPE_STRING, &sxi.program_website,          "program_website"       },
8305   { TYPE_STRING, &sxi.program_copyright,        "program_copyright"     },
8306   { TYPE_STRING, &sxi.program_company,          "program_company"       },
8307   { TYPE_STRING, &sxi.program_icon_file,        "program_icon_file"     },
8308   { TYPE_STRING, &sxi.default_graphics_set,     "default_graphics_set"  },
8309   { TYPE_STRING, &sxi.default_sounds_set,       "default_sounds_set"    },
8310   { TYPE_STRING, &sxi.default_music_set,        "default_music_set"     },
8311   { TYPE_STRING, &sxi.fallback_graphics_file,   "fallback_graphics_file"},
8312   { TYPE_STRING, &sxi.fallback_sounds_file,     "fallback_sounds_file"  },
8313   { TYPE_STRING, &sxi.fallback_music_file,      "fallback_music_file"   },
8314   { TYPE_STRING, &sxi.default_level_series,     "default_level_series"  },
8315   { TYPE_BOOLEAN,&sxi.choose_from_top_leveldir, "choose_from_top_leveldir" },
8316   { TYPE_BOOLEAN,&sxi.show_scaling_in_title,    "show_scaling_in_title" },
8317   { TYPE_INTEGER,&sxi.default_window_width,     "default_window_width"  },
8318   { TYPE_INTEGER,&sxi.default_window_height,    "default_window_height" },
8319 };
8320
8321 static struct TokenInfo debug_setup_tokens[] =
8322 {
8323   { TYPE_INTEGER, &sdi.frame_delay[0],          "debug.frame_delay_0"   },
8324   { TYPE_INTEGER, &sdi.frame_delay[1],          "debug.frame_delay_1"   },
8325   { TYPE_INTEGER, &sdi.frame_delay[2],          "debug.frame_delay_2"   },
8326   { TYPE_INTEGER, &sdi.frame_delay[3],          "debug.frame_delay_3"   },
8327   { TYPE_INTEGER, &sdi.frame_delay[4],          "debug.frame_delay_4"   },
8328   { TYPE_INTEGER, &sdi.frame_delay[5],          "debug.frame_delay_5"   },
8329   { TYPE_INTEGER, &sdi.frame_delay[6],          "debug.frame_delay_6"   },
8330   { TYPE_INTEGER, &sdi.frame_delay[7],          "debug.frame_delay_7"   },
8331   { TYPE_INTEGER, &sdi.frame_delay[8],          "debug.frame_delay_8"   },
8332   { TYPE_INTEGER, &sdi.frame_delay[9],          "debug.frame_delay_9"   },
8333   { TYPE_KEY_X11, &sdi.frame_delay_key[0],      "debug.key.frame_delay_0" },
8334   { TYPE_KEY_X11, &sdi.frame_delay_key[1],      "debug.key.frame_delay_1" },
8335   { TYPE_KEY_X11, &sdi.frame_delay_key[2],      "debug.key.frame_delay_2" },
8336   { TYPE_KEY_X11, &sdi.frame_delay_key[3],      "debug.key.frame_delay_3" },
8337   { TYPE_KEY_X11, &sdi.frame_delay_key[4],      "debug.key.frame_delay_4" },
8338   { TYPE_KEY_X11, &sdi.frame_delay_key[5],      "debug.key.frame_delay_5" },
8339   { TYPE_KEY_X11, &sdi.frame_delay_key[6],      "debug.key.frame_delay_6" },
8340   { TYPE_KEY_X11, &sdi.frame_delay_key[7],      "debug.key.frame_delay_7" },
8341   { TYPE_KEY_X11, &sdi.frame_delay_key[8],      "debug.key.frame_delay_8" },
8342   { TYPE_KEY_X11, &sdi.frame_delay_key[9],      "debug.key.frame_delay_9" },
8343   { TYPE_BOOLEAN, &sdi.frame_delay_use_mod_key,"debug.frame_delay.use_mod_key"},
8344   { TYPE_BOOLEAN, &sdi.frame_delay_game_only,  "debug.frame_delay.game_only" },
8345   { TYPE_BOOLEAN, &sdi.show_frames_per_second, "debug.show_frames_per_second" },
8346 };
8347
8348 static struct TokenInfo options_setup_tokens[] =
8349 {
8350   { TYPE_BOOLEAN, &soi.verbose,         "options.verbose"               },
8351 };
8352
8353 static char *get_corrected_login_name(char *login_name)
8354 {
8355   /* needed because player name must be a fixed length string */
8356   char *login_name_new = checked_malloc(MAX_PLAYER_NAME_LEN + 1);
8357
8358   strncpy(login_name_new, login_name, MAX_PLAYER_NAME_LEN);
8359   login_name_new[MAX_PLAYER_NAME_LEN] = '\0';
8360
8361   if (strlen(login_name) > MAX_PLAYER_NAME_LEN)         /* name has been cut */
8362     if (strchr(login_name_new, ' '))
8363       *strchr(login_name_new, ' ') = '\0';
8364
8365   return login_name_new;
8366 }
8367
8368 static void setSetupInfoToDefaults(struct SetupInfo *si)
8369 {
8370   int i;
8371
8372   si->player_name = get_corrected_login_name(getLoginName());
8373
8374   si->sound = TRUE;
8375   si->sound_loops = TRUE;
8376   si->sound_music = TRUE;
8377   si->sound_simple = TRUE;
8378   si->toons = TRUE;
8379   si->scroll_delay = TRUE;
8380   si->scroll_delay_value = STD_SCROLL_DELAY;
8381   si->engine_snapshot_mode = getStringCopy(STR_SNAPSHOT_MODE_DEFAULT);
8382   si->engine_snapshot_memory = SNAPSHOT_MEMORY_DEFAULT;
8383   si->fade_screens = TRUE;
8384   si->autorecord = TRUE;
8385   si->show_titlescreen = TRUE;
8386   si->quick_doors = FALSE;
8387   si->team_mode = FALSE;
8388   si->handicap = TRUE;
8389   si->skip_levels = TRUE;
8390   si->increment_levels = TRUE;
8391   si->time_limit = TRUE;
8392   si->fullscreen = FALSE;
8393   si->window_scaling_percent = STD_WINDOW_SCALING_PERCENT;
8394   si->window_scaling_quality = getStringCopy(SCALING_QUALITY_DEFAULT);
8395   si->screen_rendering_mode = getStringCopy(STR_SPECIAL_RENDERING_DEFAULT);
8396   si->ask_on_escape = TRUE;
8397   si->ask_on_escape_editor = TRUE;
8398   si->quick_switch = FALSE;
8399   si->input_on_focus = FALSE;
8400   si->prefer_aga_graphics = TRUE;
8401   si->game_frame_delay = GAME_FRAME_DELAY;
8402   si->sp_show_border_elements = FALSE;
8403   si->small_game_graphics = FALSE;
8404   si->show_snapshot_buttons = FALSE;
8405
8406   si->graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
8407   si->sounds_set   = getStringCopy(SND_CLASSIC_SUBDIR);
8408   si->music_set    = getStringCopy(MUS_CLASSIC_SUBDIR);
8409
8410   si->override_level_graphics = FALSE;
8411   si->override_level_sounds = FALSE;
8412   si->override_level_music = FALSE;
8413
8414   si->volume_simple = 100;              /* percent */
8415   si->volume_loops = 100;               /* percent */
8416   si->volume_music = 100;               /* percent */
8417
8418   si->touch.control_type = getStringCopy(TOUCH_CONTROL_DEFAULT);
8419   si->touch.move_distance = TOUCH_MOVE_DISTANCE_DEFAULT;        /* percent */
8420   si->touch.drop_distance = TOUCH_DROP_DISTANCE_DEFAULT;        /* percent */
8421
8422   si->editor.el_boulderdash             = TRUE;
8423   si->editor.el_emerald_mine            = TRUE;
8424   si->editor.el_emerald_mine_club       = TRUE;
8425   si->editor.el_more                    = TRUE;
8426   si->editor.el_sokoban                 = TRUE;
8427   si->editor.el_supaplex                = TRUE;
8428   si->editor.el_diamond_caves           = TRUE;
8429   si->editor.el_dx_boulderdash          = TRUE;
8430   si->editor.el_chars                   = TRUE;
8431   si->editor.el_steel_chars             = TRUE;
8432
8433   si->editor.el_classic                 = TRUE;
8434   si->editor.el_custom                  = TRUE;
8435
8436   si->editor.el_user_defined            = FALSE;
8437   si->editor.el_dynamic                 = TRUE;
8438
8439   si->editor.el_headlines               = TRUE;
8440
8441   si->editor.show_element_token         = FALSE;
8442
8443   si->editor.use_template_for_new_levels = TRUE;
8444
8445   si->shortcut.save_game        = DEFAULT_KEY_SAVE_GAME;
8446   si->shortcut.load_game        = DEFAULT_KEY_LOAD_GAME;
8447   si->shortcut.toggle_pause     = DEFAULT_KEY_TOGGLE_PAUSE;
8448
8449   si->shortcut.focus_player[0]  = DEFAULT_KEY_FOCUS_PLAYER_1;
8450   si->shortcut.focus_player[1]  = DEFAULT_KEY_FOCUS_PLAYER_2;
8451   si->shortcut.focus_player[2]  = DEFAULT_KEY_FOCUS_PLAYER_3;
8452   si->shortcut.focus_player[3]  = DEFAULT_KEY_FOCUS_PLAYER_4;
8453   si->shortcut.focus_player_all = DEFAULT_KEY_FOCUS_PLAYER_ALL;
8454
8455   si->shortcut.tape_eject       = DEFAULT_KEY_TAPE_EJECT;
8456   si->shortcut.tape_extra       = DEFAULT_KEY_TAPE_EXTRA;
8457   si->shortcut.tape_stop        = DEFAULT_KEY_TAPE_STOP;
8458   si->shortcut.tape_pause       = DEFAULT_KEY_TAPE_PAUSE;
8459   si->shortcut.tape_record      = DEFAULT_KEY_TAPE_RECORD;
8460   si->shortcut.tape_play        = DEFAULT_KEY_TAPE_PLAY;
8461
8462   si->shortcut.sound_simple     = DEFAULT_KEY_SOUND_SIMPLE;
8463   si->shortcut.sound_loops      = DEFAULT_KEY_SOUND_LOOPS;
8464   si->shortcut.sound_music      = DEFAULT_KEY_SOUND_MUSIC;
8465
8466   si->shortcut.snap_left        = DEFAULT_KEY_SNAP_LEFT;
8467   si->shortcut.snap_right       = DEFAULT_KEY_SNAP_RIGHT;
8468   si->shortcut.snap_up          = DEFAULT_KEY_SNAP_UP;
8469   si->shortcut.snap_down        = DEFAULT_KEY_SNAP_DOWN;
8470
8471   for (i = 0; i < MAX_PLAYERS; i++)
8472   {
8473     si->input[i].use_joystick = FALSE;
8474     si->input[i].joy.device_name=getStringCopy(getDeviceNameFromJoystickNr(i));
8475     si->input[i].joy.xleft   = JOYSTICK_XLEFT;
8476     si->input[i].joy.xmiddle = JOYSTICK_XMIDDLE;
8477     si->input[i].joy.xright  = JOYSTICK_XRIGHT;
8478     si->input[i].joy.yupper  = JOYSTICK_YUPPER;
8479     si->input[i].joy.ymiddle = JOYSTICK_YMIDDLE;
8480     si->input[i].joy.ylower  = JOYSTICK_YLOWER;
8481     si->input[i].joy.snap  = (i == 0 ? JOY_BUTTON_1 : 0);
8482     si->input[i].joy.drop  = (i == 0 ? JOY_BUTTON_2 : 0);
8483     si->input[i].key.left  = (i == 0 ? DEFAULT_KEY_LEFT  : KSYM_UNDEFINED);
8484     si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KSYM_UNDEFINED);
8485     si->input[i].key.up    = (i == 0 ? DEFAULT_KEY_UP    : KSYM_UNDEFINED);
8486     si->input[i].key.down  = (i == 0 ? DEFAULT_KEY_DOWN  : KSYM_UNDEFINED);
8487     si->input[i].key.snap  = (i == 0 ? DEFAULT_KEY_SNAP  : KSYM_UNDEFINED);
8488     si->input[i].key.drop  = (i == 0 ? DEFAULT_KEY_DROP  : KSYM_UNDEFINED);
8489   }
8490
8491   si->system.sdl_videodriver = getStringCopy(ARG_DEFAULT);
8492   si->system.sdl_audiodriver = getStringCopy(ARG_DEFAULT);
8493   si->system.audio_fragment_size = DEFAULT_AUDIO_FRAGMENT_SIZE;
8494
8495   si->internal.program_title     = getStringCopy(PROGRAM_TITLE_STRING);
8496   si->internal.program_version   = getStringCopy(getProgramRealVersionString());
8497   si->internal.program_author    = getStringCopy(PROGRAM_AUTHOR_STRING);
8498   si->internal.program_email     = getStringCopy(PROGRAM_EMAIL_STRING);
8499   si->internal.program_website   = getStringCopy(PROGRAM_WEBSITE_STRING);
8500   si->internal.program_copyright = getStringCopy(PROGRAM_COPYRIGHT_STRING);
8501   si->internal.program_company   = getStringCopy(PROGRAM_COMPANY_STRING);
8502
8503   si->internal.program_icon_file = getStringCopy(PROGRAM_ICON_FILENAME);
8504
8505   si->internal.default_graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
8506   si->internal.default_sounds_set   = getStringCopy(SND_CLASSIC_SUBDIR);
8507   si->internal.default_music_set    = getStringCopy(MUS_CLASSIC_SUBDIR);
8508
8509   si->internal.fallback_graphics_file = getStringCopy(UNDEFINED_FILENAME);
8510   si->internal.fallback_sounds_file   = getStringCopy(UNDEFINED_FILENAME);
8511   si->internal.fallback_music_file    = getStringCopy(UNDEFINED_FILENAME);
8512
8513   si->internal.default_level_series = getStringCopy(UNDEFINED_LEVELSET);
8514   si->internal.choose_from_top_leveldir = FALSE;
8515   si->internal.show_scaling_in_title = TRUE;
8516
8517   si->internal.default_window_width  = WIN_XSIZE_DEFAULT;
8518   si->internal.default_window_height = WIN_YSIZE_DEFAULT;
8519
8520   si->debug.frame_delay[0] = DEFAULT_FRAME_DELAY_0;
8521   si->debug.frame_delay[1] = DEFAULT_FRAME_DELAY_1;
8522   si->debug.frame_delay[2] = DEFAULT_FRAME_DELAY_2;
8523   si->debug.frame_delay[3] = DEFAULT_FRAME_DELAY_3;
8524   si->debug.frame_delay[4] = DEFAULT_FRAME_DELAY_4;
8525   si->debug.frame_delay[5] = DEFAULT_FRAME_DELAY_5;
8526   si->debug.frame_delay[6] = DEFAULT_FRAME_DELAY_6;
8527   si->debug.frame_delay[7] = DEFAULT_FRAME_DELAY_7;
8528   si->debug.frame_delay[8] = DEFAULT_FRAME_DELAY_8;
8529   si->debug.frame_delay[9] = DEFAULT_FRAME_DELAY_9;
8530
8531   si->debug.frame_delay_key[0] = DEFAULT_KEY_FRAME_DELAY_0;
8532   si->debug.frame_delay_key[1] = DEFAULT_KEY_FRAME_DELAY_1;
8533   si->debug.frame_delay_key[2] = DEFAULT_KEY_FRAME_DELAY_2;
8534   si->debug.frame_delay_key[3] = DEFAULT_KEY_FRAME_DELAY_3;
8535   si->debug.frame_delay_key[4] = DEFAULT_KEY_FRAME_DELAY_4;
8536   si->debug.frame_delay_key[5] = DEFAULT_KEY_FRAME_DELAY_5;
8537   si->debug.frame_delay_key[6] = DEFAULT_KEY_FRAME_DELAY_6;
8538   si->debug.frame_delay_key[7] = DEFAULT_KEY_FRAME_DELAY_7;
8539   si->debug.frame_delay_key[8] = DEFAULT_KEY_FRAME_DELAY_8;
8540   si->debug.frame_delay_key[9] = DEFAULT_KEY_FRAME_DELAY_9;
8541
8542   si->debug.frame_delay_use_mod_key = DEFAULT_FRAME_DELAY_USE_MOD_KEY;
8543   si->debug.frame_delay_game_only   = DEFAULT_FRAME_DELAY_GAME_ONLY;
8544
8545   si->debug.show_frames_per_second = FALSE;
8546
8547   si->options.verbose = FALSE;
8548
8549 #if defined(PLATFORM_ANDROID)
8550   si->fullscreen = TRUE;
8551 #endif
8552 }
8553
8554 static void setSetupInfoToDefaults_EditorCascade(struct SetupInfo *si)
8555 {
8556   si->editor_cascade.el_bd              = TRUE;
8557   si->editor_cascade.el_em              = TRUE;
8558   si->editor_cascade.el_emc             = TRUE;
8559   si->editor_cascade.el_rnd             = TRUE;
8560   si->editor_cascade.el_sb              = TRUE;
8561   si->editor_cascade.el_sp              = TRUE;
8562   si->editor_cascade.el_dc              = TRUE;
8563   si->editor_cascade.el_dx              = TRUE;
8564
8565   si->editor_cascade.el_chars           = FALSE;
8566   si->editor_cascade.el_steel_chars     = FALSE;
8567   si->editor_cascade.el_ce              = FALSE;
8568   si->editor_cascade.el_ge              = FALSE;
8569   si->editor_cascade.el_ref             = FALSE;
8570   si->editor_cascade.el_user            = FALSE;
8571   si->editor_cascade.el_dynamic         = FALSE;
8572 }
8573
8574 #define MAX_HIDE_SETUP_TOKEN_SIZE               20
8575
8576 static char *getHideSetupToken(void *setup_value)
8577 {
8578   static char hide_setup_token[MAX_HIDE_SETUP_TOKEN_SIZE];
8579
8580   if (setup_value != NULL)
8581     snprintf(hide_setup_token, MAX_HIDE_SETUP_TOKEN_SIZE, "%p", setup_value);
8582
8583   return hide_setup_token;
8584 }
8585
8586 static void setHideSetupEntry(void *setup_value_raw)
8587 {
8588   /* !!! DIRTY WORKAROUND; TO BE FIXED AFTER THE MM ENGINE RELEASE !!! */
8589   void *setup_value = setup_value_raw - (void *)&si + (void *)&setup;
8590
8591   char *hide_setup_token = getHideSetupToken(setup_value);
8592
8593   if (setup_value != NULL)
8594     setHashEntry(hide_setup_hash, hide_setup_token, "");
8595 }
8596
8597 boolean hideSetupEntry(void *setup_value)
8598 {
8599   char *hide_setup_token = getHideSetupToken(setup_value);
8600
8601   return (setup_value != NULL &&
8602           getHashEntry(hide_setup_hash, hide_setup_token) != NULL);
8603 }
8604
8605 static void setSetupInfoFromTokenText(SetupFileHash *setup_file_hash,
8606                                       struct TokenInfo *token_info,
8607                                       int token_nr, char *token_text)
8608 {
8609   char *token_hide_text = getStringCat2(token_text, ".hide");
8610   char *token_hide_value = getHashEntry(setup_file_hash, token_hide_text);
8611
8612   /* set the value of this setup option in the setup option structure */
8613   setSetupInfo(token_info, token_nr, getHashEntry(setup_file_hash, token_text));
8614
8615   /* check if this setup option should be hidden in the setup menu */
8616   if (token_hide_value != NULL && get_boolean_from_string(token_hide_value))
8617     setHideSetupEntry(token_info[token_nr].value);
8618 }
8619
8620 static void setSetupInfoFromTokenInfo(SetupFileHash *setup_file_hash,
8621                                       struct TokenInfo *token_info,
8622                                       int token_nr)
8623 {
8624   setSetupInfoFromTokenText(setup_file_hash, token_info, token_nr,
8625                             token_info[token_nr].text);
8626 }
8627
8628 static void decodeSetupFileHash(SetupFileHash *setup_file_hash)
8629 {
8630   int i, pnr;
8631
8632   if (!setup_file_hash)
8633     return;
8634
8635   if (hide_setup_hash == NULL)
8636     hide_setup_hash = newSetupFileHash();
8637
8638   /* global setup */
8639   si = setup;
8640   for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
8641     setSetupInfoFromTokenInfo(setup_file_hash, global_setup_tokens, i);
8642   setup = si;
8643
8644   /* editor setup */
8645   sei = setup.editor;
8646   for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
8647     setSetupInfoFromTokenInfo(setup_file_hash, editor_setup_tokens, i);
8648   setup.editor = sei;
8649
8650   /* shortcut setup */
8651   ssi = setup.shortcut;
8652   for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
8653     setSetupInfoFromTokenInfo(setup_file_hash, shortcut_setup_tokens, i);
8654   setup.shortcut = ssi;
8655
8656   /* player setup */
8657   for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
8658   {
8659     char prefix[30];
8660
8661     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
8662
8663     sii = setup.input[pnr];
8664     for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
8665     {
8666       char full_token[100];
8667
8668       sprintf(full_token, "%s%s", prefix, player_setup_tokens[i].text);
8669       setSetupInfoFromTokenText(setup_file_hash, player_setup_tokens, i,
8670                                 full_token);
8671     }
8672     setup.input[pnr] = sii;
8673   }
8674
8675   /* system setup */
8676   syi = setup.system;
8677   for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
8678     setSetupInfoFromTokenInfo(setup_file_hash, system_setup_tokens, i);
8679   setup.system = syi;
8680
8681   /* internal setup */
8682   sxi = setup.internal;
8683   for (i = 0; i < NUM_INTERNAL_SETUP_TOKENS; i++)
8684     setSetupInfoFromTokenInfo(setup_file_hash, internal_setup_tokens, i);
8685   setup.internal = sxi;
8686
8687   /* debug setup */
8688   sdi = setup.debug;
8689   for (i = 0; i < NUM_DEBUG_SETUP_TOKENS; i++)
8690     setSetupInfoFromTokenInfo(setup_file_hash, debug_setup_tokens, i);
8691   setup.debug = sdi;
8692
8693   /* options setup */
8694   soi = setup.options;
8695   for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
8696     setSetupInfoFromTokenInfo(setup_file_hash, options_setup_tokens, i);
8697   setup.options = soi;
8698 }
8699
8700 static void decodeSetupFileHash_EditorCascade(SetupFileHash *setup_file_hash)
8701 {
8702   int i;
8703
8704   if (!setup_file_hash)
8705     return;
8706
8707   /* editor cascade setup */
8708   seci = setup.editor_cascade;
8709   for (i = 0; i < NUM_EDITOR_CASCADE_SETUP_TOKENS; i++)
8710     setSetupInfo(editor_cascade_setup_tokens, i,
8711                  getHashEntry(setup_file_hash,
8712                               editor_cascade_setup_tokens[i].text));
8713   setup.editor_cascade = seci;
8714 }
8715
8716 void LoadSetupFromFilename(char *filename)
8717 {
8718   SetupFileHash *setup_file_hash = loadSetupFileHash(filename);
8719
8720   if (setup_file_hash)
8721   {
8722     decodeSetupFileHash(setup_file_hash);
8723
8724     freeSetupFileHash(setup_file_hash);
8725   }
8726   else
8727   {
8728     Error(ERR_DEBUG, "using default setup values");
8729   }
8730 }
8731
8732 static void LoadSetup_SpecialPostProcessing()
8733 {
8734   char *player_name_new;
8735
8736   /* needed to work around problems with fixed length strings */
8737   player_name_new = get_corrected_login_name(setup.player_name);
8738   free(setup.player_name);
8739   setup.player_name = player_name_new;
8740
8741   /* "scroll_delay: on(3) / off(0)" was replaced by scroll delay value */
8742   if (setup.scroll_delay == FALSE)
8743   {
8744     setup.scroll_delay_value = MIN_SCROLL_DELAY;
8745     setup.scroll_delay = TRUE;                  /* now always "on" */
8746   }
8747
8748   /* make sure that scroll delay value stays inside valid range */
8749   setup.scroll_delay_value =
8750     MIN(MAX(MIN_SCROLL_DELAY, setup.scroll_delay_value), MAX_SCROLL_DELAY);
8751 }
8752
8753 void LoadSetup()
8754 {
8755   char *filename;
8756
8757   /* always start with reliable default values */
8758   setSetupInfoToDefaults(&setup);
8759
8760   /* try to load setup values from default setup file */
8761   filename = getDefaultSetupFilename();
8762
8763   if (fileExists(filename))
8764     LoadSetupFromFilename(filename);
8765
8766   /* try to load setup values from user setup file */
8767   filename = getSetupFilename();
8768
8769   LoadSetupFromFilename(filename);
8770
8771   LoadSetup_SpecialPostProcessing();
8772 }
8773
8774 void LoadSetup_EditorCascade()
8775 {
8776   char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
8777   SetupFileHash *setup_file_hash = NULL;
8778
8779   /* always start with reliable default values */
8780   setSetupInfoToDefaults_EditorCascade(&setup);
8781
8782   setup_file_hash = loadSetupFileHash(filename);
8783
8784   if (setup_file_hash)
8785   {
8786     decodeSetupFileHash_EditorCascade(setup_file_hash);
8787
8788     freeSetupFileHash(setup_file_hash);
8789   }
8790
8791   free(filename);
8792 }
8793
8794 static void addGameControllerMappingToHash(SetupFileHash *mappings_hash,
8795                                            char *mapping_line)
8796 {
8797   char mapping_guid[MAX_LINE_LEN];
8798   char *mapping_start, *mapping_end;
8799
8800   // get GUID from game controller mapping line: copy complete line
8801   strncpy(mapping_guid, mapping_line, MAX_LINE_LEN - 1);
8802   mapping_guid[MAX_LINE_LEN - 1] = '\0';
8803
8804   // get GUID from game controller mapping line: cut after GUID part
8805   mapping_start = strchr(mapping_guid, ',');
8806   if (mapping_start != NULL)
8807     *mapping_start = '\0';
8808
8809   // cut newline from game controller mapping line
8810   mapping_end = strchr(mapping_line, '\n');
8811   if (mapping_end != NULL)
8812     *mapping_end = '\0';
8813
8814   // add mapping entry to game controller mappings hash
8815   setHashEntry(mappings_hash, mapping_guid, mapping_line);
8816 }
8817
8818 static void LoadSetup_ReadGameControllerMappings(SetupFileHash *mappings_hash,
8819                                                  char *filename)
8820 {
8821   FILE *file;
8822
8823   if (!(file = fopen(filename, MODE_READ)))
8824   {
8825     Error(ERR_WARN, "cannot read game controller mappings file '%s'", filename);
8826
8827     return;
8828   }
8829
8830   while (!feof(file))
8831   {
8832     char line[MAX_LINE_LEN];
8833
8834     if (!fgets(line, MAX_LINE_LEN, file))
8835       break;
8836
8837     addGameControllerMappingToHash(mappings_hash, line);
8838   }
8839
8840   fclose(file);
8841 }
8842
8843 void SaveSetup()
8844 {
8845   char *filename = getSetupFilename();
8846   FILE *file;
8847   int i, pnr;
8848
8849   InitUserDataDirectory();
8850
8851   if (!(file = fopen(filename, MODE_WRITE)))
8852   {
8853     Error(ERR_WARN, "cannot write setup file '%s'", filename);
8854     return;
8855   }
8856
8857   fprintFileHeader(file, SETUP_FILENAME);
8858
8859   /* global setup */
8860   si = setup;
8861   for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
8862   {
8863     /* just to make things nicer :) */
8864     if (i == SETUP_TOKEN_PLAYER_NAME + 1 ||
8865         i == SETUP_TOKEN_GRAPHICS_SET ||
8866         i == SETUP_TOKEN_VOLUME_SIMPLE ||
8867         i == SETUP_TOKEN_TOUCH_CONTROL_TYPE)
8868       fprintf(file, "\n");
8869
8870     fprintf(file, "%s\n", getSetupLine(global_setup_tokens, "", i));
8871   }
8872
8873   /* editor setup */
8874   sei = setup.editor;
8875   fprintf(file, "\n");
8876   for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
8877     fprintf(file, "%s\n", getSetupLine(editor_setup_tokens, "", i));
8878
8879   /* shortcut setup */
8880   ssi = setup.shortcut;
8881   fprintf(file, "\n");
8882   for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
8883     fprintf(file, "%s\n", getSetupLine(shortcut_setup_tokens, "", i));
8884
8885   /* player setup */
8886   for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
8887   {
8888     char prefix[30];
8889
8890     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
8891     fprintf(file, "\n");
8892
8893     sii = setup.input[pnr];
8894     for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
8895       fprintf(file, "%s\n", getSetupLine(player_setup_tokens, prefix, i));
8896   }
8897
8898   /* system setup */
8899   syi = setup.system;
8900   fprintf(file, "\n");
8901   for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
8902     fprintf(file, "%s\n", getSetupLine(system_setup_tokens, "", i));
8903
8904   /* internal setup */
8905   /* (internal setup values not saved to user setup file) */
8906
8907   /* debug setup */
8908   sdi = setup.debug;
8909   fprintf(file, "\n");
8910   for (i = 0; i < NUM_DEBUG_SETUP_TOKENS; i++)
8911     fprintf(file, "%s\n", getSetupLine(debug_setup_tokens, "", i));
8912
8913   /* options setup */
8914   soi = setup.options;
8915   fprintf(file, "\n");
8916   for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
8917     fprintf(file, "%s\n", getSetupLine(options_setup_tokens, "", i));
8918
8919   fclose(file);
8920
8921   SetFilePermissions(filename, PERMS_PRIVATE);
8922 }
8923
8924 void SaveSetup_EditorCascade()
8925 {
8926   char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
8927   FILE *file;
8928   int i;
8929
8930   InitUserDataDirectory();
8931
8932   if (!(file = fopen(filename, MODE_WRITE)))
8933   {
8934     Error(ERR_WARN, "cannot write editor cascade state file '%s'", filename);
8935     free(filename);
8936     return;
8937   }
8938
8939   fprintFileHeader(file, EDITORCASCADE_FILENAME);
8940
8941   seci = setup.editor_cascade;
8942   for (i = 0; i < NUM_EDITOR_CASCADE_SETUP_TOKENS; i++)
8943     fprintf(file, "%s\n", getSetupLine(editor_cascade_setup_tokens, "", i));
8944
8945   fclose(file);
8946
8947   SetFilePermissions(filename, PERMS_PRIVATE);
8948
8949   free(filename);
8950 }
8951
8952 static void SaveSetup_WriteGameControllerMappings(SetupFileHash *mappings_hash,
8953                                                   char *filename)
8954 {
8955   FILE *file;
8956
8957   if (!(file = fopen(filename, MODE_WRITE)))
8958   {
8959     Error(ERR_WARN, "cannot write game controller mappings file '%s'",filename);
8960
8961     return;
8962   }
8963
8964   BEGIN_HASH_ITERATION(mappings_hash, itr)
8965   {
8966     fprintf(file, "%s\n", HASH_ITERATION_VALUE(itr));
8967   }
8968   END_HASH_ITERATION(mappings_hash, itr)
8969
8970   fclose(file);
8971 }
8972
8973 void SaveSetup_AddGameControllerMapping(char *mapping)
8974 {
8975   char *filename = getPath2(getSetupDir(), GAMECONTROLLER_BASENAME);
8976   SetupFileHash *mappings_hash = newSetupFileHash();
8977
8978   InitUserDataDirectory();
8979
8980   // load existing personal game controller mappings
8981   LoadSetup_ReadGameControllerMappings(mappings_hash, filename);
8982
8983   // add new mapping to personal game controller mappings
8984   addGameControllerMappingToHash(mappings_hash, mapping);
8985
8986   // save updated personal game controller mappings
8987   SaveSetup_WriteGameControllerMappings(mappings_hash, filename);
8988
8989   freeSetupFileHash(mappings_hash);
8990   free(filename);
8991 }
8992
8993 void LoadCustomElementDescriptions()
8994 {
8995   char *filename = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
8996   SetupFileHash *setup_file_hash;
8997   int i;
8998
8999   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
9000   {
9001     if (element_info[i].custom_description != NULL)
9002     {
9003       free(element_info[i].custom_description);
9004       element_info[i].custom_description = NULL;
9005     }
9006   }
9007
9008   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
9009     return;
9010
9011   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
9012   {
9013     char *token = getStringCat2(element_info[i].token_name, ".name");
9014     char *value = getHashEntry(setup_file_hash, token);
9015
9016     if (value != NULL)
9017       element_info[i].custom_description = getStringCopy(value);
9018
9019     free(token);
9020   }
9021
9022   freeSetupFileHash(setup_file_hash);
9023 }
9024
9025 static int getElementFromToken(char *token)
9026 {
9027   char *value = getHashEntry(element_token_hash, token);
9028
9029   if (value != NULL)
9030     return atoi(value);
9031
9032   Error(ERR_WARN, "unknown element token '%s'", token);
9033
9034   return EL_UNDEFINED;
9035 }
9036
9037 static int get_token_parameter_value(char *token, char *value_raw)
9038 {
9039   char *suffix;
9040
9041   if (token == NULL || value_raw == NULL)
9042     return ARG_UNDEFINED_VALUE;
9043
9044   suffix = strrchr(token, '.');
9045   if (suffix == NULL)
9046     suffix = token;
9047
9048   if (strEqual(suffix, ".element"))
9049     return getElementFromToken(value_raw);
9050
9051   /* !!! USE CORRECT VALUE TYPE (currently works also for TYPE_BOOLEAN) !!! */
9052   return get_parameter_value(value_raw, suffix, TYPE_INTEGER);
9053 }
9054
9055 void InitMenuDesignSettings_Static()
9056 {
9057   int i;
9058
9059   /* always start with reliable default values from static default config */
9060   for (i = 0; image_config_vars[i].token != NULL; i++)
9061   {
9062     char *value = getHashEntry(image_config_hash, image_config_vars[i].token);
9063
9064     if (value != NULL)
9065       *image_config_vars[i].value =
9066         get_token_parameter_value(image_config_vars[i].token, value);
9067   }
9068 }
9069
9070 static void InitMenuDesignSettings_SpecialPreProcessing()
9071 {
9072   int i;
9073
9074   /* the following initializes hierarchical values from static configuration */
9075
9076   /* special case: initialize "ARG_DEFAULT" values in static default config */
9077   /* (e.g., initialize "[titlemessage].fade_mode" from "[title].fade_mode") */
9078   titlescreen_initial_first_default.fade_mode  =
9079     title_initial_first_default.fade_mode;
9080   titlescreen_initial_first_default.fade_delay =
9081     title_initial_first_default.fade_delay;
9082   titlescreen_initial_first_default.post_delay =
9083     title_initial_first_default.post_delay;
9084   titlescreen_initial_first_default.auto_delay =
9085     title_initial_first_default.auto_delay;
9086   titlescreen_first_default.fade_mode  = title_first_default.fade_mode;
9087   titlescreen_first_default.fade_delay = title_first_default.fade_delay;
9088   titlescreen_first_default.post_delay = title_first_default.post_delay;
9089   titlescreen_first_default.auto_delay = title_first_default.auto_delay;
9090   titlemessage_initial_first_default.fade_mode  =
9091     title_initial_first_default.fade_mode;
9092   titlemessage_initial_first_default.fade_delay =
9093     title_initial_first_default.fade_delay;
9094   titlemessage_initial_first_default.post_delay =
9095     title_initial_first_default.post_delay;
9096   titlemessage_initial_first_default.auto_delay =
9097     title_initial_first_default.auto_delay;
9098   titlemessage_first_default.fade_mode  = title_first_default.fade_mode;
9099   titlemessage_first_default.fade_delay = title_first_default.fade_delay;
9100   titlemessage_first_default.post_delay = title_first_default.post_delay;
9101   titlemessage_first_default.auto_delay = title_first_default.auto_delay;
9102
9103   titlescreen_initial_default.fade_mode  = title_initial_default.fade_mode;
9104   titlescreen_initial_default.fade_delay = title_initial_default.fade_delay;
9105   titlescreen_initial_default.post_delay = title_initial_default.post_delay;
9106   titlescreen_initial_default.auto_delay = title_initial_default.auto_delay;
9107   titlescreen_default.fade_mode  = title_default.fade_mode;
9108   titlescreen_default.fade_delay = title_default.fade_delay;
9109   titlescreen_default.post_delay = title_default.post_delay;
9110   titlescreen_default.auto_delay = title_default.auto_delay;
9111   titlemessage_initial_default.fade_mode  = title_initial_default.fade_mode;
9112   titlemessage_initial_default.fade_delay = title_initial_default.fade_delay;
9113   titlemessage_initial_default.post_delay = title_initial_default.post_delay;
9114   titlemessage_initial_default.auto_delay = title_initial_default.auto_delay;
9115   titlemessage_default.fade_mode  = title_default.fade_mode;
9116   titlemessage_default.fade_delay = title_default.fade_delay;
9117   titlemessage_default.post_delay = title_default.post_delay;
9118   titlemessage_default.auto_delay = title_default.auto_delay;
9119
9120   /* special case: initialize "ARG_DEFAULT" values in static default config */
9121   /* (e.g., init "titlemessage_1.fade_mode" from "[titlemessage].fade_mode") */
9122   for (i = 0; i < MAX_NUM_TITLE_MESSAGES; i++)
9123   {
9124     titlescreen_initial_first[i] = titlescreen_initial_first_default;
9125     titlescreen_first[i] = titlescreen_first_default;
9126     titlemessage_initial_first[i] = titlemessage_initial_first_default;
9127     titlemessage_first[i] = titlemessage_first_default;
9128
9129     titlescreen_initial[i] = titlescreen_initial_default;
9130     titlescreen[i] = titlescreen_default;
9131     titlemessage_initial[i] = titlemessage_initial_default;
9132     titlemessage[i] = titlemessage_default;
9133   }
9134
9135   /* special case: initialize "ARG_DEFAULT" values in static default config */
9136   /* (eg, init "menu.enter_screen.SCORES.xyz" from "menu.enter_screen.xyz") */
9137   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9138   {
9139     if (i == GFX_SPECIAL_ARG_TITLE)     /* title values already initialized */
9140       continue;
9141
9142     menu.enter_screen[i] = menu.enter_screen[GFX_SPECIAL_ARG_DEFAULT];
9143     menu.leave_screen[i] = menu.leave_screen[GFX_SPECIAL_ARG_DEFAULT];
9144     menu.next_screen[i]  = menu.next_screen[GFX_SPECIAL_ARG_DEFAULT];
9145   }
9146
9147   /* special case: initialize "ARG_DEFAULT" values in static default config */
9148   /* (eg, init "viewport.door_1.MAIN.xyz" from "viewport.door_1.xyz") */
9149   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9150   {
9151     viewport.window[i]    = viewport.window[GFX_SPECIAL_ARG_DEFAULT];
9152     viewport.playfield[i] = viewport.playfield[GFX_SPECIAL_ARG_DEFAULT];
9153     viewport.door_1[i]    = viewport.door_1[GFX_SPECIAL_ARG_DEFAULT];
9154
9155     if (i == GFX_SPECIAL_ARG_EDITOR)    /* editor values already initialized */
9156       continue;
9157
9158     viewport.door_2[i] = viewport.door_2[GFX_SPECIAL_ARG_DEFAULT];
9159   }
9160 }
9161
9162 static void InitMenuDesignSettings_SpecialPostProcessing()
9163 {
9164   static struct
9165   {
9166     struct XY *dst, *src;
9167   }
9168   game_buttons_xy[] =
9169   {
9170     { &game.button.save,        &game.button.stop       },
9171     { &game.button.pause2,      &game.button.pause      },
9172     { &game.button.load,        &game.button.play       },
9173     { &game.button.undo,        &game.button.stop       },
9174     { &game.button.redo,        &game.button.play       },
9175
9176     { NULL,                     NULL                    }
9177   };
9178   int i;
9179
9180   /* special case: initialize later added SETUP list size from LEVELS value */
9181   if (menu.list_size[GAME_MODE_SETUP] == -1)
9182     menu.list_size[GAME_MODE_SETUP] = menu.list_size[GAME_MODE_LEVELS];
9183
9184   /* set default position for snapshot buttons to stop/pause/play buttons */
9185   for (i = 0; game_buttons_xy[i].dst != NULL; i++)
9186     if ((*game_buttons_xy[i].dst).x == -1 &&
9187         (*game_buttons_xy[i].dst).y == -1)
9188       *game_buttons_xy[i].dst = *game_buttons_xy[i].src;
9189 }
9190
9191 static void InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics()
9192 {
9193   static struct
9194   {
9195     struct XYTileSize *dst, *src;
9196     int graphic;
9197   }
9198   editor_buttons_xy[] =
9199   {
9200     {
9201       &editor.button.element_left,      &editor.palette.element_left,
9202       IMG_GFX_EDITOR_BUTTON_ELEMENT_LEFT
9203     },
9204     {
9205       &editor.button.element_middle,    &editor.palette.element_middle,
9206       IMG_GFX_EDITOR_BUTTON_ELEMENT_MIDDLE
9207     },
9208     {
9209       &editor.button.element_right,     &editor.palette.element_right,
9210       IMG_GFX_EDITOR_BUTTON_ELEMENT_RIGHT
9211     },
9212
9213     { NULL,                     NULL                    }
9214   };
9215   int i;
9216
9217   /* set default position for element buttons to element graphics */
9218   for (i = 0; editor_buttons_xy[i].dst != NULL; i++)
9219   {
9220     if ((*editor_buttons_xy[i].dst).x == -1 &&
9221         (*editor_buttons_xy[i].dst).y == -1)
9222     {
9223       struct GraphicInfo *gd = &graphic_info[editor_buttons_xy[i].graphic];
9224
9225       gd->width = gd->height = editor_buttons_xy[i].src->tile_size;
9226
9227       *editor_buttons_xy[i].dst = *editor_buttons_xy[i].src;
9228     }
9229   }
9230 }
9231
9232 static void LoadMenuDesignSettingsFromFilename(char *filename)
9233 {
9234   static struct TitleFadingInfo tfi;
9235   static struct TitleMessageInfo tmi;
9236   static struct TokenInfo title_tokens[] =
9237   {
9238     { TYPE_INTEGER,     &tfi.fade_mode,         ".fade_mode"            },
9239     { TYPE_INTEGER,     &tfi.fade_delay,        ".fade_delay"           },
9240     { TYPE_INTEGER,     &tfi.post_delay,        ".post_delay"           },
9241     { TYPE_INTEGER,     &tfi.auto_delay,        ".auto_delay"           },
9242
9243     { -1,               NULL,                   NULL                    }
9244   };
9245   static struct TokenInfo titlemessage_tokens[] =
9246   {
9247     { TYPE_INTEGER,     &tmi.x,                 ".x"                    },
9248     { TYPE_INTEGER,     &tmi.y,                 ".y"                    },
9249     { TYPE_INTEGER,     &tmi.width,             ".width"                },
9250     { TYPE_INTEGER,     &tmi.height,            ".height"               },
9251     { TYPE_INTEGER,     &tmi.chars,             ".chars"                },
9252     { TYPE_INTEGER,     &tmi.lines,             ".lines"                },
9253     { TYPE_INTEGER,     &tmi.align,             ".align"                },
9254     { TYPE_INTEGER,     &tmi.valign,            ".valign"               },
9255     { TYPE_INTEGER,     &tmi.font,              ".font"                 },
9256     { TYPE_BOOLEAN,     &tmi.autowrap,          ".autowrap"             },
9257     { TYPE_BOOLEAN,     &tmi.centered,          ".centered"             },
9258     { TYPE_BOOLEAN,     &tmi.parse_comments,    ".parse_comments"       },
9259     { TYPE_INTEGER,     &tmi.sort_priority,     ".sort_priority"        },
9260     { TYPE_INTEGER,     &tmi.fade_mode,         ".fade_mode"            },
9261     { TYPE_INTEGER,     &tmi.fade_delay,        ".fade_delay"           },
9262     { TYPE_INTEGER,     &tmi.post_delay,        ".post_delay"           },
9263     { TYPE_INTEGER,     &tmi.auto_delay,        ".auto_delay"           },
9264
9265     { -1,               NULL,                   NULL                    }
9266   };
9267   static struct
9268   {
9269     struct TitleFadingInfo *info;
9270     char *text;
9271   }
9272   title_info[] =
9273   {
9274     /* initialize first titles from "enter screen" definitions, if defined */
9275     { &title_initial_first_default,     "menu.enter_screen.TITLE"       },
9276     { &title_first_default,             "menu.enter_screen.TITLE"       },
9277
9278     /* initialize title screens from "next screen" definitions, if defined */
9279     { &title_initial_default,           "menu.next_screen.TITLE"        },
9280     { &title_default,                   "menu.next_screen.TITLE"        },
9281
9282     { NULL,                             NULL                            }
9283   };
9284   static struct
9285   {
9286     struct TitleMessageInfo *array;
9287     char *text;
9288   }
9289   titlemessage_arrays[] =
9290   {
9291     /* initialize first titles from "enter screen" definitions, if defined */
9292     { titlescreen_initial_first,        "menu.enter_screen.TITLE"       },
9293     { titlescreen_first,                "menu.enter_screen.TITLE"       },
9294     { titlemessage_initial_first,       "menu.enter_screen.TITLE"       },
9295     { titlemessage_first,               "menu.enter_screen.TITLE"       },
9296
9297     /* initialize titles from "next screen" definitions, if defined */
9298     { titlescreen_initial,              "menu.next_screen.TITLE"        },
9299     { titlescreen,                      "menu.next_screen.TITLE"        },
9300     { titlemessage_initial,             "menu.next_screen.TITLE"        },
9301     { titlemessage,                     "menu.next_screen.TITLE"        },
9302
9303     /* overwrite titles with title definitions, if defined */
9304     { titlescreen_initial_first,        "[title_initial]"               },
9305     { titlescreen_first,                "[title]"                       },
9306     { titlemessage_initial_first,       "[title_initial]"               },
9307     { titlemessage_first,               "[title]"                       },
9308
9309     { titlescreen_initial,              "[title_initial]"               },
9310     { titlescreen,                      "[title]"                       },
9311     { titlemessage_initial,             "[title_initial]"               },
9312     { titlemessage,                     "[title]"                       },
9313
9314     /* overwrite titles with title screen/message definitions, if defined */
9315     { titlescreen_initial_first,        "[titlescreen_initial]"         },
9316     { titlescreen_first,                "[titlescreen]"                 },
9317     { titlemessage_initial_first,       "[titlemessage_initial]"        },
9318     { titlemessage_first,               "[titlemessage]"                },
9319
9320     { titlescreen_initial,              "[titlescreen_initial]"         },
9321     { titlescreen,                      "[titlescreen]"                 },
9322     { titlemessage_initial,             "[titlemessage_initial]"        },
9323     { titlemessage,                     "[titlemessage]"                },
9324
9325     { NULL,                             NULL                            }
9326   };
9327   SetupFileHash *setup_file_hash;
9328   int i, j, k;
9329
9330   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
9331     return;
9332
9333   /* the following initializes hierarchical values from dynamic configuration */
9334
9335   /* special case: initialize with default values that may be overwritten */
9336   /* (e.g., init "menu.draw_xoffset.INFO" from "menu.draw_xoffset") */
9337   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9338   {
9339     char *value_1 = getHashEntry(setup_file_hash, "menu.draw_xoffset");
9340     char *value_2 = getHashEntry(setup_file_hash, "menu.draw_yoffset");
9341     char *value_3 = getHashEntry(setup_file_hash, "menu.list_size");
9342
9343     if (value_1 != NULL)
9344       menu.draw_xoffset[i] = get_integer_from_string(value_1);
9345     if (value_2 != NULL)
9346       menu.draw_yoffset[i] = get_integer_from_string(value_2);
9347     if (value_3 != NULL)
9348       menu.list_size[i] = get_integer_from_string(value_3);
9349   }
9350
9351   /* special case: initialize with default values that may be overwritten */
9352   /* (eg, init "menu.draw_xoffset.INFO[XXX]" from "menu.draw_xoffset.INFO") */
9353   for (i = 0; i < NUM_SPECIAL_GFX_INFO_ARGS; i++)
9354   {
9355     char *value_1 = getHashEntry(setup_file_hash, "menu.draw_xoffset.INFO");
9356     char *value_2 = getHashEntry(setup_file_hash, "menu.draw_yoffset.INFO");
9357
9358     if (value_1 != NULL)
9359       menu.draw_xoffset_info[i] = get_integer_from_string(value_1);
9360     if (value_2 != NULL)
9361       menu.draw_yoffset_info[i] = get_integer_from_string(value_2);
9362
9363     if (i == GFX_SPECIAL_ARG_INFO_ELEMENTS)
9364     {
9365       char *value_1 = getHashEntry(setup_file_hash, "menu.list_size.INFO");
9366
9367       if (value_1 != NULL)
9368         menu.list_size_info[i] = get_integer_from_string(value_1);
9369     }
9370   }
9371
9372   /* special case: initialize with default values that may be overwritten */
9373   /* (eg, init "menu.draw_xoffset.SETUP[XXX]" from "menu.draw_xoffset.SETUP") */
9374   for (i = 0; i < NUM_SPECIAL_GFX_SETUP_ARGS; i++)
9375   {
9376     char *value_1 = getHashEntry(setup_file_hash, "menu.draw_xoffset.SETUP");
9377     char *value_2 = getHashEntry(setup_file_hash, "menu.draw_yoffset.SETUP");
9378
9379     if (value_1 != NULL)
9380       menu.draw_xoffset_setup[i] = get_integer_from_string(value_1);
9381     if (value_2 != NULL)
9382       menu.draw_yoffset_setup[i] = get_integer_from_string(value_2);
9383   }
9384
9385   /* special case: initialize with default values that may be overwritten */
9386   /* (eg, init "menu.enter_screen.SCORES.xyz" from "menu.enter_screen.xyz") */
9387   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9388   {
9389     char *token_1 = "menu.enter_screen.fade_mode";
9390     char *token_2 = "menu.enter_screen.fade_delay";
9391     char *token_3 = "menu.enter_screen.post_delay";
9392     char *token_4 = "menu.leave_screen.fade_mode";
9393     char *token_5 = "menu.leave_screen.fade_delay";
9394     char *token_6 = "menu.leave_screen.post_delay";
9395     char *token_7 = "menu.next_screen.fade_mode";
9396     char *token_8 = "menu.next_screen.fade_delay";
9397     char *token_9 = "menu.next_screen.post_delay";
9398     char *value_1 = getHashEntry(setup_file_hash, token_1);
9399     char *value_2 = getHashEntry(setup_file_hash, token_2);
9400     char *value_3 = getHashEntry(setup_file_hash, token_3);
9401     char *value_4 = getHashEntry(setup_file_hash, token_4);
9402     char *value_5 = getHashEntry(setup_file_hash, token_5);
9403     char *value_6 = getHashEntry(setup_file_hash, token_6);
9404     char *value_7 = getHashEntry(setup_file_hash, token_7);
9405     char *value_8 = getHashEntry(setup_file_hash, token_8);
9406     char *value_9 = getHashEntry(setup_file_hash, token_9);
9407
9408     if (value_1 != NULL)
9409       menu.enter_screen[i].fade_mode = get_token_parameter_value(token_1,
9410                                                                  value_1);
9411     if (value_2 != NULL)
9412       menu.enter_screen[i].fade_delay = get_token_parameter_value(token_2,
9413                                                                   value_2);
9414     if (value_3 != NULL)
9415       menu.enter_screen[i].post_delay = get_token_parameter_value(token_3,
9416                                                                   value_3);
9417     if (value_4 != NULL)
9418       menu.leave_screen[i].fade_mode = get_token_parameter_value(token_4,
9419                                                                  value_4);
9420     if (value_5 != NULL)
9421       menu.leave_screen[i].fade_delay = get_token_parameter_value(token_5,
9422                                                                   value_5);
9423     if (value_6 != NULL)
9424       menu.leave_screen[i].post_delay = get_token_parameter_value(token_6,
9425                                                                   value_6);
9426     if (value_7 != NULL)
9427       menu.next_screen[i].fade_mode = get_token_parameter_value(token_7,
9428                                                                 value_7);
9429     if (value_8 != NULL)
9430       menu.next_screen[i].fade_delay = get_token_parameter_value(token_8,
9431                                                                  value_8);
9432     if (value_9 != NULL)
9433       menu.next_screen[i].post_delay = get_token_parameter_value(token_9,
9434                                                                  value_9);
9435   }
9436
9437   /* special case: initialize with default values that may be overwritten */
9438   /* (eg, init "viewport.door_1.MAIN.xyz" from "viewport.door_1.xyz") */
9439   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9440   {
9441     char *token_w1 = "viewport.window.width";
9442     char *token_w2 = "viewport.window.height";
9443     char *token_01 = "viewport.playfield.x";
9444     char *token_02 = "viewport.playfield.y";
9445     char *token_03 = "viewport.playfield.width";
9446     char *token_04 = "viewport.playfield.height";
9447     char *token_05 = "viewport.playfield.border_size";
9448     char *token_06 = "viewport.door_1.x";
9449     char *token_07 = "viewport.door_1.y";
9450     char *token_08 = "viewport.door_1.width";
9451     char *token_09 = "viewport.door_1.height";
9452     char *token_10 = "viewport.door_1.border_size";
9453     char *token_11 = "viewport.door_2.x";
9454     char *token_12 = "viewport.door_2.y";
9455     char *token_13 = "viewport.door_2.width";
9456     char *token_14 = "viewport.door_2.height";
9457     char *token_15 = "viewport.door_2.border_size";
9458     char *value_w1 = getHashEntry(setup_file_hash, token_w1);
9459     char *value_w2 = getHashEntry(setup_file_hash, token_w2);
9460     char *value_01 = getHashEntry(setup_file_hash, token_01);
9461     char *value_02 = getHashEntry(setup_file_hash, token_02);
9462     char *value_03 = getHashEntry(setup_file_hash, token_03);
9463     char *value_04 = getHashEntry(setup_file_hash, token_04);
9464     char *value_05 = getHashEntry(setup_file_hash, token_05);
9465     char *value_06 = getHashEntry(setup_file_hash, token_06);
9466     char *value_07 = getHashEntry(setup_file_hash, token_07);
9467     char *value_08 = getHashEntry(setup_file_hash, token_08);
9468     char *value_09 = getHashEntry(setup_file_hash, token_09);
9469     char *value_10 = getHashEntry(setup_file_hash, token_10);
9470     char *value_11 = getHashEntry(setup_file_hash, token_11);
9471     char *value_12 = getHashEntry(setup_file_hash, token_12);
9472     char *value_13 = getHashEntry(setup_file_hash, token_13);
9473     char *value_14 = getHashEntry(setup_file_hash, token_14);
9474     char *value_15 = getHashEntry(setup_file_hash, token_15);
9475
9476     if (value_w1 != NULL)
9477       viewport.window[i].width = get_token_parameter_value(token_w1, value_w1);
9478     if (value_w2 != NULL)
9479       viewport.window[i].height = get_token_parameter_value(token_w2, value_w2);
9480     if (value_01 != NULL)
9481       viewport.playfield[i].x = get_token_parameter_value(token_01, value_01);
9482     if (value_02 != NULL)
9483       viewport.playfield[i].y = get_token_parameter_value(token_02, value_02);
9484     if (value_03 != NULL)
9485       viewport.playfield[i].width = get_token_parameter_value(token_03,
9486                                                               value_03);
9487     if (value_04 != NULL)
9488       viewport.playfield[i].height = get_token_parameter_value(token_04,
9489                                                                value_04);
9490     if (value_05 != NULL)
9491       viewport.playfield[i].border_size = get_token_parameter_value(token_05,
9492                                                                     value_05);
9493     if (value_06 != NULL)
9494       viewport.door_1[i].x = get_token_parameter_value(token_06, value_06);
9495     if (value_07 != NULL)
9496       viewport.door_1[i].y = get_token_parameter_value(token_07, value_07);
9497     if (value_08 != NULL)
9498       viewport.door_1[i].width = get_token_parameter_value(token_08, value_08);
9499     if (value_09 != NULL)
9500       viewport.door_1[i].height = get_token_parameter_value(token_09, value_09);
9501     if (value_10 != NULL)
9502       viewport.door_1[i].border_size = get_token_parameter_value(token_10,
9503                                                                  value_10);
9504     if (value_11 != NULL)
9505       viewport.door_2[i].x = get_token_parameter_value(token_11, value_11);
9506     if (value_12 != NULL)
9507       viewport.door_2[i].y = get_token_parameter_value(token_12, value_12);
9508     if (value_13 != NULL)
9509       viewport.door_2[i].width = get_token_parameter_value(token_13, value_13);
9510     if (value_14 != NULL)
9511       viewport.door_2[i].height = get_token_parameter_value(token_14, value_14);
9512     if (value_15 != NULL)
9513       viewport.door_1[i].border_size = get_token_parameter_value(token_15,
9514                                                                  value_15);
9515   }
9516
9517   /* special case: initialize with default values that may be overwritten */
9518   /* (e.g., init "[title].fade_mode" from "menu.next_screen.TITLE.fade_mode") */
9519   for (i = 0; title_info[i].info != NULL; i++)
9520   {
9521     struct TitleFadingInfo *info = title_info[i].info;
9522     char *base_token = title_info[i].text;
9523
9524     for (j = 0; title_tokens[j].type != -1; j++)
9525     {
9526       char *token = getStringCat2(base_token, title_tokens[j].text);
9527       char *value = getHashEntry(setup_file_hash, token);
9528
9529       if (value != NULL)
9530       {
9531         int parameter_value = get_token_parameter_value(token, value);
9532
9533         tfi = *info;
9534
9535         *(int *)title_tokens[j].value = (int)parameter_value;
9536
9537         *info = tfi;
9538       }
9539
9540       free(token);
9541     }
9542   }
9543
9544   /* special case: initialize with default values that may be overwritten */
9545   /* (e.g., init "titlemessage_1.fade_mode" from "[titlemessage].fade_mode") */
9546   for (i = 0; titlemessage_arrays[i].array != NULL; i++)
9547   {
9548     struct TitleMessageInfo *array = titlemessage_arrays[i].array;
9549     char *base_token = titlemessage_arrays[i].text;
9550
9551     for (j = 0; titlemessage_tokens[j].type != -1; j++)
9552     {
9553       char *token = getStringCat2(base_token, titlemessage_tokens[j].text);
9554       char *value = getHashEntry(setup_file_hash, token);
9555
9556       if (value != NULL)
9557       {
9558         int parameter_value = get_token_parameter_value(token, value);
9559
9560         for (k = 0; k < MAX_NUM_TITLE_MESSAGES; k++)
9561         {
9562           tmi = array[k];
9563
9564           if (titlemessage_tokens[j].type == TYPE_INTEGER)
9565             *(int     *)titlemessage_tokens[j].value = (int)parameter_value;
9566           else
9567             *(boolean *)titlemessage_tokens[j].value = (boolean)parameter_value;
9568
9569           array[k] = tmi;
9570         }
9571       }
9572
9573       free(token);
9574     }
9575   }
9576
9577   /* read (and overwrite with) values that may be specified in config file */
9578   for (i = 0; image_config_vars[i].token != NULL; i++)
9579   {
9580     char *value = getHashEntry(setup_file_hash, image_config_vars[i].token);
9581
9582     /* (ignore definitions set to "[DEFAULT]" which are already initialized) */
9583     if (value != NULL && !strEqual(value, ARG_DEFAULT))
9584       *image_config_vars[i].value =
9585         get_token_parameter_value(image_config_vars[i].token, value);
9586   }
9587
9588   freeSetupFileHash(setup_file_hash);
9589 }
9590
9591 void LoadMenuDesignSettings()
9592 {
9593   char *filename_base = UNDEFINED_FILENAME, *filename_local;
9594
9595   InitMenuDesignSettings_Static();
9596   InitMenuDesignSettings_SpecialPreProcessing();
9597
9598   if (!GFX_OVERRIDE_ARTWORK(ARTWORK_TYPE_GRAPHICS))
9599   {
9600     /* first look for special settings configured in level series config */
9601     filename_base = getCustomArtworkLevelConfigFilename(ARTWORK_TYPE_GRAPHICS);
9602
9603     if (fileExists(filename_base))
9604       LoadMenuDesignSettingsFromFilename(filename_base);
9605   }
9606
9607   filename_local = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
9608
9609   if (filename_local != NULL && !strEqual(filename_base, filename_local))
9610     LoadMenuDesignSettingsFromFilename(filename_local);
9611
9612   InitMenuDesignSettings_SpecialPostProcessing();
9613 }
9614
9615 void LoadMenuDesignSettings_AfterGraphics()
9616 {
9617   InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics();
9618 }
9619
9620 void LoadUserDefinedEditorElementList(int **elements, int *num_elements)
9621 {
9622   char *filename = getEditorSetupFilename();
9623   SetupFileList *setup_file_list, *list;
9624   SetupFileHash *element_hash;
9625   int num_unknown_tokens = 0;
9626   int i;
9627
9628   if ((setup_file_list = loadSetupFileList(filename)) == NULL)
9629     return;
9630
9631   element_hash = newSetupFileHash();
9632
9633   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
9634     setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
9635
9636   /* determined size may be larger than needed (due to unknown elements) */
9637   *num_elements = 0;
9638   for (list = setup_file_list; list != NULL; list = list->next)
9639     (*num_elements)++;
9640
9641   /* add space for up to 3 more elements for padding that may be needed */
9642   *num_elements += 3;
9643
9644   /* free memory for old list of elements, if needed */
9645   checked_free(*elements);
9646
9647   /* allocate memory for new list of elements */
9648   *elements = checked_malloc(*num_elements * sizeof(int));
9649
9650   *num_elements = 0;
9651   for (list = setup_file_list; list != NULL; list = list->next)
9652   {
9653     char *value = getHashEntry(element_hash, list->token);
9654
9655     if (value == NULL)          /* try to find obsolete token mapping */
9656     {
9657       char *mapped_token = get_mapped_token(list->token);
9658
9659       if (mapped_token != NULL)
9660       {
9661         value = getHashEntry(element_hash, mapped_token);
9662
9663         free(mapped_token);
9664       }
9665     }
9666
9667     if (value != NULL)
9668     {
9669       (*elements)[(*num_elements)++] = atoi(value);
9670     }
9671     else
9672     {
9673       if (num_unknown_tokens == 0)
9674       {
9675         Error(ERR_INFO_LINE, "-");
9676         Error(ERR_INFO, "warning: unknown token(s) found in config file:");
9677         Error(ERR_INFO, "- config file: '%s'", filename);
9678
9679         num_unknown_tokens++;
9680       }
9681
9682       Error(ERR_INFO, "- token: '%s'", list->token);
9683     }
9684   }
9685
9686   if (num_unknown_tokens > 0)
9687     Error(ERR_INFO_LINE, "-");
9688
9689   while (*num_elements % 4)     /* pad with empty elements, if needed */
9690     (*elements)[(*num_elements)++] = EL_EMPTY;
9691
9692   freeSetupFileList(setup_file_list);
9693   freeSetupFileHash(element_hash);
9694
9695 #if 0
9696   for (i = 0; i < *num_elements; i++)
9697     printf("editor: element '%s' [%d]\n",
9698            element_info[(*elements)[i]].token_name, (*elements)[i]);
9699 #endif
9700 }
9701
9702 static struct MusicFileInfo *get_music_file_info_ext(char *basename, int music,
9703                                                      boolean is_sound)
9704 {
9705   SetupFileHash *setup_file_hash = NULL;
9706   struct MusicFileInfo tmp_music_file_info, *new_music_file_info;
9707   char *filename_music, *filename_prefix, *filename_info;
9708   struct
9709   {
9710     char *token;
9711     char **value_ptr;
9712   }
9713   token_to_value_ptr[] =
9714   {
9715     { "title_header",   &tmp_music_file_info.title_header       },
9716     { "artist_header",  &tmp_music_file_info.artist_header      },
9717     { "album_header",   &tmp_music_file_info.album_header       },
9718     { "year_header",    &tmp_music_file_info.year_header        },
9719
9720     { "title",          &tmp_music_file_info.title              },
9721     { "artist",         &tmp_music_file_info.artist             },
9722     { "album",          &tmp_music_file_info.album              },
9723     { "year",           &tmp_music_file_info.year               },
9724
9725     { NULL,             NULL                                    },
9726   };
9727   int i;
9728
9729   filename_music = (is_sound ? getCustomSoundFilename(basename) :
9730                     getCustomMusicFilename(basename));
9731
9732   if (filename_music == NULL)
9733     return NULL;
9734
9735   /* ---------- try to replace file extension ---------- */
9736
9737   filename_prefix = getStringCopy(filename_music);
9738   if (strrchr(filename_prefix, '.') != NULL)
9739     *strrchr(filename_prefix, '.') = '\0';
9740   filename_info = getStringCat2(filename_prefix, ".txt");
9741
9742   if (fileExists(filename_info))
9743     setup_file_hash = loadSetupFileHash(filename_info);
9744
9745   free(filename_prefix);
9746   free(filename_info);
9747
9748   if (setup_file_hash == NULL)
9749   {
9750     /* ---------- try to add file extension ---------- */
9751
9752     filename_prefix = getStringCopy(filename_music);
9753     filename_info = getStringCat2(filename_prefix, ".txt");
9754
9755     if (fileExists(filename_info))
9756       setup_file_hash = loadSetupFileHash(filename_info);
9757
9758     free(filename_prefix);
9759     free(filename_info);
9760   }
9761
9762   if (setup_file_hash == NULL)
9763     return NULL;
9764
9765   /* ---------- music file info found ---------- */
9766
9767   clear_mem(&tmp_music_file_info, sizeof(struct MusicFileInfo));
9768
9769   for (i = 0; token_to_value_ptr[i].token != NULL; i++)
9770   {
9771     char *value = getHashEntry(setup_file_hash, token_to_value_ptr[i].token);
9772
9773     *token_to_value_ptr[i].value_ptr =
9774       getStringCopy(value != NULL && *value != '\0' ? value : UNKNOWN_NAME);
9775   }
9776
9777   tmp_music_file_info.basename = getStringCopy(basename);
9778   tmp_music_file_info.music = music;
9779   tmp_music_file_info.is_sound = is_sound;
9780
9781   new_music_file_info = checked_malloc(sizeof(struct MusicFileInfo));
9782   *new_music_file_info = tmp_music_file_info;
9783
9784   return new_music_file_info;
9785 }
9786
9787 static struct MusicFileInfo *get_music_file_info(char *basename, int music)
9788 {
9789   return get_music_file_info_ext(basename, music, FALSE);
9790 }
9791
9792 static struct MusicFileInfo *get_sound_file_info(char *basename, int sound)
9793 {
9794   return get_music_file_info_ext(basename, sound, TRUE);
9795 }
9796
9797 static boolean music_info_listed_ext(struct MusicFileInfo *list,
9798                                      char *basename, boolean is_sound)
9799 {
9800   for (; list != NULL; list = list->next)
9801     if (list->is_sound == is_sound && strEqual(list->basename, basename))
9802       return TRUE;
9803
9804   return FALSE;
9805 }
9806
9807 static boolean music_info_listed(struct MusicFileInfo *list, char *basename)
9808 {
9809   return music_info_listed_ext(list, basename, FALSE);
9810 }
9811
9812 static boolean sound_info_listed(struct MusicFileInfo *list, char *basename)
9813 {
9814   return music_info_listed_ext(list, basename, TRUE);
9815 }
9816
9817 void LoadMusicInfo()
9818 {
9819   char *music_directory = getCustomMusicDirectory();
9820   int num_music = getMusicListSize();
9821   int num_music_noconf = 0;
9822   int num_sounds = getSoundListSize();
9823   Directory *dir;
9824   DirectoryEntry *dir_entry;
9825   struct FileInfo *music, *sound;
9826   struct MusicFileInfo *next, **new;
9827   int i;
9828
9829   while (music_file_info != NULL)
9830   {
9831     next = music_file_info->next;
9832
9833     checked_free(music_file_info->basename);
9834
9835     checked_free(music_file_info->title_header);
9836     checked_free(music_file_info->artist_header);
9837     checked_free(music_file_info->album_header);
9838     checked_free(music_file_info->year_header);
9839
9840     checked_free(music_file_info->title);
9841     checked_free(music_file_info->artist);
9842     checked_free(music_file_info->album);
9843     checked_free(music_file_info->year);
9844
9845     free(music_file_info);
9846
9847     music_file_info = next;
9848   }
9849
9850   new = &music_file_info;
9851
9852   for (i = 0; i < num_music; i++)
9853   {
9854     music = getMusicListEntry(i);
9855
9856     if (music->filename == NULL)
9857       continue;
9858
9859     if (strEqual(music->filename, UNDEFINED_FILENAME))
9860       continue;
9861
9862     /* a configured file may be not recognized as music */
9863     if (!FileIsMusic(music->filename))
9864       continue;
9865
9866     if (!music_info_listed(music_file_info, music->filename))
9867     {
9868       *new = get_music_file_info(music->filename, i);
9869
9870       if (*new != NULL)
9871         new = &(*new)->next;
9872     }
9873   }
9874
9875   if ((dir = openDirectory(music_directory)) == NULL)
9876   {
9877     Error(ERR_WARN, "cannot read music directory '%s'", music_directory);
9878     return;
9879   }
9880
9881   while ((dir_entry = readDirectory(dir)) != NULL)      /* loop all entries */
9882   {
9883     char *basename = dir_entry->basename;
9884     boolean music_already_used = FALSE;
9885     int i;
9886
9887     /* skip all music files that are configured in music config file */
9888     for (i = 0; i < num_music; i++)
9889     {
9890       music = getMusicListEntry(i);
9891
9892       if (music->filename == NULL)
9893         continue;
9894
9895       if (strEqual(basename, music->filename))
9896       {
9897         music_already_used = TRUE;
9898         break;
9899       }
9900     }
9901
9902     if (music_already_used)
9903       continue;
9904
9905     if (!FileIsMusic(dir_entry->filename))
9906       continue;
9907
9908     if (!music_info_listed(music_file_info, basename))
9909     {
9910       *new = get_music_file_info(basename, MAP_NOCONF_MUSIC(num_music_noconf));
9911
9912       if (*new != NULL)
9913         new = &(*new)->next;
9914     }
9915
9916     num_music_noconf++;
9917   }
9918
9919   closeDirectory(dir);
9920
9921   for (i = 0; i < num_sounds; i++)
9922   {
9923     sound = getSoundListEntry(i);
9924
9925     if (sound->filename == NULL)
9926       continue;
9927
9928     if (strEqual(sound->filename, UNDEFINED_FILENAME))
9929       continue;
9930
9931     /* a configured file may be not recognized as sound */
9932     if (!FileIsSound(sound->filename))
9933       continue;
9934
9935     if (!sound_info_listed(music_file_info, sound->filename))
9936     {
9937       *new = get_sound_file_info(sound->filename, i);
9938       if (*new != NULL)
9939         new = &(*new)->next;
9940     }
9941   }
9942 }
9943
9944 void add_helpanim_entry(int element, int action, int direction, int delay,
9945                         int *num_list_entries)
9946 {
9947   struct HelpAnimInfo *new_list_entry;
9948   (*num_list_entries)++;
9949
9950   helpanim_info =
9951     checked_realloc(helpanim_info,
9952                     *num_list_entries * sizeof(struct HelpAnimInfo));
9953   new_list_entry = &helpanim_info[*num_list_entries - 1];
9954
9955   new_list_entry->element = element;
9956   new_list_entry->action = action;
9957   new_list_entry->direction = direction;
9958   new_list_entry->delay = delay;
9959 }
9960
9961 void print_unknown_token(char *filename, char *token, int token_nr)
9962 {
9963   if (token_nr == 0)
9964   {
9965     Error(ERR_INFO_LINE, "-");
9966     Error(ERR_INFO, "warning: unknown token(s) found in config file:");
9967     Error(ERR_INFO, "- config file: '%s'", filename);
9968   }
9969
9970   Error(ERR_INFO, "- token: '%s'", token);
9971 }
9972
9973 void print_unknown_token_end(int token_nr)
9974 {
9975   if (token_nr > 0)
9976     Error(ERR_INFO_LINE, "-");
9977 }
9978
9979 void LoadHelpAnimInfo()
9980 {
9981   char *filename = getHelpAnimFilename();
9982   SetupFileList *setup_file_list = NULL, *list;
9983   SetupFileHash *element_hash, *action_hash, *direction_hash;
9984   int num_list_entries = 0;
9985   int num_unknown_tokens = 0;
9986   int i;
9987
9988   if (fileExists(filename))
9989     setup_file_list = loadSetupFileList(filename);
9990
9991   if (setup_file_list == NULL)
9992   {
9993     /* use reliable default values from static configuration */
9994     SetupFileList *insert_ptr;
9995
9996     insert_ptr = setup_file_list =
9997       newSetupFileList(helpanim_config[0].token,
9998                        helpanim_config[0].value);
9999
10000     for (i = 1; helpanim_config[i].token; i++)
10001       insert_ptr = addListEntry(insert_ptr,
10002                                 helpanim_config[i].token,
10003                                 helpanim_config[i].value);
10004   }
10005
10006   element_hash   = newSetupFileHash();
10007   action_hash    = newSetupFileHash();
10008   direction_hash = newSetupFileHash();
10009
10010   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
10011     setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
10012
10013   for (i = 0; i < NUM_ACTIONS; i++)
10014     setHashEntry(action_hash, element_action_info[i].suffix,
10015                  i_to_a(element_action_info[i].value));
10016
10017   /* do not store direction index (bit) here, but direction value! */
10018   for (i = 0; i < NUM_DIRECTIONS_FULL; i++)
10019     setHashEntry(direction_hash, element_direction_info[i].suffix,
10020                  i_to_a(1 << element_direction_info[i].value));
10021
10022   for (list = setup_file_list; list != NULL; list = list->next)
10023   {
10024     char *element_token, *action_token, *direction_token;
10025     char *element_value, *action_value, *direction_value;
10026     int delay = atoi(list->value);
10027
10028     if (strEqual(list->token, "end"))
10029     {
10030       add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
10031
10032       continue;
10033     }
10034
10035     /* first try to break element into element/action/direction parts;
10036        if this does not work, also accept combined "element[.act][.dir]"
10037        elements (like "dynamite.active"), which are unique elements */
10038
10039     if (strchr(list->token, '.') == NULL)       /* token contains no '.' */
10040     {
10041       element_value = getHashEntry(element_hash, list->token);
10042       if (element_value != NULL)        /* element found */
10043         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10044                            &num_list_entries);
10045       else
10046       {
10047         /* no further suffixes found -- this is not an element */
10048         print_unknown_token(filename, list->token, num_unknown_tokens++);
10049       }
10050
10051       continue;
10052     }
10053
10054     /* token has format "<prefix>.<something>" */
10055
10056     action_token = strchr(list->token, '.');    /* suffix may be action ... */
10057     direction_token = action_token;             /* ... or direction */
10058
10059     element_token = getStringCopy(list->token);
10060     *strchr(element_token, '.') = '\0';
10061
10062     element_value = getHashEntry(element_hash, element_token);
10063
10064     if (element_value == NULL)          /* this is no element */
10065     {
10066       element_value = getHashEntry(element_hash, list->token);
10067       if (element_value != NULL)        /* combined element found */
10068         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10069                            &num_list_entries);
10070       else
10071         print_unknown_token(filename, list->token, num_unknown_tokens++);
10072
10073       free(element_token);
10074
10075       continue;
10076     }
10077
10078     action_value = getHashEntry(action_hash, action_token);
10079
10080     if (action_value != NULL)           /* action found */
10081     {
10082       add_helpanim_entry(atoi(element_value), atoi(action_value), -1, delay,
10083                     &num_list_entries);
10084
10085       free(element_token);
10086
10087       continue;
10088     }
10089
10090     direction_value = getHashEntry(direction_hash, direction_token);
10091
10092     if (direction_value != NULL)        /* direction found */
10093     {
10094       add_helpanim_entry(atoi(element_value), -1, atoi(direction_value), delay,
10095                          &num_list_entries);
10096
10097       free(element_token);
10098
10099       continue;
10100     }
10101
10102     if (strchr(action_token + 1, '.') == NULL)
10103     {
10104       /* no further suffixes found -- this is not an action nor direction */
10105
10106       element_value = getHashEntry(element_hash, list->token);
10107       if (element_value != NULL)        /* combined element found */
10108         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10109                            &num_list_entries);
10110       else
10111         print_unknown_token(filename, list->token, num_unknown_tokens++);
10112
10113       free(element_token);
10114
10115       continue;
10116     }
10117
10118     /* token has format "<prefix>.<suffix>.<something>" */
10119
10120     direction_token = strchr(action_token + 1, '.');
10121
10122     action_token = getStringCopy(action_token);
10123     *strchr(action_token + 1, '.') = '\0';
10124
10125     action_value = getHashEntry(action_hash, action_token);
10126
10127     if (action_value == NULL)           /* this is no action */
10128     {
10129       element_value = getHashEntry(element_hash, list->token);
10130       if (element_value != NULL)        /* combined element found */
10131         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10132                            &num_list_entries);
10133       else
10134         print_unknown_token(filename, list->token, num_unknown_tokens++);
10135
10136       free(element_token);
10137       free(action_token);
10138
10139       continue;
10140     }
10141
10142     direction_value = getHashEntry(direction_hash, direction_token);
10143
10144     if (direction_value != NULL)        /* direction found */
10145     {
10146       add_helpanim_entry(atoi(element_value), atoi(action_value),
10147                          atoi(direction_value), delay, &num_list_entries);
10148
10149       free(element_token);
10150       free(action_token);
10151
10152       continue;
10153     }
10154
10155     /* this is no direction */
10156
10157     element_value = getHashEntry(element_hash, list->token);
10158     if (element_value != NULL)          /* combined element found */
10159       add_helpanim_entry(atoi(element_value), -1, -1, delay,
10160                          &num_list_entries);
10161     else
10162       print_unknown_token(filename, list->token, num_unknown_tokens++);
10163
10164     free(element_token);
10165     free(action_token);
10166   }
10167
10168   print_unknown_token_end(num_unknown_tokens);
10169
10170   add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
10171   add_helpanim_entry(HELPANIM_LIST_END,  -1, -1, -1, &num_list_entries);
10172
10173   freeSetupFileList(setup_file_list);
10174   freeSetupFileHash(element_hash);
10175   freeSetupFileHash(action_hash);
10176   freeSetupFileHash(direction_hash);
10177
10178 #if 0
10179   for (i = 0; i < num_list_entries; i++)
10180     printf("::: '%s': %d, %d, %d => %d\n",
10181            EL_NAME(helpanim_info[i].element),
10182            helpanim_info[i].element,
10183            helpanim_info[i].action,
10184            helpanim_info[i].direction,
10185            helpanim_info[i].delay);
10186 #endif
10187 }
10188
10189 void LoadHelpTextInfo()
10190 {
10191   char *filename = getHelpTextFilename();
10192   int i;
10193
10194   if (helptext_info != NULL)
10195   {
10196     freeSetupFileHash(helptext_info);
10197     helptext_info = NULL;
10198   }
10199
10200   if (fileExists(filename))
10201     helptext_info = loadSetupFileHash(filename);
10202
10203   if (helptext_info == NULL)
10204   {
10205     /* use reliable default values from static configuration */
10206     helptext_info = newSetupFileHash();
10207
10208     for (i = 0; helptext_config[i].token; i++)
10209       setHashEntry(helptext_info,
10210                    helptext_config[i].token,
10211                    helptext_config[i].value);
10212   }
10213
10214 #if 0
10215   BEGIN_HASH_ITERATION(helptext_info, itr)
10216   {
10217     printf("::: '%s' => '%s'\n",
10218            HASH_ITERATION_TOKEN(itr), HASH_ITERATION_VALUE(itr));
10219   }
10220   END_HASH_ITERATION(hash, itr)
10221 #endif
10222 }
10223
10224
10225 /* ------------------------------------------------------------------------- */
10226 /* convert levels                                                            */
10227 /* ------------------------------------------------------------------------- */
10228
10229 #define MAX_NUM_CONVERT_LEVELS          1000
10230
10231 void ConvertLevels()
10232 {
10233   static LevelDirTree *convert_leveldir = NULL;
10234   static int convert_level_nr = -1;
10235   static int num_levels_handled = 0;
10236   static int num_levels_converted = 0;
10237   static boolean levels_failed[MAX_NUM_CONVERT_LEVELS];
10238   int i;
10239
10240   convert_leveldir = getTreeInfoFromIdentifier(leveldir_first,
10241                                                global.convert_leveldir);
10242
10243   if (convert_leveldir == NULL)
10244     Error(ERR_EXIT, "no such level identifier: '%s'",
10245           global.convert_leveldir);
10246
10247   leveldir_current = convert_leveldir;
10248
10249   if (global.convert_level_nr != -1)
10250   {
10251     convert_leveldir->first_level = global.convert_level_nr;
10252     convert_leveldir->last_level  = global.convert_level_nr;
10253   }
10254
10255   convert_level_nr = convert_leveldir->first_level;
10256
10257   PrintLine("=", 79);
10258   Print("Converting levels\n");
10259   PrintLine("-", 79);
10260   Print("Level series identifier: '%s'\n", convert_leveldir->identifier);
10261   Print("Level series name:       '%s'\n", convert_leveldir->name);
10262   Print("Level series author:     '%s'\n", convert_leveldir->author);
10263   Print("Number of levels:        %d\n",   convert_leveldir->levels);
10264   PrintLine("=", 79);
10265   Print("\n");
10266
10267   for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
10268     levels_failed[i] = FALSE;
10269
10270   while (convert_level_nr <= convert_leveldir->last_level)
10271   {
10272     char *level_filename;
10273     boolean new_level;
10274
10275     level_nr = convert_level_nr++;
10276
10277     Print("Level %03d: ", level_nr);
10278
10279     LoadLevel(level_nr);
10280     if (level.no_level_file || level.no_valid_file)
10281     {
10282       Print("(no level)\n");
10283       continue;
10284     }
10285
10286     Print("converting level ... ");
10287
10288     level_filename = getDefaultLevelFilename(level_nr);
10289     new_level = !fileExists(level_filename);
10290
10291     if (new_level)
10292     {
10293       SaveLevel(level_nr);
10294
10295       num_levels_converted++;
10296
10297       Print("converted.\n");
10298     }
10299     else
10300     {
10301       if (level_nr >= 0 && level_nr < MAX_NUM_CONVERT_LEVELS)
10302         levels_failed[level_nr] = TRUE;
10303
10304       Print("NOT CONVERTED -- LEVEL ALREADY EXISTS.\n");
10305     }
10306
10307     num_levels_handled++;
10308   }
10309
10310   Print("\n");
10311   PrintLine("=", 79);
10312   Print("Number of levels handled: %d\n", num_levels_handled);
10313   Print("Number of levels converted: %d (%d%%)\n", num_levels_converted,
10314          (num_levels_handled ?
10315           num_levels_converted * 100 / num_levels_handled : 0));
10316   PrintLine("-", 79);
10317   Print("Summary (for automatic parsing by scripts):\n");
10318   Print("LEVELDIR '%s', CONVERTED %d/%d (%d%%)",
10319          convert_leveldir->identifier, num_levels_converted,
10320          num_levels_handled,
10321          (num_levels_handled ?
10322           num_levels_converted * 100 / num_levels_handled : 0));
10323
10324   if (num_levels_handled != num_levels_converted)
10325   {
10326     Print(", FAILED:");
10327     for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
10328       if (levels_failed[i])
10329         Print(" %03d", i);
10330   }
10331
10332   Print("\n");
10333   PrintLine("=", 79);
10334
10335   CloseAllAndExit(0);
10336 }
10337
10338
10339 /* ------------------------------------------------------------------------- */
10340 /* create and save images for use in level sketches (raw BMP format)         */
10341 /* ------------------------------------------------------------------------- */
10342
10343 void CreateLevelSketchImages()
10344 {
10345 #if defined(TARGET_SDL)
10346   Bitmap *bitmap1;
10347   Bitmap *bitmap2;
10348   int i;
10349
10350   InitElementPropertiesGfxElement();
10351
10352   bitmap1 = CreateBitmap(TILEX, TILEY, DEFAULT_DEPTH);
10353   bitmap2 = CreateBitmap(MINI_TILEX, MINI_TILEY, DEFAULT_DEPTH);
10354
10355   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
10356   {
10357     Bitmap *src_bitmap;
10358     int src_x, src_y;
10359     int element = getMappedElement(i);
10360     int graphic = el2edimg(element);
10361     char basename1[16];
10362     char basename2[16];
10363     char *filename1;
10364     char *filename2;
10365
10366     sprintf(basename1, "%03d.bmp", i);
10367     sprintf(basename2, "%03ds.bmp", i);
10368
10369     filename1 = getPath2(global.create_images_dir, basename1);
10370     filename2 = getPath2(global.create_images_dir, basename2);
10371
10372     getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
10373     BlitBitmap(src_bitmap, bitmap1, src_x, src_y, TILEX, TILEY,
10374                0, 0);
10375
10376     if (SDL_SaveBMP(bitmap1->surface, filename1) != 0)
10377       Error(ERR_EXIT, "cannot save level sketch image file '%s'", filename1);
10378
10379     getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
10380     BlitBitmap(src_bitmap, bitmap2, src_x, src_y, MINI_TILEX, MINI_TILEY, 0, 0);
10381
10382     if (SDL_SaveBMP(bitmap2->surface, filename2) != 0)
10383       Error(ERR_EXIT, "cannot save level sketch image file '%s'", filename2);
10384
10385     free(filename1);
10386     free(filename2);
10387
10388     if (options.debug)
10389       printf("%03d `%03d%c", i, i, (i % 10 < 9 ? ' ' : '\n'));
10390   }
10391
10392   FreeBitmap(bitmap1);
10393   FreeBitmap(bitmap2);
10394
10395   if (options.debug)
10396     printf("\n");
10397
10398   Error(ERR_INFO, "%d normal and small images created", NUM_FILE_ELEMENTS);
10399
10400   CloseAllAndExit(0);
10401 #endif
10402 }
10403
10404
10405 /* ------------------------------------------------------------------------- */
10406 /* create and save images for custom and group elements (raw BMP format)     */
10407 /* ------------------------------------------------------------------------- */
10408
10409 void CreateCustomElementImages(char *directory)
10410 {
10411 #if defined(TARGET_SDL)
10412   char *src_basename = "RocksCE-template.ilbm";
10413   char *dst_basename = "RocksCE.bmp";
10414   char *src_filename = getPath2(directory, src_basename);
10415   char *dst_filename = getPath2(directory, dst_basename);
10416   Bitmap *src_bitmap;
10417   Bitmap *bitmap;
10418   int yoffset_ce = 0;
10419   int yoffset_ge = (TILEY * NUM_CUSTOM_ELEMENTS / 16);
10420   int i;
10421
10422   SDLInitVideoDisplay();
10423
10424   ReCreateBitmap(&backbuffer, video.width, video.height);
10425
10426   src_bitmap = LoadImage(src_filename);
10427
10428   bitmap = CreateBitmap(TILEX * 16 * 2,
10429                         TILEY * (NUM_CUSTOM_ELEMENTS + NUM_GROUP_ELEMENTS) / 16,
10430                         DEFAULT_DEPTH);
10431
10432   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10433   {
10434     int x = i % 16;
10435     int y = i / 16;
10436     int ii = i + 1;
10437     int j;
10438
10439     BlitBitmap(src_bitmap, bitmap, 0, 0, TILEX, TILEY,
10440                TILEX * x, TILEY * y + yoffset_ce);
10441
10442     BlitBitmap(src_bitmap, bitmap, 0, TILEY,
10443                TILEX, TILEY,
10444                TILEX * x + TILEX * 16,
10445                TILEY * y + yoffset_ce);
10446
10447     for (j = 2; j >= 0; j--)
10448     {
10449       int c = ii % 10;
10450
10451       BlitBitmap(src_bitmap, bitmap,
10452                  TILEX + c * 7, 0, 6, 10,
10453                  TILEX * x + 6 + j * 7,
10454                  TILEY * y + 11 + yoffset_ce);
10455
10456       BlitBitmap(src_bitmap, bitmap,
10457                  TILEX + c * 8, TILEY, 6, 10,
10458                  TILEX * 16 + TILEX * x + 6 + j * 8,
10459                  TILEY * y + 10 + yoffset_ce);
10460
10461       ii /= 10;
10462     }
10463   }
10464
10465   for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
10466   {
10467     int x = i % 16;
10468     int y = i / 16;
10469     int ii = i + 1;
10470     int j;
10471
10472     BlitBitmap(src_bitmap, bitmap, 0, 0, TILEX, TILEY,
10473                TILEX * x, TILEY * y + yoffset_ge);
10474
10475     BlitBitmap(src_bitmap, bitmap, 0, TILEY,
10476                TILEX, TILEY,
10477                TILEX * x + TILEX * 16,
10478                TILEY * y + yoffset_ge);
10479
10480     for (j = 1; j >= 0; j--)
10481     {
10482       int c = ii % 10;
10483
10484       BlitBitmap(src_bitmap, bitmap, TILEX + c * 10, 11, 10, 10,
10485                  TILEX * x + 6 + j * 10,
10486                  TILEY * y + 11 + yoffset_ge);
10487
10488       BlitBitmap(src_bitmap, bitmap,
10489                  TILEX + c * 8, TILEY + 12, 6, 10,
10490                  TILEX * 16 + TILEX * x + 10 + j * 8,
10491                  TILEY * y + 10 + yoffset_ge);
10492
10493       ii /= 10;
10494     }
10495   }
10496
10497   if (SDL_SaveBMP(bitmap->surface, dst_filename) != 0)
10498     Error(ERR_EXIT, "cannot save CE graphics file '%s'", dst_filename);
10499
10500   FreeBitmap(bitmap);
10501
10502   CloseAllAndExit(0);
10503 #endif
10504 }