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   for (i = 0; i < tape.length; i++)
3779   {
3780     int demo_action = map_key_RND_to_SP(tape.pos[i].action[0]);
3781     int demo_repeat = tape.pos[i].delay;
3782     int demo_entries = (demo_repeat + 15) / 16;
3783
3784     if (demo->length + demo_entries >= SP_MAX_TAPE_LEN)
3785     {
3786       Error(ERR_WARN, "tape truncated: size exceeds maximum SP demo size %d",
3787             SP_MAX_TAPE_LEN);
3788
3789       break;
3790     }
3791
3792     for (j = 0; j < demo_repeat / 16; j++)
3793       demo->data[demo->length++] = 0xf0 | demo_action;
3794
3795     if (demo_repeat % 16)
3796       demo->data[demo->length++] = ((demo_repeat % 16 - 1) << 4) | demo_action;
3797   }
3798
3799   demo->is_available = TRUE;
3800 }
3801
3802 static void setTapeInfoToDefaults();
3803
3804 static void CopyNativeTape_SP_to_RND(struct LevelInfo *level)
3805 {
3806   struct LevelInfo_SP *level_sp = level->native_sp_level;
3807   struct DemoInfo_SP *demo = &level_sp->demo;
3808   char *filename = level->file_info.filename;
3809   int i;
3810
3811   /* always start with reliable default values */
3812   setTapeInfoToDefaults();
3813
3814   if (!demo->is_available)
3815     return;
3816
3817   tape.level_nr = demo->level_nr;       /* (currently not used) */
3818   tape.length = MIN(demo->length, MAX_TAPE_LEN);
3819   tape.random_seed = level_sp->header.DemoRandomSeed;
3820
3821   TapeSetDateFromEpochSeconds(getFileTimestampEpochSeconds(filename));
3822
3823   if (tape.length < demo->length)
3824     Error(ERR_WARN, "SP demo truncated: size %d exceeds maximum tape size %d",
3825           demo->length, MAX_TAPE_LEN);
3826
3827   for (i = 0; i < tape.length; i++)
3828   {
3829     int demo_action = demo->data[i] & 0x0f;
3830     int demo_repeat = (demo->data[i] & 0xf0) >> 4;
3831
3832     tape.pos[i].action[0] = map_key_SP_to_RND(demo_action);
3833     tape.pos[i].delay = demo_repeat + 1;
3834   }
3835
3836   tape.length_frames  = GetTapeLengthFrames();
3837   tape.length_seconds = GetTapeLengthSeconds();
3838 }
3839
3840
3841 /* ------------------------------------------------------------------------- */
3842 /* functions for loading DC level                                            */
3843 /* ------------------------------------------------------------------------- */
3844
3845 #define DC_LEVEL_HEADER_SIZE            344
3846
3847 unsigned short getDecodedWord_DC(unsigned short data_encoded, boolean init)
3848 {
3849   static int last_data_encoded;
3850   static int offset1;
3851   static int offset2;
3852   int diff;
3853   int diff_hi, diff_lo;
3854   int data_hi, data_lo;
3855   unsigned short data_decoded;
3856
3857   if (init)
3858   {
3859     last_data_encoded = 0;
3860     offset1 = -1;
3861     offset2 = 0;
3862
3863     return 0;
3864   }
3865
3866   diff = data_encoded - last_data_encoded;
3867   diff_hi = diff & ~0xff;
3868   diff_lo = diff &  0xff;
3869
3870   offset2 += diff_lo;
3871
3872   data_hi = diff_hi - (offset1 << 8) + (offset2 & 0xff00);
3873   data_lo = (diff_lo + (data_hi >> 16)) & 0x00ff;
3874   data_hi = data_hi & 0xff00;
3875
3876   data_decoded = data_hi | data_lo;
3877
3878   last_data_encoded = data_encoded;
3879
3880   offset1 = (offset1 + 1) % 31;
3881   offset2 = offset2 & 0xff;
3882
3883   return data_decoded;
3884 }
3885
3886 int getMappedElement_DC(int element)
3887 {
3888   switch (element)
3889   {
3890     case 0x0000:
3891       element = EL_ROCK;
3892       break;
3893
3894       /* 0x0117 - 0x036e: (?) */
3895       /* EL_DIAMOND */
3896
3897       /* 0x042d - 0x0684: (?) */
3898       /* EL_EMERALD */
3899
3900     case 0x06f1:
3901       element = EL_NUT;
3902       break;
3903
3904     case 0x074c:
3905       element = EL_BOMB;
3906       break;
3907
3908     case 0x07a4:
3909       element = EL_PEARL;
3910       break;
3911
3912     case 0x0823:
3913       element = EL_CRYSTAL;
3914       break;
3915
3916     case 0x0e77:        /* quicksand (boulder) */
3917       element = EL_QUICKSAND_FAST_FULL;
3918       break;
3919
3920     case 0x0e99:        /* slow quicksand (boulder) */
3921       element = EL_QUICKSAND_FULL;
3922       break;
3923
3924     case 0x0ed2:
3925       element = EL_EM_EXIT_OPEN;
3926       break;
3927
3928     case 0x0ee3:
3929       element = EL_EM_EXIT_CLOSED;
3930       break;
3931
3932     case 0x0eeb:
3933       element = EL_EM_STEEL_EXIT_OPEN;
3934       break;
3935
3936     case 0x0efc:
3937       element = EL_EM_STEEL_EXIT_CLOSED;
3938       break;
3939
3940     case 0x0f4f:        /* dynamite (lit 1) */
3941       element = EL_EM_DYNAMITE_ACTIVE;
3942       break;
3943
3944     case 0x0f57:        /* dynamite (lit 2) */
3945       element = EL_EM_DYNAMITE_ACTIVE;
3946       break;
3947
3948     case 0x0f5f:        /* dynamite (lit 3) */
3949       element = EL_EM_DYNAMITE_ACTIVE;
3950       break;
3951
3952     case 0x0f67:        /* dynamite (lit 4) */
3953       element = EL_EM_DYNAMITE_ACTIVE;
3954       break;
3955
3956     case 0x0f81:
3957     case 0x0f82:
3958     case 0x0f83:
3959     case 0x0f84:
3960       element = EL_AMOEBA_WET;
3961       break;
3962
3963     case 0x0f85:
3964       element = EL_AMOEBA_DROP;
3965       break;
3966
3967     case 0x0fb9:
3968       element = EL_DC_MAGIC_WALL;
3969       break;
3970
3971     case 0x0fd0:
3972       element = EL_SPACESHIP_UP;
3973       break;
3974
3975     case 0x0fd9:
3976       element = EL_SPACESHIP_DOWN;
3977       break;
3978
3979     case 0x0ff1:
3980       element = EL_SPACESHIP_LEFT;
3981       break;
3982
3983     case 0x0ff9:
3984       element = EL_SPACESHIP_RIGHT;
3985       break;
3986
3987     case 0x1057:
3988       element = EL_BUG_UP;
3989       break;
3990
3991     case 0x1060:
3992       element = EL_BUG_DOWN;
3993       break;
3994
3995     case 0x1078:
3996       element = EL_BUG_LEFT;
3997       break;
3998
3999     case 0x1080:
4000       element = EL_BUG_RIGHT;
4001       break;
4002
4003     case 0x10de:
4004       element = EL_MOLE_UP;
4005       break;
4006
4007     case 0x10e7:
4008       element = EL_MOLE_DOWN;
4009       break;
4010
4011     case 0x10ff:
4012       element = EL_MOLE_LEFT;
4013       break;
4014
4015     case 0x1107:
4016       element = EL_MOLE_RIGHT;
4017       break;
4018
4019     case 0x11c0:
4020       element = EL_ROBOT;
4021       break;
4022
4023     case 0x13f5:
4024       element = EL_YAMYAM;
4025       break;
4026
4027     case 0x1425:
4028       element = EL_SWITCHGATE_OPEN;
4029       break;
4030
4031     case 0x1426:
4032       element = EL_SWITCHGATE_CLOSED;
4033       break;
4034
4035     case 0x1437:
4036       element = EL_DC_SWITCHGATE_SWITCH_UP;
4037       break;
4038
4039     case 0x143a:
4040       element = EL_TIMEGATE_CLOSED;
4041       break;
4042
4043     case 0x144c:        /* conveyor belt switch (green) */
4044       element = EL_CONVEYOR_BELT_3_SWITCH_MIDDLE;
4045       break;
4046
4047     case 0x144f:        /* conveyor belt switch (red) */
4048       element = EL_CONVEYOR_BELT_1_SWITCH_MIDDLE;
4049       break;
4050
4051     case 0x1452:        /* conveyor belt switch (blue) */
4052       element = EL_CONVEYOR_BELT_4_SWITCH_MIDDLE;
4053       break;
4054
4055     case 0x145b:
4056       element = EL_CONVEYOR_BELT_3_MIDDLE;
4057       break;
4058
4059     case 0x1463:
4060       element = EL_CONVEYOR_BELT_3_LEFT;
4061       break;
4062
4063     case 0x146b:
4064       element = EL_CONVEYOR_BELT_3_RIGHT;
4065       break;
4066
4067     case 0x1473:
4068       element = EL_CONVEYOR_BELT_1_MIDDLE;
4069       break;
4070
4071     case 0x147b:
4072       element = EL_CONVEYOR_BELT_1_LEFT;
4073       break;
4074
4075     case 0x1483:
4076       element = EL_CONVEYOR_BELT_1_RIGHT;
4077       break;
4078
4079     case 0x148b:
4080       element = EL_CONVEYOR_BELT_4_MIDDLE;
4081       break;
4082
4083     case 0x1493:
4084       element = EL_CONVEYOR_BELT_4_LEFT;
4085       break;
4086
4087     case 0x149b:
4088       element = EL_CONVEYOR_BELT_4_RIGHT;
4089       break;
4090
4091     case 0x14ac:
4092       element = EL_EXPANDABLE_WALL_HORIZONTAL;
4093       break;
4094
4095     case 0x14bd:
4096       element = EL_EXPANDABLE_WALL_VERTICAL;
4097       break;
4098
4099     case 0x14c6:
4100       element = EL_EXPANDABLE_WALL_ANY;
4101       break;
4102
4103     case 0x14ce:        /* growing steel wall (left/right) */
4104       element = EL_EXPANDABLE_STEELWALL_HORIZONTAL;
4105       break;
4106
4107     case 0x14df:        /* growing steel wall (up/down) */
4108       element = EL_EXPANDABLE_STEELWALL_VERTICAL;
4109       break;
4110
4111     case 0x14e8:        /* growing steel wall (up/down/left/right) */
4112       element = EL_EXPANDABLE_STEELWALL_ANY;
4113       break;
4114
4115     case 0x14e9:
4116       element = EL_SHIELD_DEADLY;
4117       break;
4118
4119     case 0x1501:
4120       element = EL_EXTRA_TIME;
4121       break;
4122
4123     case 0x154f:
4124       element = EL_ACID;
4125       break;
4126
4127     case 0x1577:
4128       element = EL_EMPTY_SPACE;
4129       break;
4130
4131     case 0x1578:        /* quicksand (empty) */
4132       element = EL_QUICKSAND_FAST_EMPTY;
4133       break;
4134
4135     case 0x1579:        /* slow quicksand (empty) */
4136       element = EL_QUICKSAND_EMPTY;
4137       break;
4138
4139       /* 0x157c - 0x158b: */
4140       /* EL_SAND */
4141
4142       /* 0x1590 - 0x159f: */
4143       /* EL_DC_LANDMINE */
4144
4145     case 0x15a0:
4146       element = EL_EM_DYNAMITE;
4147       break;
4148
4149     case 0x15a1:        /* key (red) */
4150       element = EL_EM_KEY_1;
4151       break;
4152
4153     case 0x15a2:        /* key (yellow) */
4154       element = EL_EM_KEY_2;
4155       break;
4156
4157     case 0x15a3:        /* key (blue) */
4158       element = EL_EM_KEY_4;
4159       break;
4160
4161     case 0x15a4:        /* key (green) */
4162       element = EL_EM_KEY_3;
4163       break;
4164
4165     case 0x15a5:        /* key (white) */
4166       element = EL_DC_KEY_WHITE;
4167       break;
4168
4169     case 0x15a6:
4170       element = EL_WALL_SLIPPERY;
4171       break;
4172
4173     case 0x15a7:
4174       element = EL_WALL;
4175       break;
4176
4177     case 0x15a8:        /* wall (not round) */
4178       element = EL_WALL;
4179       break;
4180
4181     case 0x15a9:        /* (blue) */
4182       element = EL_CHAR_A;
4183       break;
4184
4185     case 0x15aa:        /* (blue) */
4186       element = EL_CHAR_B;
4187       break;
4188
4189     case 0x15ab:        /* (blue) */
4190       element = EL_CHAR_C;
4191       break;
4192
4193     case 0x15ac:        /* (blue) */
4194       element = EL_CHAR_D;
4195       break;
4196
4197     case 0x15ad:        /* (blue) */
4198       element = EL_CHAR_E;
4199       break;
4200
4201     case 0x15ae:        /* (blue) */
4202       element = EL_CHAR_F;
4203       break;
4204
4205     case 0x15af:        /* (blue) */
4206       element = EL_CHAR_G;
4207       break;
4208
4209     case 0x15b0:        /* (blue) */
4210       element = EL_CHAR_H;
4211       break;
4212
4213     case 0x15b1:        /* (blue) */
4214       element = EL_CHAR_I;
4215       break;
4216
4217     case 0x15b2:        /* (blue) */
4218       element = EL_CHAR_J;
4219       break;
4220
4221     case 0x15b3:        /* (blue) */
4222       element = EL_CHAR_K;
4223       break;
4224
4225     case 0x15b4:        /* (blue) */
4226       element = EL_CHAR_L;
4227       break;
4228
4229     case 0x15b5:        /* (blue) */
4230       element = EL_CHAR_M;
4231       break;
4232
4233     case 0x15b6:        /* (blue) */
4234       element = EL_CHAR_N;
4235       break;
4236
4237     case 0x15b7:        /* (blue) */
4238       element = EL_CHAR_O;
4239       break;
4240
4241     case 0x15b8:        /* (blue) */
4242       element = EL_CHAR_P;
4243       break;
4244
4245     case 0x15b9:        /* (blue) */
4246       element = EL_CHAR_Q;
4247       break;
4248
4249     case 0x15ba:        /* (blue) */
4250       element = EL_CHAR_R;
4251       break;
4252
4253     case 0x15bb:        /* (blue) */
4254       element = EL_CHAR_S;
4255       break;
4256
4257     case 0x15bc:        /* (blue) */
4258       element = EL_CHAR_T;
4259       break;
4260
4261     case 0x15bd:        /* (blue) */
4262       element = EL_CHAR_U;
4263       break;
4264
4265     case 0x15be:        /* (blue) */
4266       element = EL_CHAR_V;
4267       break;
4268
4269     case 0x15bf:        /* (blue) */
4270       element = EL_CHAR_W;
4271       break;
4272
4273     case 0x15c0:        /* (blue) */
4274       element = EL_CHAR_X;
4275       break;
4276
4277     case 0x15c1:        /* (blue) */
4278       element = EL_CHAR_Y;
4279       break;
4280
4281     case 0x15c2:        /* (blue) */
4282       element = EL_CHAR_Z;
4283       break;
4284
4285     case 0x15c3:        /* (blue) */
4286       element = EL_CHAR_AUMLAUT;
4287       break;
4288
4289     case 0x15c4:        /* (blue) */
4290       element = EL_CHAR_OUMLAUT;
4291       break;
4292
4293     case 0x15c5:        /* (blue) */
4294       element = EL_CHAR_UUMLAUT;
4295       break;
4296
4297     case 0x15c6:        /* (blue) */
4298       element = EL_CHAR_0;
4299       break;
4300
4301     case 0x15c7:        /* (blue) */
4302       element = EL_CHAR_1;
4303       break;
4304
4305     case 0x15c8:        /* (blue) */
4306       element = EL_CHAR_2;
4307       break;
4308
4309     case 0x15c9:        /* (blue) */
4310       element = EL_CHAR_3;
4311       break;
4312
4313     case 0x15ca:        /* (blue) */
4314       element = EL_CHAR_4;
4315       break;
4316
4317     case 0x15cb:        /* (blue) */
4318       element = EL_CHAR_5;
4319       break;
4320
4321     case 0x15cc:        /* (blue) */
4322       element = EL_CHAR_6;
4323       break;
4324
4325     case 0x15cd:        /* (blue) */
4326       element = EL_CHAR_7;
4327       break;
4328
4329     case 0x15ce:        /* (blue) */
4330       element = EL_CHAR_8;
4331       break;
4332
4333     case 0x15cf:        /* (blue) */
4334       element = EL_CHAR_9;
4335       break;
4336
4337     case 0x15d0:        /* (blue) */
4338       element = EL_CHAR_PERIOD;
4339       break;
4340
4341     case 0x15d1:        /* (blue) */
4342       element = EL_CHAR_EXCLAM;
4343       break;
4344
4345     case 0x15d2:        /* (blue) */
4346       element = EL_CHAR_COLON;
4347       break;
4348
4349     case 0x15d3:        /* (blue) */
4350       element = EL_CHAR_LESS;
4351       break;
4352
4353     case 0x15d4:        /* (blue) */
4354       element = EL_CHAR_GREATER;
4355       break;
4356
4357     case 0x15d5:        /* (blue) */
4358       element = EL_CHAR_QUESTION;
4359       break;
4360
4361     case 0x15d6:        /* (blue) */
4362       element = EL_CHAR_COPYRIGHT;
4363       break;
4364
4365     case 0x15d7:        /* (blue) */
4366       element = EL_CHAR_UP;
4367       break;
4368
4369     case 0x15d8:        /* (blue) */
4370       element = EL_CHAR_DOWN;
4371       break;
4372
4373     case 0x15d9:        /* (blue) */
4374       element = EL_CHAR_BUTTON;
4375       break;
4376
4377     case 0x15da:        /* (blue) */
4378       element = EL_CHAR_PLUS;
4379       break;
4380
4381     case 0x15db:        /* (blue) */
4382       element = EL_CHAR_MINUS;
4383       break;
4384
4385     case 0x15dc:        /* (blue) */
4386       element = EL_CHAR_APOSTROPHE;
4387       break;
4388
4389     case 0x15dd:        /* (blue) */
4390       element = EL_CHAR_PARENLEFT;
4391       break;
4392
4393     case 0x15de:        /* (blue) */
4394       element = EL_CHAR_PARENRIGHT;
4395       break;
4396
4397     case 0x15df:        /* (green) */
4398       element = EL_CHAR_A;
4399       break;
4400
4401     case 0x15e0:        /* (green) */
4402       element = EL_CHAR_B;
4403       break;
4404
4405     case 0x15e1:        /* (green) */
4406       element = EL_CHAR_C;
4407       break;
4408
4409     case 0x15e2:        /* (green) */
4410       element = EL_CHAR_D;
4411       break;
4412
4413     case 0x15e3:        /* (green) */
4414       element = EL_CHAR_E;
4415       break;
4416
4417     case 0x15e4:        /* (green) */
4418       element = EL_CHAR_F;
4419       break;
4420
4421     case 0x15e5:        /* (green) */
4422       element = EL_CHAR_G;
4423       break;
4424
4425     case 0x15e6:        /* (green) */
4426       element = EL_CHAR_H;
4427       break;
4428
4429     case 0x15e7:        /* (green) */
4430       element = EL_CHAR_I;
4431       break;
4432
4433     case 0x15e8:        /* (green) */
4434       element = EL_CHAR_J;
4435       break;
4436
4437     case 0x15e9:        /* (green) */
4438       element = EL_CHAR_K;
4439       break;
4440
4441     case 0x15ea:        /* (green) */
4442       element = EL_CHAR_L;
4443       break;
4444
4445     case 0x15eb:        /* (green) */
4446       element = EL_CHAR_M;
4447       break;
4448
4449     case 0x15ec:        /* (green) */
4450       element = EL_CHAR_N;
4451       break;
4452
4453     case 0x15ed:        /* (green) */
4454       element = EL_CHAR_O;
4455       break;
4456
4457     case 0x15ee:        /* (green) */
4458       element = EL_CHAR_P;
4459       break;
4460
4461     case 0x15ef:        /* (green) */
4462       element = EL_CHAR_Q;
4463       break;
4464
4465     case 0x15f0:        /* (green) */
4466       element = EL_CHAR_R;
4467       break;
4468
4469     case 0x15f1:        /* (green) */
4470       element = EL_CHAR_S;
4471       break;
4472
4473     case 0x15f2:        /* (green) */
4474       element = EL_CHAR_T;
4475       break;
4476
4477     case 0x15f3:        /* (green) */
4478       element = EL_CHAR_U;
4479       break;
4480
4481     case 0x15f4:        /* (green) */
4482       element = EL_CHAR_V;
4483       break;
4484
4485     case 0x15f5:        /* (green) */
4486       element = EL_CHAR_W;
4487       break;
4488
4489     case 0x15f6:        /* (green) */
4490       element = EL_CHAR_X;
4491       break;
4492
4493     case 0x15f7:        /* (green) */
4494       element = EL_CHAR_Y;
4495       break;
4496
4497     case 0x15f8:        /* (green) */
4498       element = EL_CHAR_Z;
4499       break;
4500
4501     case 0x15f9:        /* (green) */
4502       element = EL_CHAR_AUMLAUT;
4503       break;
4504
4505     case 0x15fa:        /* (green) */
4506       element = EL_CHAR_OUMLAUT;
4507       break;
4508
4509     case 0x15fb:        /* (green) */
4510       element = EL_CHAR_UUMLAUT;
4511       break;
4512
4513     case 0x15fc:        /* (green) */
4514       element = EL_CHAR_0;
4515       break;
4516
4517     case 0x15fd:        /* (green) */
4518       element = EL_CHAR_1;
4519       break;
4520
4521     case 0x15fe:        /* (green) */
4522       element = EL_CHAR_2;
4523       break;
4524
4525     case 0x15ff:        /* (green) */
4526       element = EL_CHAR_3;
4527       break;
4528
4529     case 0x1600:        /* (green) */
4530       element = EL_CHAR_4;
4531       break;
4532
4533     case 0x1601:        /* (green) */
4534       element = EL_CHAR_5;
4535       break;
4536
4537     case 0x1602:        /* (green) */
4538       element = EL_CHAR_6;
4539       break;
4540
4541     case 0x1603:        /* (green) */
4542       element = EL_CHAR_7;
4543       break;
4544
4545     case 0x1604:        /* (green) */
4546       element = EL_CHAR_8;
4547       break;
4548
4549     case 0x1605:        /* (green) */
4550       element = EL_CHAR_9;
4551       break;
4552
4553     case 0x1606:        /* (green) */
4554       element = EL_CHAR_PERIOD;
4555       break;
4556
4557     case 0x1607:        /* (green) */
4558       element = EL_CHAR_EXCLAM;
4559       break;
4560
4561     case 0x1608:        /* (green) */
4562       element = EL_CHAR_COLON;
4563       break;
4564
4565     case 0x1609:        /* (green) */
4566       element = EL_CHAR_LESS;
4567       break;
4568
4569     case 0x160a:        /* (green) */
4570       element = EL_CHAR_GREATER;
4571       break;
4572
4573     case 0x160b:        /* (green) */
4574       element = EL_CHAR_QUESTION;
4575       break;
4576
4577     case 0x160c:        /* (green) */
4578       element = EL_CHAR_COPYRIGHT;
4579       break;
4580
4581     case 0x160d:        /* (green) */
4582       element = EL_CHAR_UP;
4583       break;
4584
4585     case 0x160e:        /* (green) */
4586       element = EL_CHAR_DOWN;
4587       break;
4588
4589     case 0x160f:        /* (green) */
4590       element = EL_CHAR_BUTTON;
4591       break;
4592
4593     case 0x1610:        /* (green) */
4594       element = EL_CHAR_PLUS;
4595       break;
4596
4597     case 0x1611:        /* (green) */
4598       element = EL_CHAR_MINUS;
4599       break;
4600
4601     case 0x1612:        /* (green) */
4602       element = EL_CHAR_APOSTROPHE;
4603       break;
4604
4605     case 0x1613:        /* (green) */
4606       element = EL_CHAR_PARENLEFT;
4607       break;
4608
4609     case 0x1614:        /* (green) */
4610       element = EL_CHAR_PARENRIGHT;
4611       break;
4612
4613     case 0x1615:        /* (blue steel) */
4614       element = EL_STEEL_CHAR_A;
4615       break;
4616
4617     case 0x1616:        /* (blue steel) */
4618       element = EL_STEEL_CHAR_B;
4619       break;
4620
4621     case 0x1617:        /* (blue steel) */
4622       element = EL_STEEL_CHAR_C;
4623       break;
4624
4625     case 0x1618:        /* (blue steel) */
4626       element = EL_STEEL_CHAR_D;
4627       break;
4628
4629     case 0x1619:        /* (blue steel) */
4630       element = EL_STEEL_CHAR_E;
4631       break;
4632
4633     case 0x161a:        /* (blue steel) */
4634       element = EL_STEEL_CHAR_F;
4635       break;
4636
4637     case 0x161b:        /* (blue steel) */
4638       element = EL_STEEL_CHAR_G;
4639       break;
4640
4641     case 0x161c:        /* (blue steel) */
4642       element = EL_STEEL_CHAR_H;
4643       break;
4644
4645     case 0x161d:        /* (blue steel) */
4646       element = EL_STEEL_CHAR_I;
4647       break;
4648
4649     case 0x161e:        /* (blue steel) */
4650       element = EL_STEEL_CHAR_J;
4651       break;
4652
4653     case 0x161f:        /* (blue steel) */
4654       element = EL_STEEL_CHAR_K;
4655       break;
4656
4657     case 0x1620:        /* (blue steel) */
4658       element = EL_STEEL_CHAR_L;
4659       break;
4660
4661     case 0x1621:        /* (blue steel) */
4662       element = EL_STEEL_CHAR_M;
4663       break;
4664
4665     case 0x1622:        /* (blue steel) */
4666       element = EL_STEEL_CHAR_N;
4667       break;
4668
4669     case 0x1623:        /* (blue steel) */
4670       element = EL_STEEL_CHAR_O;
4671       break;
4672
4673     case 0x1624:        /* (blue steel) */
4674       element = EL_STEEL_CHAR_P;
4675       break;
4676
4677     case 0x1625:        /* (blue steel) */
4678       element = EL_STEEL_CHAR_Q;
4679       break;
4680
4681     case 0x1626:        /* (blue steel) */
4682       element = EL_STEEL_CHAR_R;
4683       break;
4684
4685     case 0x1627:        /* (blue steel) */
4686       element = EL_STEEL_CHAR_S;
4687       break;
4688
4689     case 0x1628:        /* (blue steel) */
4690       element = EL_STEEL_CHAR_T;
4691       break;
4692
4693     case 0x1629:        /* (blue steel) */
4694       element = EL_STEEL_CHAR_U;
4695       break;
4696
4697     case 0x162a:        /* (blue steel) */
4698       element = EL_STEEL_CHAR_V;
4699       break;
4700
4701     case 0x162b:        /* (blue steel) */
4702       element = EL_STEEL_CHAR_W;
4703       break;
4704
4705     case 0x162c:        /* (blue steel) */
4706       element = EL_STEEL_CHAR_X;
4707       break;
4708
4709     case 0x162d:        /* (blue steel) */
4710       element = EL_STEEL_CHAR_Y;
4711       break;
4712
4713     case 0x162e:        /* (blue steel) */
4714       element = EL_STEEL_CHAR_Z;
4715       break;
4716
4717     case 0x162f:        /* (blue steel) */
4718       element = EL_STEEL_CHAR_AUMLAUT;
4719       break;
4720
4721     case 0x1630:        /* (blue steel) */
4722       element = EL_STEEL_CHAR_OUMLAUT;
4723       break;
4724
4725     case 0x1631:        /* (blue steel) */
4726       element = EL_STEEL_CHAR_UUMLAUT;
4727       break;
4728
4729     case 0x1632:        /* (blue steel) */
4730       element = EL_STEEL_CHAR_0;
4731       break;
4732
4733     case 0x1633:        /* (blue steel) */
4734       element = EL_STEEL_CHAR_1;
4735       break;
4736
4737     case 0x1634:        /* (blue steel) */
4738       element = EL_STEEL_CHAR_2;
4739       break;
4740
4741     case 0x1635:        /* (blue steel) */
4742       element = EL_STEEL_CHAR_3;
4743       break;
4744
4745     case 0x1636:        /* (blue steel) */
4746       element = EL_STEEL_CHAR_4;
4747       break;
4748
4749     case 0x1637:        /* (blue steel) */
4750       element = EL_STEEL_CHAR_5;
4751       break;
4752
4753     case 0x1638:        /* (blue steel) */
4754       element = EL_STEEL_CHAR_6;
4755       break;
4756
4757     case 0x1639:        /* (blue steel) */
4758       element = EL_STEEL_CHAR_7;
4759       break;
4760
4761     case 0x163a:        /* (blue steel) */
4762       element = EL_STEEL_CHAR_8;
4763       break;
4764
4765     case 0x163b:        /* (blue steel) */
4766       element = EL_STEEL_CHAR_9;
4767       break;
4768
4769     case 0x163c:        /* (blue steel) */
4770       element = EL_STEEL_CHAR_PERIOD;
4771       break;
4772
4773     case 0x163d:        /* (blue steel) */
4774       element = EL_STEEL_CHAR_EXCLAM;
4775       break;
4776
4777     case 0x163e:        /* (blue steel) */
4778       element = EL_STEEL_CHAR_COLON;
4779       break;
4780
4781     case 0x163f:        /* (blue steel) */
4782       element = EL_STEEL_CHAR_LESS;
4783       break;
4784
4785     case 0x1640:        /* (blue steel) */
4786       element = EL_STEEL_CHAR_GREATER;
4787       break;
4788
4789     case 0x1641:        /* (blue steel) */
4790       element = EL_STEEL_CHAR_QUESTION;
4791       break;
4792
4793     case 0x1642:        /* (blue steel) */
4794       element = EL_STEEL_CHAR_COPYRIGHT;
4795       break;
4796
4797     case 0x1643:        /* (blue steel) */
4798       element = EL_STEEL_CHAR_UP;
4799       break;
4800
4801     case 0x1644:        /* (blue steel) */
4802       element = EL_STEEL_CHAR_DOWN;
4803       break;
4804
4805     case 0x1645:        /* (blue steel) */
4806       element = EL_STEEL_CHAR_BUTTON;
4807       break;
4808
4809     case 0x1646:        /* (blue steel) */
4810       element = EL_STEEL_CHAR_PLUS;
4811       break;
4812
4813     case 0x1647:        /* (blue steel) */
4814       element = EL_STEEL_CHAR_MINUS;
4815       break;
4816
4817     case 0x1648:        /* (blue steel) */
4818       element = EL_STEEL_CHAR_APOSTROPHE;
4819       break;
4820
4821     case 0x1649:        /* (blue steel) */
4822       element = EL_STEEL_CHAR_PARENLEFT;
4823       break;
4824
4825     case 0x164a:        /* (blue steel) */
4826       element = EL_STEEL_CHAR_PARENRIGHT;
4827       break;
4828
4829     case 0x164b:        /* (green steel) */
4830       element = EL_STEEL_CHAR_A;
4831       break;
4832
4833     case 0x164c:        /* (green steel) */
4834       element = EL_STEEL_CHAR_B;
4835       break;
4836
4837     case 0x164d:        /* (green steel) */
4838       element = EL_STEEL_CHAR_C;
4839       break;
4840
4841     case 0x164e:        /* (green steel) */
4842       element = EL_STEEL_CHAR_D;
4843       break;
4844
4845     case 0x164f:        /* (green steel) */
4846       element = EL_STEEL_CHAR_E;
4847       break;
4848
4849     case 0x1650:        /* (green steel) */
4850       element = EL_STEEL_CHAR_F;
4851       break;
4852
4853     case 0x1651:        /* (green steel) */
4854       element = EL_STEEL_CHAR_G;
4855       break;
4856
4857     case 0x1652:        /* (green steel) */
4858       element = EL_STEEL_CHAR_H;
4859       break;
4860
4861     case 0x1653:        /* (green steel) */
4862       element = EL_STEEL_CHAR_I;
4863       break;
4864
4865     case 0x1654:        /* (green steel) */
4866       element = EL_STEEL_CHAR_J;
4867       break;
4868
4869     case 0x1655:        /* (green steel) */
4870       element = EL_STEEL_CHAR_K;
4871       break;
4872
4873     case 0x1656:        /* (green steel) */
4874       element = EL_STEEL_CHAR_L;
4875       break;
4876
4877     case 0x1657:        /* (green steel) */
4878       element = EL_STEEL_CHAR_M;
4879       break;
4880
4881     case 0x1658:        /* (green steel) */
4882       element = EL_STEEL_CHAR_N;
4883       break;
4884
4885     case 0x1659:        /* (green steel) */
4886       element = EL_STEEL_CHAR_O;
4887       break;
4888
4889     case 0x165a:        /* (green steel) */
4890       element = EL_STEEL_CHAR_P;
4891       break;
4892
4893     case 0x165b:        /* (green steel) */
4894       element = EL_STEEL_CHAR_Q;
4895       break;
4896
4897     case 0x165c:        /* (green steel) */
4898       element = EL_STEEL_CHAR_R;
4899       break;
4900
4901     case 0x165d:        /* (green steel) */
4902       element = EL_STEEL_CHAR_S;
4903       break;
4904
4905     case 0x165e:        /* (green steel) */
4906       element = EL_STEEL_CHAR_T;
4907       break;
4908
4909     case 0x165f:        /* (green steel) */
4910       element = EL_STEEL_CHAR_U;
4911       break;
4912
4913     case 0x1660:        /* (green steel) */
4914       element = EL_STEEL_CHAR_V;
4915       break;
4916
4917     case 0x1661:        /* (green steel) */
4918       element = EL_STEEL_CHAR_W;
4919       break;
4920
4921     case 0x1662:        /* (green steel) */
4922       element = EL_STEEL_CHAR_X;
4923       break;
4924
4925     case 0x1663:        /* (green steel) */
4926       element = EL_STEEL_CHAR_Y;
4927       break;
4928
4929     case 0x1664:        /* (green steel) */
4930       element = EL_STEEL_CHAR_Z;
4931       break;
4932
4933     case 0x1665:        /* (green steel) */
4934       element = EL_STEEL_CHAR_AUMLAUT;
4935       break;
4936
4937     case 0x1666:        /* (green steel) */
4938       element = EL_STEEL_CHAR_OUMLAUT;
4939       break;
4940
4941     case 0x1667:        /* (green steel) */
4942       element = EL_STEEL_CHAR_UUMLAUT;
4943       break;
4944
4945     case 0x1668:        /* (green steel) */
4946       element = EL_STEEL_CHAR_0;
4947       break;
4948
4949     case 0x1669:        /* (green steel) */
4950       element = EL_STEEL_CHAR_1;
4951       break;
4952
4953     case 0x166a:        /* (green steel) */
4954       element = EL_STEEL_CHAR_2;
4955       break;
4956
4957     case 0x166b:        /* (green steel) */
4958       element = EL_STEEL_CHAR_3;
4959       break;
4960
4961     case 0x166c:        /* (green steel) */
4962       element = EL_STEEL_CHAR_4;
4963       break;
4964
4965     case 0x166d:        /* (green steel) */
4966       element = EL_STEEL_CHAR_5;
4967       break;
4968
4969     case 0x166e:        /* (green steel) */
4970       element = EL_STEEL_CHAR_6;
4971       break;
4972
4973     case 0x166f:        /* (green steel) */
4974       element = EL_STEEL_CHAR_7;
4975       break;
4976
4977     case 0x1670:        /* (green steel) */
4978       element = EL_STEEL_CHAR_8;
4979       break;
4980
4981     case 0x1671:        /* (green steel) */
4982       element = EL_STEEL_CHAR_9;
4983       break;
4984
4985     case 0x1672:        /* (green steel) */
4986       element = EL_STEEL_CHAR_PERIOD;
4987       break;
4988
4989     case 0x1673:        /* (green steel) */
4990       element = EL_STEEL_CHAR_EXCLAM;
4991       break;
4992
4993     case 0x1674:        /* (green steel) */
4994       element = EL_STEEL_CHAR_COLON;
4995       break;
4996
4997     case 0x1675:        /* (green steel) */
4998       element = EL_STEEL_CHAR_LESS;
4999       break;
5000
5001     case 0x1676:        /* (green steel) */
5002       element = EL_STEEL_CHAR_GREATER;
5003       break;
5004
5005     case 0x1677:        /* (green steel) */
5006       element = EL_STEEL_CHAR_QUESTION;
5007       break;
5008
5009     case 0x1678:        /* (green steel) */
5010       element = EL_STEEL_CHAR_COPYRIGHT;
5011       break;
5012
5013     case 0x1679:        /* (green steel) */
5014       element = EL_STEEL_CHAR_UP;
5015       break;
5016
5017     case 0x167a:        /* (green steel) */
5018       element = EL_STEEL_CHAR_DOWN;
5019       break;
5020
5021     case 0x167b:        /* (green steel) */
5022       element = EL_STEEL_CHAR_BUTTON;
5023       break;
5024
5025     case 0x167c:        /* (green steel) */
5026       element = EL_STEEL_CHAR_PLUS;
5027       break;
5028
5029     case 0x167d:        /* (green steel) */
5030       element = EL_STEEL_CHAR_MINUS;
5031       break;
5032
5033     case 0x167e:        /* (green steel) */
5034       element = EL_STEEL_CHAR_APOSTROPHE;
5035       break;
5036
5037     case 0x167f:        /* (green steel) */
5038       element = EL_STEEL_CHAR_PARENLEFT;
5039       break;
5040
5041     case 0x1680:        /* (green steel) */
5042       element = EL_STEEL_CHAR_PARENRIGHT;
5043       break;
5044
5045     case 0x1681:        /* gate (red) */
5046       element = EL_EM_GATE_1;
5047       break;
5048
5049     case 0x1682:        /* secret gate (red) */
5050       element = EL_GATE_1_GRAY;
5051       break;
5052
5053     case 0x1683:        /* gate (yellow) */
5054       element = EL_EM_GATE_2;
5055       break;
5056
5057     case 0x1684:        /* secret gate (yellow) */
5058       element = EL_GATE_2_GRAY;
5059       break;
5060
5061     case 0x1685:        /* gate (blue) */
5062       element = EL_EM_GATE_4;
5063       break;
5064
5065     case 0x1686:        /* secret gate (blue) */
5066       element = EL_GATE_4_GRAY;
5067       break;
5068
5069     case 0x1687:        /* gate (green) */
5070       element = EL_EM_GATE_3;
5071       break;
5072
5073     case 0x1688:        /* secret gate (green) */
5074       element = EL_GATE_3_GRAY;
5075       break;
5076
5077     case 0x1689:        /* gate (white) */
5078       element = EL_DC_GATE_WHITE;
5079       break;
5080
5081     case 0x168a:        /* secret gate (white) */
5082       element = EL_DC_GATE_WHITE_GRAY;
5083       break;
5084
5085     case 0x168b:        /* secret gate (no key) */
5086       element = EL_DC_GATE_FAKE_GRAY;
5087       break;
5088
5089     case 0x168c:
5090       element = EL_ROBOT_WHEEL;
5091       break;
5092
5093     case 0x168d:
5094       element = EL_DC_TIMEGATE_SWITCH;
5095       break;
5096
5097     case 0x168e:
5098       element = EL_ACID_POOL_BOTTOM;
5099       break;
5100
5101     case 0x168f:
5102       element = EL_ACID_POOL_TOPLEFT;
5103       break;
5104
5105     case 0x1690:
5106       element = EL_ACID_POOL_TOPRIGHT;
5107       break;
5108
5109     case 0x1691:
5110       element = EL_ACID_POOL_BOTTOMLEFT;
5111       break;
5112
5113     case 0x1692:
5114       element = EL_ACID_POOL_BOTTOMRIGHT;
5115       break;
5116
5117     case 0x1693:
5118       element = EL_STEELWALL;
5119       break;
5120
5121     case 0x1694:
5122       element = EL_STEELWALL_SLIPPERY;
5123       break;
5124
5125     case 0x1695:        /* steel wall (not round) */
5126       element = EL_STEELWALL;
5127       break;
5128
5129     case 0x1696:        /* steel wall (left) */
5130       element = EL_DC_STEELWALL_1_LEFT;
5131       break;
5132
5133     case 0x1697:        /* steel wall (bottom) */
5134       element = EL_DC_STEELWALL_1_BOTTOM;
5135       break;
5136
5137     case 0x1698:        /* steel wall (right) */
5138       element = EL_DC_STEELWALL_1_RIGHT;
5139       break;
5140
5141     case 0x1699:        /* steel wall (top) */
5142       element = EL_DC_STEELWALL_1_TOP;
5143       break;
5144
5145     case 0x169a:        /* steel wall (left/bottom) */
5146       element = EL_DC_STEELWALL_1_BOTTOMLEFT;
5147       break;
5148
5149     case 0x169b:        /* steel wall (right/bottom) */
5150       element = EL_DC_STEELWALL_1_BOTTOMRIGHT;
5151       break;
5152
5153     case 0x169c:        /* steel wall (right/top) */
5154       element = EL_DC_STEELWALL_1_TOPRIGHT;
5155       break;
5156
5157     case 0x169d:        /* steel wall (left/top) */
5158       element = EL_DC_STEELWALL_1_TOPLEFT;
5159       break;
5160
5161     case 0x169e:        /* steel wall (right/bottom small) */
5162       element = EL_DC_STEELWALL_1_BOTTOMRIGHT_2;
5163       break;
5164
5165     case 0x169f:        /* steel wall (left/bottom small) */
5166       element = EL_DC_STEELWALL_1_BOTTOMLEFT_2;
5167       break;
5168
5169     case 0x16a0:        /* steel wall (right/top small) */
5170       element = EL_DC_STEELWALL_1_TOPRIGHT_2;
5171       break;
5172
5173     case 0x16a1:        /* steel wall (left/top small) */
5174       element = EL_DC_STEELWALL_1_TOPLEFT_2;
5175       break;
5176
5177     case 0x16a2:        /* steel wall (left/right) */
5178       element = EL_DC_STEELWALL_1_VERTICAL;
5179       break;
5180
5181     case 0x16a3:        /* steel wall (top/bottom) */
5182       element = EL_DC_STEELWALL_1_HORIZONTAL;
5183       break;
5184
5185     case 0x16a4:        /* steel wall 2 (left end) */
5186       element = EL_DC_STEELWALL_2_LEFT;
5187       break;
5188
5189     case 0x16a5:        /* steel wall 2 (right end) */
5190       element = EL_DC_STEELWALL_2_RIGHT;
5191       break;
5192
5193     case 0x16a6:        /* steel wall 2 (top end) */
5194       element = EL_DC_STEELWALL_2_TOP;
5195       break;
5196
5197     case 0x16a7:        /* steel wall 2 (bottom end) */
5198       element = EL_DC_STEELWALL_2_BOTTOM;
5199       break;
5200
5201     case 0x16a8:        /* steel wall 2 (left/right) */
5202       element = EL_DC_STEELWALL_2_HORIZONTAL;
5203       break;
5204
5205     case 0x16a9:        /* steel wall 2 (up/down) */
5206       element = EL_DC_STEELWALL_2_VERTICAL;
5207       break;
5208
5209     case 0x16aa:        /* steel wall 2 (mid) */
5210       element = EL_DC_STEELWALL_2_MIDDLE;
5211       break;
5212
5213     case 0x16ab:
5214       element = EL_SIGN_EXCLAMATION;
5215       break;
5216
5217     case 0x16ac:
5218       element = EL_SIGN_RADIOACTIVITY;
5219       break;
5220
5221     case 0x16ad:
5222       element = EL_SIGN_STOP;
5223       break;
5224
5225     case 0x16ae:
5226       element = EL_SIGN_WHEELCHAIR;
5227       break;
5228
5229     case 0x16af:
5230       element = EL_SIGN_PARKING;
5231       break;
5232
5233     case 0x16b0:
5234       element = EL_SIGN_NO_ENTRY;
5235       break;
5236
5237     case 0x16b1:
5238       element = EL_SIGN_HEART;
5239       break;
5240
5241     case 0x16b2:
5242       element = EL_SIGN_GIVE_WAY;
5243       break;
5244
5245     case 0x16b3:
5246       element = EL_SIGN_ENTRY_FORBIDDEN;
5247       break;
5248
5249     case 0x16b4:
5250       element = EL_SIGN_EMERGENCY_EXIT;
5251       break;
5252
5253     case 0x16b5:
5254       element = EL_SIGN_YIN_YANG;
5255       break;
5256
5257     case 0x16b6:
5258       element = EL_WALL_EMERALD;
5259       break;
5260
5261     case 0x16b7:
5262       element = EL_WALL_DIAMOND;
5263       break;
5264
5265     case 0x16b8:
5266       element = EL_WALL_PEARL;
5267       break;
5268
5269     case 0x16b9:
5270       element = EL_WALL_CRYSTAL;
5271       break;
5272
5273     case 0x16ba:
5274       element = EL_INVISIBLE_WALL;
5275       break;
5276
5277     case 0x16bb:
5278       element = EL_INVISIBLE_STEELWALL;
5279       break;
5280
5281       /* 0x16bc - 0x16cb: */
5282       /* EL_INVISIBLE_SAND */
5283
5284     case 0x16cc:
5285       element = EL_LIGHT_SWITCH;
5286       break;
5287
5288     case 0x16cd:
5289       element = EL_ENVELOPE_1;
5290       break;
5291
5292     default:
5293       if (element >= 0x0117 && element <= 0x036e)       /* (?) */
5294         element = EL_DIAMOND;
5295       else if (element >= 0x042d && element <= 0x0684)  /* (?) */
5296         element = EL_EMERALD;
5297       else if (element >= 0x157c && element <= 0x158b)
5298         element = EL_SAND;
5299       else if (element >= 0x1590 && element <= 0x159f)
5300         element = EL_DC_LANDMINE;
5301       else if (element >= 0x16bc && element <= 0x16cb)
5302         element = EL_INVISIBLE_SAND;
5303       else
5304       {
5305         Error(ERR_WARN, "unknown Diamond Caves element 0x%04x", element);
5306         element = EL_UNKNOWN;
5307       }
5308       break;
5309   }
5310
5311   return getMappedElement(element);
5312 }
5313
5314 static void LoadLevelFromFileStream_DC(File *file, struct LevelInfo *level,
5315                                        int nr)
5316 {
5317   byte header[DC_LEVEL_HEADER_SIZE];
5318   int envelope_size;
5319   int envelope_header_pos = 62;
5320   int envelope_content_pos = 94;
5321   int level_name_pos = 251;
5322   int level_author_pos = 292;
5323   int envelope_header_len;
5324   int envelope_content_len;
5325   int level_name_len;
5326   int level_author_len;
5327   int fieldx, fieldy;
5328   int num_yamyam_contents;
5329   int i, x, y;
5330
5331   getDecodedWord_DC(0, TRUE);           /* initialize DC2 decoding engine */
5332
5333   for (i = 0; i < DC_LEVEL_HEADER_SIZE / 2; i++)
5334   {
5335     unsigned short header_word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5336
5337     header[i * 2 + 0] = header_word >> 8;
5338     header[i * 2 + 1] = header_word & 0xff;
5339   }
5340
5341   /* read some values from level header to check level decoding integrity */
5342   fieldx = header[6] | (header[7] << 8);
5343   fieldy = header[8] | (header[9] << 8);
5344   num_yamyam_contents = header[60] | (header[61] << 8);
5345
5346   /* do some simple sanity checks to ensure that level was correctly decoded */
5347   if (fieldx < 1 || fieldx > 256 ||
5348       fieldy < 1 || fieldy > 256 ||
5349       num_yamyam_contents < 1 || num_yamyam_contents > 8)
5350   {
5351     level->no_valid_file = TRUE;
5352
5353     Error(ERR_WARN, "cannot decode level from stream -- using empty level");
5354
5355     return;
5356   }
5357
5358   /* maximum envelope header size is 31 bytes */
5359   envelope_header_len   = header[envelope_header_pos];
5360   /* maximum envelope content size is 110 (156?) bytes */
5361   envelope_content_len  = header[envelope_content_pos];
5362
5363   /* maximum level title size is 40 bytes */
5364   level_name_len        = MIN(header[level_name_pos],   MAX_LEVEL_NAME_LEN);
5365   /* maximum level author size is 30 (51?) bytes */
5366   level_author_len      = MIN(header[level_author_pos], MAX_LEVEL_AUTHOR_LEN);
5367
5368   envelope_size = 0;
5369
5370   for (i = 0; i < envelope_header_len; i++)
5371     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5372       level->envelope[0].text[envelope_size++] =
5373         header[envelope_header_pos + 1 + i];
5374
5375   if (envelope_header_len > 0 && envelope_content_len > 0)
5376   {
5377     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5378       level->envelope[0].text[envelope_size++] = '\n';
5379     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5380       level->envelope[0].text[envelope_size++] = '\n';
5381   }
5382
5383   for (i = 0; i < envelope_content_len; i++)
5384     if (envelope_size < MAX_ENVELOPE_TEXT_LEN)
5385       level->envelope[0].text[envelope_size++] =
5386         header[envelope_content_pos + 1 + i];
5387
5388   level->envelope[0].text[envelope_size] = '\0';
5389
5390   level->envelope[0].xsize = MAX_ENVELOPE_XSIZE;
5391   level->envelope[0].ysize = 10;
5392   level->envelope[0].autowrap = TRUE;
5393   level->envelope[0].centered = TRUE;
5394
5395   for (i = 0; i < level_name_len; i++)
5396     level->name[i] = header[level_name_pos + 1 + i];
5397   level->name[level_name_len] = '\0';
5398
5399   for (i = 0; i < level_author_len; i++)
5400     level->author[i] = header[level_author_pos + 1 + i];
5401   level->author[level_author_len] = '\0';
5402
5403   num_yamyam_contents = header[60] | (header[61] << 8);
5404   level->num_yamyam_contents =
5405     MIN(MAX(MIN_ELEMENT_CONTENTS, num_yamyam_contents), MAX_ELEMENT_CONTENTS);
5406
5407   for (i = 0; i < num_yamyam_contents; i++)
5408   {
5409     for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
5410     {
5411       unsigned short word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5412       int element_dc = ((word & 0xff) << 8) | ((word >> 8) & 0xff);
5413
5414       if (i < MAX_ELEMENT_CONTENTS)
5415         level->yamyam_content[i].e[x][y] = getMappedElement_DC(element_dc);
5416     }
5417   }
5418
5419   fieldx = header[6] | (header[7] << 8);
5420   fieldy = header[8] | (header[9] << 8);
5421   level->fieldx = MIN(MAX(MIN_LEV_FIELDX, fieldx), MAX_LEV_FIELDX);
5422   level->fieldy = MIN(MAX(MIN_LEV_FIELDY, fieldy), MAX_LEV_FIELDY);
5423
5424   for (y = 0; y < fieldy; y++) for (x = 0; x < fieldx; x++)
5425   {
5426     unsigned short word = getDecodedWord_DC(getFile16BitBE(file), FALSE);
5427     int element_dc = ((word & 0xff) << 8) | ((word >> 8) & 0xff);
5428
5429     if (x < MAX_LEV_FIELDX && y < MAX_LEV_FIELDY)
5430       level->field[x][y] = getMappedElement_DC(element_dc);
5431   }
5432
5433   x = MIN(MAX(0, (header[10] | (header[11] << 8)) - 1), MAX_LEV_FIELDX - 1);
5434   y = MIN(MAX(0, (header[12] | (header[13] << 8)) - 1), MAX_LEV_FIELDY - 1);
5435   level->field[x][y] = EL_PLAYER_1;
5436
5437   x = MIN(MAX(0, (header[14] | (header[15] << 8)) - 1), MAX_LEV_FIELDX - 1);
5438   y = MIN(MAX(0, (header[16] | (header[17] << 8)) - 1), MAX_LEV_FIELDY - 1);
5439   level->field[x][y] = EL_PLAYER_2;
5440
5441   level->gems_needed            = header[18] | (header[19] << 8);
5442
5443   level->score[SC_EMERALD]      = header[20] | (header[21] << 8);
5444   level->score[SC_DIAMOND]      = header[22] | (header[23] << 8);
5445   level->score[SC_PEARL]        = header[24] | (header[25] << 8);
5446   level->score[SC_CRYSTAL]      = header[26] | (header[27] << 8);
5447   level->score[SC_NUT]          = header[28] | (header[29] << 8);
5448   level->score[SC_ROBOT]        = header[30] | (header[31] << 8);
5449   level->score[SC_SPACESHIP]    = header[32] | (header[33] << 8);
5450   level->score[SC_BUG]          = header[34] | (header[35] << 8);
5451   level->score[SC_YAMYAM]       = header[36] | (header[37] << 8);
5452   level->score[SC_DYNAMITE]     = header[38] | (header[39] << 8);
5453   level->score[SC_KEY]          = header[40] | (header[41] << 8);
5454   level->score[SC_TIME_BONUS]   = header[42] | (header[43] << 8);
5455
5456   level->time                   = header[44] | (header[45] << 8);
5457
5458   level->amoeba_speed           = header[46] | (header[47] << 8);
5459   level->time_light             = header[48] | (header[49] << 8);
5460   level->time_timegate          = header[50] | (header[51] << 8);
5461   level->time_wheel             = header[52] | (header[53] << 8);
5462   level->time_magic_wall        = header[54] | (header[55] << 8);
5463   level->extra_time             = header[56] | (header[57] << 8);
5464   level->shield_normal_time     = header[58] | (header[59] << 8);
5465
5466   /* Diamond Caves has the same (strange) behaviour as Emerald Mine that gems
5467      can slip down from flat walls, like normal walls and steel walls */
5468   level->em_slippery_gems = TRUE;
5469 }
5470
5471 static void LoadLevelFromFileInfo_DC(struct LevelInfo *level,
5472                                      struct LevelFileInfo *level_file_info,
5473                                      boolean level_info_only)
5474 {
5475   char *filename = level_file_info->filename;
5476   File *file;
5477   int num_magic_bytes = 8;
5478   char magic_bytes[num_magic_bytes + 1];
5479   int num_levels_to_skip = level_file_info->nr - leveldir_current->first_level;
5480
5481   if (!(file = openFile(filename, MODE_READ)))
5482   {
5483     level->no_valid_file = TRUE;
5484
5485     if (!level_info_only)
5486       Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
5487
5488     return;
5489   }
5490
5491   // fseek(file, 0x0000, SEEK_SET);
5492
5493   if (level_file_info->packed)
5494   {
5495     /* read "magic bytes" from start of file */
5496     if (getStringFromFile(file, magic_bytes, num_magic_bytes + 1) == NULL)
5497       magic_bytes[0] = '\0';
5498
5499     /* check "magic bytes" for correct file format */
5500     if (!strPrefix(magic_bytes, "DC2"))
5501     {
5502       level->no_valid_file = TRUE;
5503
5504       Error(ERR_WARN, "unknown DC level file '%s' -- using empty level",
5505             filename);
5506
5507       return;
5508     }
5509
5510     if (strPrefix(magic_bytes, "DC2Win95") ||
5511         strPrefix(magic_bytes, "DC2Win98"))
5512     {
5513       int position_first_level = 0x00fa;
5514       int extra_bytes = 4;
5515       int skip_bytes;
5516
5517       /* advance file stream to first level inside the level package */
5518       skip_bytes = position_first_level - num_magic_bytes - extra_bytes;
5519
5520       /* each block of level data is followed by block of non-level data */
5521       num_levels_to_skip *= 2;
5522
5523       /* at least skip header bytes, therefore use ">= 0" instead of "> 0" */
5524       while (num_levels_to_skip >= 0)
5525       {
5526         /* advance file stream to next level inside the level package */
5527         if (seekFile(file, skip_bytes, SEEK_CUR) != 0)
5528         {
5529           level->no_valid_file = TRUE;
5530
5531           Error(ERR_WARN, "cannot fseek in file '%s' -- using empty level",
5532                 filename);
5533
5534           return;
5535         }
5536
5537         /* skip apparently unused extra bytes following each level */
5538         ReadUnusedBytesFromFile(file, extra_bytes);
5539
5540         /* read size of next level in level package */
5541         skip_bytes = getFile32BitLE(file);
5542
5543         num_levels_to_skip--;
5544       }
5545     }
5546     else
5547     {
5548       level->no_valid_file = TRUE;
5549
5550       Error(ERR_WARN, "unknown DC2 level file '%s' -- using empty level",
5551             filename);
5552
5553       return;
5554     }
5555   }
5556
5557   LoadLevelFromFileStream_DC(file, level, level_file_info->nr);
5558
5559   closeFile(file);
5560 }
5561
5562
5563 /* ------------------------------------------------------------------------- */
5564 /* functions for loading SB level                                            */
5565 /* ------------------------------------------------------------------------- */
5566
5567 int getMappedElement_SB(int element_ascii, boolean use_ces)
5568 {
5569   static struct
5570   {
5571     int ascii;
5572     int sb;
5573     int ce;
5574   }
5575   sb_element_mapping[] =
5576   {
5577     { ' ', EL_EMPTY,                EL_CUSTOM_1 },  /* floor (space) */
5578     { '#', EL_STEELWALL,            EL_CUSTOM_2 },  /* wall */
5579     { '@', EL_PLAYER_1,             EL_CUSTOM_3 },  /* player */
5580     { '$', EL_SOKOBAN_OBJECT,       EL_CUSTOM_4 },  /* box */
5581     { '.', EL_SOKOBAN_FIELD_EMPTY,  EL_CUSTOM_5 },  /* goal square */
5582     { '*', EL_SOKOBAN_FIELD_FULL,   EL_CUSTOM_6 },  /* box on goal square */
5583     { '+', EL_SOKOBAN_FIELD_PLAYER, EL_CUSTOM_7 },  /* player on goal square */
5584     { '_', EL_INVISIBLE_STEELWALL,  EL_FROM_LEVEL_TEMPLATE },  /* floor beyond border */
5585
5586     { 0,   -1,                      -1          },
5587   };
5588
5589   int i;
5590
5591   for (i = 0; sb_element_mapping[i].ascii != 0; i++)
5592     if (element_ascii == sb_element_mapping[i].ascii)
5593       return (use_ces ? sb_element_mapping[i].ce : sb_element_mapping[i].sb);
5594
5595   return EL_UNDEFINED;
5596 }
5597
5598 static void LoadLevelFromFileInfo_SB(struct LevelInfo *level,
5599                                      struct LevelFileInfo *level_file_info,
5600                                      boolean level_info_only)
5601 {
5602   char *filename = level_file_info->filename;
5603   char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
5604   char last_comment[MAX_LINE_LEN];
5605   char level_name[MAX_LINE_LEN];
5606   char *line_ptr;
5607   File *file;
5608   int num_levels_to_skip = level_file_info->nr - leveldir_current->first_level;
5609   boolean read_continued_line = FALSE;
5610   boolean reading_playfield = FALSE;
5611   boolean got_valid_playfield_line = FALSE;
5612   boolean invalid_playfield_char = FALSE;
5613   boolean load_xsb_to_ces = check_special_flags("load_xsb_to_ces");
5614   int file_level_nr = 0;
5615   int line_nr = 0;
5616   int x = 0, y = 0;             /* initialized to make compilers happy */
5617
5618   last_comment[0] = '\0';
5619   level_name[0] = '\0';
5620
5621   if (!(file = openFile(filename, MODE_READ)))
5622   {
5623     level->no_valid_file = TRUE;
5624
5625     if (!level_info_only)
5626       Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
5627
5628     return;
5629   }
5630
5631   while (!checkEndOfFile(file))
5632   {
5633     /* level successfully read, but next level may follow here */
5634     if (!got_valid_playfield_line && reading_playfield)
5635     {
5636       /* read playfield from single level file -- skip remaining file */
5637       if (!level_file_info->packed)
5638         break;
5639
5640       if (file_level_nr >= num_levels_to_skip)
5641         break;
5642
5643       file_level_nr++;
5644
5645       last_comment[0] = '\0';
5646       level_name[0] = '\0';
5647
5648       reading_playfield = FALSE;
5649     }
5650
5651     got_valid_playfield_line = FALSE;
5652
5653     /* read next line of input file */
5654     if (!getStringFromFile(file, line, MAX_LINE_LEN))
5655       break;
5656
5657     /* check if line was completely read and is terminated by line break */
5658     if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
5659       line_nr++;
5660
5661     /* cut trailing line break (this can be newline and/or carriage return) */
5662     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
5663       if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
5664         *line_ptr = '\0';
5665
5666     /* copy raw input line for later use (mainly debugging output) */
5667     strcpy(line_raw, line);
5668
5669     if (read_continued_line)
5670     {
5671       /* append new line to existing line, if there is enough space */
5672       if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
5673         strcat(previous_line, line_ptr);
5674
5675       strcpy(line, previous_line);      /* copy storage buffer to line */
5676
5677       read_continued_line = FALSE;
5678     }
5679
5680     /* if the last character is '\', continue at next line */
5681     if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
5682     {
5683       line[strlen(line) - 1] = '\0';    /* cut off trailing backslash */
5684       strcpy(previous_line, line);      /* copy line to storage buffer */
5685
5686       read_continued_line = TRUE;
5687
5688       continue;
5689     }
5690
5691     /* skip empty lines */
5692     if (line[0] == '\0')
5693       continue;
5694
5695     /* extract comment text from comment line */
5696     if (line[0] == ';')
5697     {
5698       for (line_ptr = line; *line_ptr; line_ptr++)
5699         if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != ';')
5700           break;
5701
5702       strcpy(last_comment, line_ptr);
5703
5704       continue;
5705     }
5706
5707     /* extract level title text from line containing level title */
5708     if (line[0] == '\'')
5709     {
5710       strcpy(level_name, &line[1]);
5711
5712       if (strlen(level_name) > 0 && level_name[strlen(level_name) - 1] == '\'')
5713         level_name[strlen(level_name) - 1] = '\0';
5714
5715       continue;
5716     }
5717
5718     /* skip lines containing only spaces (or empty lines) */
5719     for (line_ptr = line; *line_ptr; line_ptr++)
5720       if (*line_ptr != ' ')
5721         break;
5722     if (*line_ptr == '\0')
5723       continue;
5724
5725     /* at this point, we have found a line containing part of a playfield */
5726
5727     got_valid_playfield_line = TRUE;
5728
5729     if (!reading_playfield)
5730     {
5731       reading_playfield = TRUE;
5732       invalid_playfield_char = FALSE;
5733
5734       for (x = 0; x < MAX_LEV_FIELDX; x++)
5735         for (y = 0; y < MAX_LEV_FIELDY; y++)
5736           level->field[x][y] = getMappedElement_SB(' ', load_xsb_to_ces);
5737
5738       level->fieldx = 0;
5739       level->fieldy = 0;
5740
5741       /* start with topmost tile row */
5742       y = 0;
5743     }
5744
5745     /* skip playfield line if larger row than allowed */
5746     if (y >= MAX_LEV_FIELDY)
5747       continue;
5748
5749     /* start with leftmost tile column */
5750     x = 0;
5751
5752     /* read playfield elements from line */
5753     for (line_ptr = line; *line_ptr; line_ptr++)
5754     {
5755       int mapped_sb_element = getMappedElement_SB(*line_ptr, load_xsb_to_ces);
5756
5757       /* stop parsing playfield line if larger column than allowed */
5758       if (x >= MAX_LEV_FIELDX)
5759         break;
5760
5761       if (mapped_sb_element == EL_UNDEFINED)
5762       {
5763         invalid_playfield_char = TRUE;
5764
5765         break;
5766       }
5767
5768       level->field[x][y] = mapped_sb_element;
5769
5770       /* continue with next tile column */
5771       x++;
5772
5773       level->fieldx = MAX(x, level->fieldx);
5774     }
5775
5776     if (invalid_playfield_char)
5777     {
5778       /* if first playfield line, treat invalid lines as comment lines */
5779       if (y == 0)
5780         reading_playfield = FALSE;
5781
5782       continue;
5783     }
5784
5785     /* continue with next tile row */
5786     y++;
5787   }
5788
5789   closeFile(file);
5790
5791   level->fieldy = y;
5792
5793   level->fieldx = MIN(MAX(MIN_LEV_FIELDX, level->fieldx), MAX_LEV_FIELDX);
5794   level->fieldy = MIN(MAX(MIN_LEV_FIELDY, level->fieldy), MAX_LEV_FIELDY);
5795
5796   if (!reading_playfield)
5797   {
5798     level->no_valid_file = TRUE;
5799
5800     Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
5801
5802     return;
5803   }
5804
5805   if (*level_name != '\0')
5806   {
5807     strncpy(level->name, level_name, MAX_LEVEL_NAME_LEN);
5808     level->name[MAX_LEVEL_NAME_LEN] = '\0';
5809   }
5810   else if (*last_comment != '\0')
5811   {
5812     strncpy(level->name, last_comment, MAX_LEVEL_NAME_LEN);
5813     level->name[MAX_LEVEL_NAME_LEN] = '\0';
5814   }
5815   else
5816   {
5817     sprintf(level->name, "--> Level %d <--", level_file_info->nr);
5818   }
5819
5820   /* set all empty fields beyond the border walls to invisible steel wall */
5821   for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
5822   {
5823     if ((x == 0 || x == level->fieldx - 1 ||
5824          y == 0 || y == level->fieldy - 1) &&
5825         level->field[x][y] == getMappedElement_SB(' ', load_xsb_to_ces))
5826       FloodFillLevel(x, y, getMappedElement_SB('_', load_xsb_to_ces),
5827                      level->field, level->fieldx, level->fieldy);
5828   }
5829
5830   /* set special level settings for Sokoban levels */
5831
5832   level->time = 0;
5833   level->use_step_counter = TRUE;
5834
5835   if (load_xsb_to_ces)
5836   {
5837     /* special global settings can now be set in level template */
5838
5839     level->use_custom_template = TRUE;
5840   }
5841 }
5842
5843
5844 /* ------------------------------------------------------------------------- */
5845 /* functions for handling native levels                                      */
5846 /* ------------------------------------------------------------------------- */
5847
5848 static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
5849                                      struct LevelFileInfo *level_file_info,
5850                                      boolean level_info_only)
5851 {
5852   if (!LoadNativeLevel_EM(level_file_info->filename, level_info_only))
5853     level->no_valid_file = TRUE;
5854 }
5855
5856 static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
5857                                      struct LevelFileInfo *level_file_info,
5858                                      boolean level_info_only)
5859 {
5860   int pos = 0;
5861
5862   /* determine position of requested level inside level package */
5863   if (level_file_info->packed)
5864     pos = level_file_info->nr - leveldir_current->first_level;
5865
5866   if (!LoadNativeLevel_SP(level_file_info->filename, pos, level_info_only))
5867     level->no_valid_file = TRUE;
5868 }
5869
5870 void CopyNativeLevel_RND_to_Native(struct LevelInfo *level)
5871 {
5872   if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
5873     CopyNativeLevel_RND_to_EM(level);
5874   else if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
5875     CopyNativeLevel_RND_to_SP(level);
5876 }
5877
5878 void CopyNativeLevel_Native_to_RND(struct LevelInfo *level)
5879 {
5880   if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
5881     CopyNativeLevel_EM_to_RND(level);
5882   else if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
5883     CopyNativeLevel_SP_to_RND(level);
5884 }
5885
5886 void SaveNativeLevel(struct LevelInfo *level)
5887 {
5888   if (level->game_engine_type == GAME_ENGINE_TYPE_SP)
5889   {
5890     char *basename = getSingleLevelBasenameExt(level->file_info.nr, "sp");
5891     char *filename = getLevelFilenameFromBasename(basename);
5892
5893     CopyNativeLevel_RND_to_SP(level);
5894     CopyNativeTape_RND_to_SP(level);
5895
5896     SaveNativeLevel_SP(filename);
5897   }
5898 }
5899
5900
5901 /* ------------------------------------------------------------------------- */
5902 /* functions for loading generic level                                       */
5903 /* ------------------------------------------------------------------------- */
5904
5905 static void LoadLevelFromFileInfo(struct LevelInfo *level,
5906                                   struct LevelFileInfo *level_file_info,
5907                                   boolean level_info_only)
5908 {
5909   /* always start with reliable default values */
5910   setLevelInfoToDefaults(level, level_info_only, TRUE);
5911
5912   switch (level_file_info->type)
5913   {
5914     case LEVEL_FILE_TYPE_RND:
5915       LoadLevelFromFileInfo_RND(level, level_file_info, level_info_only);
5916       break;
5917
5918     case LEVEL_FILE_TYPE_EM:
5919       LoadLevelFromFileInfo_EM(level, level_file_info, level_info_only);
5920       level->game_engine_type = GAME_ENGINE_TYPE_EM;
5921       break;
5922
5923     case LEVEL_FILE_TYPE_SP:
5924       LoadLevelFromFileInfo_SP(level, level_file_info, level_info_only);
5925       level->game_engine_type = GAME_ENGINE_TYPE_SP;
5926       break;
5927
5928     case LEVEL_FILE_TYPE_DC:
5929       LoadLevelFromFileInfo_DC(level, level_file_info, level_info_only);
5930       break;
5931
5932     case LEVEL_FILE_TYPE_SB:
5933       LoadLevelFromFileInfo_SB(level, level_file_info, level_info_only);
5934       break;
5935
5936     default:
5937       LoadLevelFromFileInfo_RND(level, level_file_info, level_info_only);
5938       break;
5939   }
5940
5941   /* if level file is invalid, restore level structure to default values */
5942   if (level->no_valid_file)
5943     setLevelInfoToDefaults(level, level_info_only, FALSE);
5944
5945   if (level->game_engine_type == GAME_ENGINE_TYPE_UNKNOWN)
5946     level->game_engine_type = GAME_ENGINE_TYPE_RND;
5947
5948   if (level_file_info->type != LEVEL_FILE_TYPE_RND)
5949     CopyNativeLevel_Native_to_RND(level);
5950 }
5951
5952 void LoadLevelFromFilename(struct LevelInfo *level, char *filename)
5953 {
5954   static struct LevelFileInfo level_file_info;
5955
5956   /* always start with reliable default values */
5957   setFileInfoToDefaults(&level_file_info);
5958
5959   level_file_info.nr = 0;                       /* unknown level number */
5960   level_file_info.type = LEVEL_FILE_TYPE_RND;   /* no others supported yet */
5961   level_file_info.filename = filename;
5962
5963   LoadLevelFromFileInfo(level, &level_file_info, FALSE);
5964 }
5965
5966 static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
5967 {
5968   int i, j;
5969
5970   if (leveldir_current == NULL)         /* only when dumping level */
5971     return;
5972
5973   /* all engine modifications also valid for levels which use latest engine */
5974   if (level->game_version < VERSION_IDENT(3,2,0,5))
5975   {
5976     /* time bonus score was given for 10 s instead of 1 s before 3.2.0-5 */
5977     level->score[SC_TIME_BONUS] /= 10;
5978   }
5979
5980   if (leveldir_current->latest_engine)
5981   {
5982     /* ---------- use latest game engine ----------------------------------- */
5983
5984     /* For all levels which are forced to use the latest game engine version
5985        (normally all but user contributed, private and undefined levels), set
5986        the game engine version to the actual version; this allows for actual
5987        corrections in the game engine to take effect for existing, converted
5988        levels (from "classic" or other existing games) to make the emulation
5989        of the corresponding game more accurate, while (hopefully) not breaking
5990        existing levels created from other players. */
5991
5992     level->game_version = GAME_VERSION_ACTUAL;
5993
5994     /* Set special EM style gems behaviour: EM style gems slip down from
5995        normal, steel and growing wall. As this is a more fundamental change,
5996        it seems better to set the default behaviour to "off" (as it is more
5997        natural) and make it configurable in the level editor (as a property
5998        of gem style elements). Already existing converted levels (neither
5999        private nor contributed levels) are changed to the new behaviour. */
6000
6001     if (level->file_version < FILE_VERSION_2_0)
6002       level->em_slippery_gems = TRUE;
6003
6004     return;
6005   }
6006
6007   /* ---------- use game engine the level was created with ----------------- */
6008
6009   /* For all levels which are not forced to use the latest game engine
6010      version (normally user contributed, private and undefined levels),
6011      use the version of the game engine the levels were created for.
6012
6013      Since 2.0.1, the game engine version is now directly stored
6014      in the level file (chunk "VERS"), so there is no need anymore
6015      to set the game version from the file version (except for old,
6016      pre-2.0 levels, where the game version is still taken from the
6017      file format version used to store the level -- see above). */
6018
6019   /* player was faster than enemies in 1.0.0 and before */
6020   if (level->file_version == FILE_VERSION_1_0)
6021     for (i = 0; i < MAX_PLAYERS; i++)
6022       level->initial_player_stepsize[i] = STEPSIZE_FAST;
6023
6024   /* default behaviour for EM style gems was "slippery" only in 2.0.1 */
6025   if (level->game_version == VERSION_IDENT(2,0,1,0))
6026     level->em_slippery_gems = TRUE;
6027
6028   /* springs could be pushed over pits before (pre-release version) 2.2.0 */
6029   if (level->game_version < VERSION_IDENT(2,2,0,0))
6030     level->use_spring_bug = TRUE;
6031
6032   if (level->game_version < VERSION_IDENT(3,2,0,5))
6033   {
6034     /* time orb caused limited time in endless time levels before 3.2.0-5 */
6035     level->use_time_orb_bug = TRUE;
6036
6037     /* default behaviour for snapping was "no snap delay" before 3.2.0-5 */
6038     level->block_snap_field = FALSE;
6039
6040     /* extra time score was same value as time left score before 3.2.0-5 */
6041     level->extra_time_score = level->score[SC_TIME_BONUS];
6042   }
6043
6044   if (level->game_version < VERSION_IDENT(3,2,0,7))
6045   {
6046     /* default behaviour for snapping was "not continuous" before 3.2.0-7 */
6047     level->continuous_snapping = FALSE;
6048   }
6049
6050   /* only few elements were able to actively move into acid before 3.1.0 */
6051   /* trigger settings did not exist before 3.1.0; set to default "any" */
6052   if (level->game_version < VERSION_IDENT(3,1,0,0))
6053   {
6054     /* correct "can move into acid" settings (all zero in old levels) */
6055
6056     level->can_move_into_acid_bits = 0; /* nothing can move into acid */
6057     level->dont_collide_with_bits = 0; /* nothing is deadly when colliding */
6058
6059     setMoveIntoAcidProperty(level, EL_ROBOT,     TRUE);
6060     setMoveIntoAcidProperty(level, EL_SATELLITE, TRUE);
6061     setMoveIntoAcidProperty(level, EL_PENGUIN,   TRUE);
6062     setMoveIntoAcidProperty(level, EL_BALLOON,   TRUE);
6063
6064     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6065       SET_PROPERTY(EL_CUSTOM_START + i, EP_CAN_MOVE_INTO_ACID, TRUE);
6066
6067     /* correct trigger settings (stored as zero == "none" in old levels) */
6068
6069     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6070     {
6071       int element = EL_CUSTOM_START + i;
6072       struct ElementInfo *ei = &element_info[element];
6073
6074       for (j = 0; j < ei->num_change_pages; j++)
6075       {
6076         struct ElementChangeInfo *change = &ei->change_page[j];
6077
6078         change->trigger_player = CH_PLAYER_ANY;
6079         change->trigger_page = CH_PAGE_ANY;
6080       }
6081     }
6082   }
6083
6084   /* try to detect and fix "Snake Bite" levels, which are broken with 3.2.0 */
6085   {
6086     int element = EL_CUSTOM_256;
6087     struct ElementInfo *ei = &element_info[element];
6088     struct ElementChangeInfo *change = &ei->change_page[0];
6089
6090     /* This is needed to fix a problem that was caused by a bugfix in function
6091        game.c/CreateFieldExt() introduced with 3.2.0 that corrects the behaviour
6092        when a custom element changes to EL_SOKOBAN_FIELD_PLAYER (before, it did
6093        not replace walkable elements, but instead just placed the player on it,
6094        without placing the Sokoban field under the player). Unfortunately, this
6095        breaks "Snake Bite" style levels when the snake is halfway through a door
6096        that just closes (the snake head is still alive and can be moved in this
6097        case). This can be fixed by replacing the EL_SOKOBAN_FIELD_PLAYER by the
6098        player (without Sokoban element) which then gets killed as designed). */
6099
6100     if ((strncmp(leveldir_current->identifier, "snake_bite", 10) == 0 ||
6101          strncmp(ei->description, "pause b4 death", 14) == 0) &&
6102         change->target_element == EL_SOKOBAN_FIELD_PLAYER)
6103       change->target_element = EL_PLAYER_1;
6104   }
6105
6106   /* try to detect and fix "Zelda" style levels, which are broken with 3.2.5 */
6107   if (level->game_version < VERSION_IDENT(3,2,5,0))
6108   {
6109     /* This is needed to fix a problem that was caused by a bugfix in function
6110        game.c/CheckTriggeredElementChangeExt() introduced with 3.2.5 that
6111        corrects the behaviour when a custom element changes to another custom
6112        element with a higher element number that has change actions defined.
6113        Normally, only one change per frame is allowed for custom elements.
6114        Therefore, it is checked if a custom element already changed in the
6115        current frame; if it did, subsequent changes are suppressed.
6116        Unfortunately, this is only checked for element changes, but not for
6117        change actions, which are still executed. As the function above loops
6118        through all custom elements from lower to higher, an element change
6119        resulting in a lower CE number won't be checked again, while a target
6120        element with a higher number will also be checked, and potential change
6121        actions will get executed for this CE, too (which is wrong), while
6122        further changes are ignored (which is correct). As this bugfix breaks
6123        Zelda II (and introduces graphical bugs to Zelda I, and also breaks a
6124        few other levels like Alan Bond's "FMV"), allow the previous, incorrect
6125        behaviour for existing levels and tapes that make use of this bug */
6126
6127     level->use_action_after_change_bug = TRUE;
6128   }
6129
6130   /* not centering level after relocating player was default only in 3.2.3 */
6131   if (level->game_version == VERSION_IDENT(3,2,3,0))    /* (no pre-releases) */
6132     level->shifted_relocation = TRUE;
6133
6134   /* EM style elements always chain-exploded in R'n'D engine before 3.2.6 */
6135   if (level->game_version < VERSION_IDENT(3,2,6,0))
6136     level->em_explodes_by_fire = TRUE;
6137 }
6138
6139 static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
6140 {
6141   int i, j, x, y;
6142
6143   /* map custom element change events that have changed in newer versions
6144      (these following values were accidentally changed in version 3.0.1)
6145      (this seems to be needed only for 'ab_levelset3' and 'ab_levelset4') */
6146   if (level->game_version <= VERSION_IDENT(3,0,0,0))
6147   {
6148     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6149     {
6150       int element = EL_CUSTOM_START + i;
6151
6152       /* order of checking and copying events to be mapped is important */
6153       /* (do not change the start and end value -- they are constant) */
6154       for (j = CE_BY_OTHER_ACTION; j >= CE_VALUE_GETS_ZERO; j--)
6155       {
6156         if (HAS_CHANGE_EVENT(element, j - 2))
6157         {
6158           SET_CHANGE_EVENT(element, j - 2, FALSE);
6159           SET_CHANGE_EVENT(element, j, TRUE);
6160         }
6161       }
6162
6163       /* order of checking and copying events to be mapped is important */
6164       /* (do not change the start and end value -- they are constant) */
6165       for (j = CE_PLAYER_COLLECTS_X; j >= CE_HITTING_SOMETHING; j--)
6166       {
6167         if (HAS_CHANGE_EVENT(element, j - 1))
6168         {
6169           SET_CHANGE_EVENT(element, j - 1, FALSE);
6170           SET_CHANGE_EVENT(element, j, TRUE);
6171         }
6172       }
6173     }
6174   }
6175
6176   /* initialize "can_change" field for old levels with only one change page */
6177   if (level->game_version <= VERSION_IDENT(3,0,2,0))
6178   {
6179     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6180     {
6181       int element = EL_CUSTOM_START + i;
6182
6183       if (CAN_CHANGE(element))
6184         element_info[element].change->can_change = TRUE;
6185     }
6186   }
6187
6188   /* correct custom element values (for old levels without these options) */
6189   if (level->game_version < VERSION_IDENT(3,1,1,0))
6190   {
6191     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6192     {
6193       int element = EL_CUSTOM_START + i;
6194       struct ElementInfo *ei = &element_info[element];
6195
6196       if (ei->access_direction == MV_NO_DIRECTION)
6197         ei->access_direction = MV_ALL_DIRECTIONS;
6198     }
6199   }
6200
6201   /* correct custom element values (fix invalid values for all versions) */
6202   if (1)
6203   {
6204     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6205     {
6206       int element = EL_CUSTOM_START + i;
6207       struct ElementInfo *ei = &element_info[element];
6208
6209       for (j = 0; j < ei->num_change_pages; j++)
6210       {
6211         struct ElementChangeInfo *change = &ei->change_page[j];
6212
6213         if (change->trigger_player == CH_PLAYER_NONE)
6214           change->trigger_player = CH_PLAYER_ANY;
6215
6216         if (change->trigger_side == CH_SIDE_NONE)
6217           change->trigger_side = CH_SIDE_ANY;
6218       }
6219     }
6220   }
6221
6222   /* initialize "can_explode" field for old levels which did not store this */
6223   /* !!! CHECK THIS -- "<= 3,1,0,0" IS PROBABLY WRONG !!! */
6224   if (level->game_version <= VERSION_IDENT(3,1,0,0))
6225   {
6226     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6227     {
6228       int element = EL_CUSTOM_START + i;
6229
6230       if (EXPLODES_1X1_OLD(element))
6231         element_info[element].explosion_type = EXPLODES_1X1;
6232
6233       SET_PROPERTY(element, EP_CAN_EXPLODE, (EXPLODES_BY_FIRE(element) ||
6234                                              EXPLODES_SMASHED(element) ||
6235                                              EXPLODES_IMPACT(element)));
6236     }
6237   }
6238
6239   /* correct previously hard-coded move delay values for maze runner style */
6240   if (level->game_version < VERSION_IDENT(3,1,1,0))
6241   {
6242     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6243     {
6244       int element = EL_CUSTOM_START + i;
6245
6246       if (element_info[element].move_pattern & MV_MAZE_RUNNER_STYLE)
6247       {
6248         /* previously hard-coded and therefore ignored */
6249         element_info[element].move_delay_fixed = 9;
6250         element_info[element].move_delay_random = 0;
6251       }
6252     }
6253   }
6254
6255   /* map elements that have changed in newer versions */
6256   level->amoeba_content = getMappedElementByVersion(level->amoeba_content,
6257                                                     level->game_version);
6258   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6259     for (x = 0; x < 3; x++)
6260       for (y = 0; y < 3; y++)
6261         level->yamyam_content[i].e[x][y] =
6262           getMappedElementByVersion(level->yamyam_content[i].e[x][y],
6263                                     level->game_version);
6264
6265   /* initialize element properties for level editor etc. */
6266   InitElementPropertiesEngine(level->game_version);
6267   InitElementPropertiesAfterLoading(level->game_version);
6268   InitElementPropertiesGfxElement();
6269 }
6270
6271 static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename)
6272 {
6273   int x, y;
6274
6275   /* map elements that have changed in newer versions */
6276   for (y = 0; y < level->fieldy; y++)
6277     for (x = 0; x < level->fieldx; x++)
6278       level->field[x][y] = getMappedElementByVersion(level->field[x][y],
6279                                                      level->game_version);
6280
6281   /* clear unused playfield data (nicer if level gets resized in editor) */
6282   for (x = 0; x < MAX_LEV_FIELDX; x++)
6283     for (y = 0; y < MAX_LEV_FIELDY; y++)
6284       if (x >= level->fieldx || y >= level->fieldy)
6285         level->field[x][y] = EL_EMPTY;
6286
6287   /* copy elements to runtime playfield array */
6288   for (x = 0; x < MAX_LEV_FIELDX; x++)
6289     for (y = 0; y < MAX_LEV_FIELDY; y++)
6290       Feld[x][y] = level->field[x][y];
6291
6292   /* initialize level size variables for faster access */
6293   lev_fieldx = level->fieldx;
6294   lev_fieldy = level->fieldy;
6295
6296   /* determine border element for this level */
6297   if (level->file_info.type == LEVEL_FILE_TYPE_DC)
6298     BorderElement = EL_EMPTY;   /* (in editor, SetBorderElement() is used) */
6299   else
6300     SetBorderElement();
6301 }
6302
6303 static void LoadLevel_InitNativeEngines(struct LevelInfo *level,char *filename)
6304 {
6305   struct LevelFileInfo *level_file_info = &level->file_info;
6306
6307   if (level_file_info->type == LEVEL_FILE_TYPE_RND)
6308     CopyNativeLevel_RND_to_Native(level);
6309 }
6310
6311 void LoadLevelTemplate(int nr)
6312 {
6313   char *filename;
6314
6315   setLevelFileInfo(&level_template.file_info, nr);
6316   filename = level_template.file_info.filename;
6317
6318   LoadLevelFromFileInfo(&level_template, &level_template.file_info, FALSE);
6319
6320   LoadLevel_InitVersion(&level_template, filename);
6321   LoadLevel_InitElements(&level_template, filename);
6322
6323   ActivateLevelTemplate();
6324 }
6325
6326 void LoadLevel(int nr)
6327 {
6328   char *filename;
6329
6330   setLevelFileInfo(&level.file_info, nr);
6331   filename = level.file_info.filename;
6332
6333   LoadLevelFromFileInfo(&level, &level.file_info, FALSE);
6334
6335   if (level.use_custom_template)
6336     LoadLevelTemplate(-1);
6337
6338   LoadLevel_InitVersion(&level, filename);
6339   LoadLevel_InitElements(&level, filename);
6340   LoadLevel_InitPlayfield(&level, filename);
6341
6342   LoadLevel_InitNativeEngines(&level, filename);
6343 }
6344
6345 void LoadLevelInfoOnly(int nr)
6346 {
6347   setLevelFileInfo(&level.file_info, nr);
6348
6349   LoadLevelFromFileInfo(&level, &level.file_info, TRUE);
6350 }
6351
6352 static int SaveLevel_VERS(FILE *file, struct LevelInfo *level)
6353 {
6354   int chunk_size = 0;
6355
6356   chunk_size += putFileVersion(file, level->file_version);
6357   chunk_size += putFileVersion(file, level->game_version);
6358
6359   return chunk_size;
6360 }
6361
6362 static int SaveLevel_DATE(FILE *file, struct LevelInfo *level)
6363 {
6364   int chunk_size = 0;
6365
6366   chunk_size += putFile16BitBE(file, level->creation_date.year);
6367   chunk_size += putFile8Bit(file,    level->creation_date.month);
6368   chunk_size += putFile8Bit(file,    level->creation_date.day);
6369
6370   return chunk_size;
6371 }
6372
6373 #if ENABLE_HISTORIC_CHUNKS
6374 static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
6375 {
6376   int i, x, y;
6377
6378   putFile8Bit(file, level->fieldx);
6379   putFile8Bit(file, level->fieldy);
6380
6381   putFile16BitBE(file, level->time);
6382   putFile16BitBE(file, level->gems_needed);
6383
6384   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
6385     putFile8Bit(file, level->name[i]);
6386
6387   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
6388     putFile8Bit(file, level->score[i]);
6389
6390   for (i = 0; i < STD_ELEMENT_CONTENTS; i++)
6391     for (y = 0; y < 3; y++)
6392       for (x = 0; x < 3; x++)
6393         putFile8Bit(file, (level->encoding_16bit_yamyam ? EL_EMPTY :
6394                            level->yamyam_content[i].e[x][y]));
6395   putFile8Bit(file, level->amoeba_speed);
6396   putFile8Bit(file, level->time_magic_wall);
6397   putFile8Bit(file, level->time_wheel);
6398   putFile8Bit(file, (level->encoding_16bit_amoeba ? EL_EMPTY :
6399                      level->amoeba_content));
6400   putFile8Bit(file, (level->initial_player_stepsize == STEPSIZE_FAST ? 1 : 0));
6401   putFile8Bit(file, (level->initial_gravity ? 1 : 0));
6402   putFile8Bit(file, (level->encoding_16bit_field ? 1 : 0));
6403   putFile8Bit(file, (level->em_slippery_gems ? 1 : 0));
6404
6405   putFile8Bit(file, (level->use_custom_template ? 1 : 0));
6406
6407   putFile8Bit(file, (level->block_last_field ? 1 : 0));
6408   putFile8Bit(file, (level->sp_block_last_field ? 1 : 0));
6409   putFile32BitBE(file, level->can_move_into_acid_bits);
6410   putFile8Bit(file, level->dont_collide_with_bits);
6411
6412   putFile8Bit(file, (level->use_spring_bug ? 1 : 0));
6413   putFile8Bit(file, (level->use_step_counter ? 1 : 0));
6414
6415   putFile8Bit(file, (level->instant_relocation ? 1 : 0));
6416   putFile8Bit(file, (level->can_pass_to_walkable ? 1 : 0));
6417   putFile8Bit(file, (level->grow_into_diggable ? 1 : 0));
6418
6419   putFile8Bit(file, level->game_engine_type);
6420
6421   WriteUnusedBytesToFile(file, LEVEL_CHUNK_HEAD_UNUSED);
6422 }
6423 #endif
6424
6425 static int SaveLevel_NAME(FILE *file, struct LevelInfo *level)
6426 {
6427   int chunk_size = 0;
6428   int i;
6429
6430   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
6431     chunk_size += putFile8Bit(file, level->name[i]);
6432
6433   return chunk_size;
6434 }
6435
6436 static int SaveLevel_AUTH(FILE *file, struct LevelInfo *level)
6437 {
6438   int chunk_size = 0;
6439   int i;
6440
6441   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
6442     chunk_size += putFile8Bit(file, level->author[i]);
6443
6444   return chunk_size;
6445 }
6446
6447 #if ENABLE_HISTORIC_CHUNKS
6448 static int SaveLevel_BODY(FILE *file, struct LevelInfo *level)
6449 {
6450   int chunk_size = 0;
6451   int x, y;
6452
6453   for (y = 0; y < level->fieldy; y++)
6454     for (x = 0; x < level->fieldx; x++)
6455       if (level->encoding_16bit_field)
6456         chunk_size += putFile16BitBE(file, level->field[x][y]);
6457       else
6458         chunk_size += putFile8Bit(file, level->field[x][y]);
6459
6460   return chunk_size;
6461 }
6462 #endif
6463
6464 static int SaveLevel_BODY(FILE *file, struct LevelInfo *level)
6465 {
6466   int chunk_size = 0;
6467   int x, y;
6468
6469   for (y = 0; y < level->fieldy; y++)
6470     for (x = 0; x < level->fieldx; x++)
6471       chunk_size += putFile16BitBE(file, level->field[x][y]);
6472
6473   return chunk_size;
6474 }
6475
6476 #if ENABLE_HISTORIC_CHUNKS
6477 static void SaveLevel_CONT(FILE *file, struct LevelInfo *level)
6478 {
6479   int i, x, y;
6480
6481   putFile8Bit(file, EL_YAMYAM);
6482   putFile8Bit(file, level->num_yamyam_contents);
6483   putFile8Bit(file, 0);
6484   putFile8Bit(file, 0);
6485
6486   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6487     for (y = 0; y < 3; y++)
6488       for (x = 0; x < 3; x++)
6489         if (level->encoding_16bit_field)
6490           putFile16BitBE(file, level->yamyam_content[i].e[x][y]);
6491         else
6492           putFile8Bit(file, level->yamyam_content[i].e[x][y]);
6493 }
6494 #endif
6495
6496 #if ENABLE_HISTORIC_CHUNKS
6497 static void SaveLevel_CNT2(FILE *file, struct LevelInfo *level, int element)
6498 {
6499   int i, x, y;
6500   int num_contents, content_xsize, content_ysize;
6501   int content_array[MAX_ELEMENT_CONTENTS][3][3];
6502
6503   if (element == EL_YAMYAM)
6504   {
6505     num_contents = level->num_yamyam_contents;
6506     content_xsize = 3;
6507     content_ysize = 3;
6508
6509     for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6510       for (y = 0; y < 3; y++)
6511         for (x = 0; x < 3; x++)
6512           content_array[i][x][y] = level->yamyam_content[i].e[x][y];
6513   }
6514   else if (element == EL_BD_AMOEBA)
6515   {
6516     num_contents = 1;
6517     content_xsize = 1;
6518     content_ysize = 1;
6519
6520     for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6521       for (y = 0; y < 3; y++)
6522         for (x = 0; x < 3; x++)
6523           content_array[i][x][y] = EL_EMPTY;
6524     content_array[0][0][0] = level->amoeba_content;
6525   }
6526   else
6527   {
6528     /* chunk header already written -- write empty chunk data */
6529     WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_SIZE);
6530
6531     Error(ERR_WARN, "cannot save content for element '%d'", element);
6532     return;
6533   }
6534
6535   putFile16BitBE(file, element);
6536   putFile8Bit(file, num_contents);
6537   putFile8Bit(file, content_xsize);
6538   putFile8Bit(file, content_ysize);
6539
6540   WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_UNUSED);
6541
6542   for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
6543     for (y = 0; y < 3; y++)
6544       for (x = 0; x < 3; x++)
6545         putFile16BitBE(file, content_array[i][x][y]);
6546 }
6547 #endif
6548
6549 #if ENABLE_HISTORIC_CHUNKS
6550 static int SaveLevel_CNT3(FILE *file, struct LevelInfo *level, int element)
6551 {
6552   int envelope_nr = element - EL_ENVELOPE_1;
6553   int envelope_len = strlen(level->envelope_text[envelope_nr]) + 1;
6554   int chunk_size = 0;
6555   int i;
6556
6557   chunk_size += putFile16BitBE(file, element);
6558   chunk_size += putFile16BitBE(file, envelope_len);
6559   chunk_size += putFile8Bit(file, level->envelope_xsize[envelope_nr]);
6560   chunk_size += putFile8Bit(file, level->envelope_ysize[envelope_nr]);
6561
6562   WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT3_UNUSED);
6563   chunk_size += LEVEL_CHUNK_CNT3_UNUSED;
6564
6565   for (i = 0; i < envelope_len; i++)
6566     chunk_size += putFile8Bit(file, level->envelope_text[envelope_nr][i]);
6567
6568   return chunk_size;
6569 }
6570 #endif
6571
6572 #if ENABLE_HISTORIC_CHUNKS
6573 static void SaveLevel_CUS1(FILE *file, struct LevelInfo *level,
6574                            int num_changed_custom_elements)
6575 {
6576   int i, check = 0;
6577
6578   putFile16BitBE(file, num_changed_custom_elements);
6579
6580   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6581   {
6582     int element = EL_CUSTOM_START + i;
6583
6584     struct ElementInfo *ei = &element_info[element];
6585
6586     if (ei->properties[EP_BITFIELD_BASE_NR] != EP_BITMASK_DEFAULT)
6587     {
6588       if (check < num_changed_custom_elements)
6589       {
6590         putFile16BitBE(file, element);
6591         putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
6592       }
6593
6594       check++;
6595     }
6596   }
6597
6598   if (check != num_changed_custom_elements)     /* should not happen */
6599     Error(ERR_WARN, "inconsistent number of custom element properties");
6600 }
6601 #endif
6602
6603 #if ENABLE_HISTORIC_CHUNKS
6604 static void SaveLevel_CUS2(FILE *file, struct LevelInfo *level,
6605                            int num_changed_custom_elements)
6606 {
6607   int i, check = 0;
6608
6609   putFile16BitBE(file, num_changed_custom_elements);
6610
6611   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
6612   {
6613     int element = EL_CUSTOM_START + i;
6614
6615     if (element_info[element].change->target_element != EL_EMPTY_SPACE)
6616     {
6617       if (check < num_changed_custom_elements)
6618       {
6619         putFile16BitBE(file, element);
6620         putFile16BitBE(file, element_info[element].change->target_element);
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 target elements");
6629 }
6630 #endif
6631
6632 #if ENABLE_HISTORIC_CHUNKS
6633 static void SaveLevel_CUS3(FILE *file, struct LevelInfo *level,
6634                            int num_changed_custom_elements)
6635 {
6636   int i, j, x, y, 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     struct ElementInfo *ei = &element_info[element];
6644
6645     if (ei->modified_settings)
6646     {
6647       if (check < num_changed_custom_elements)
6648       {
6649         putFile16BitBE(file, element);
6650
6651         for (j = 0; j < MAX_ELEMENT_NAME_LEN; j++)
6652           putFile8Bit(file, ei->description[j]);
6653
6654         putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
6655
6656         /* some free bytes for future properties and padding */
6657         WriteUnusedBytesToFile(file, 7);
6658
6659         putFile8Bit(file, ei->use_gfx_element);
6660         putFile16BitBE(file, ei->gfx_element_initial);
6661
6662         putFile8Bit(file, ei->collect_score_initial);
6663         putFile8Bit(file, ei->collect_count_initial);
6664
6665         putFile16BitBE(file, ei->push_delay_fixed);
6666         putFile16BitBE(file, ei->push_delay_random);
6667         putFile16BitBE(file, ei->move_delay_fixed);
6668         putFile16BitBE(file, ei->move_delay_random);
6669
6670         putFile16BitBE(file, ei->move_pattern);
6671         putFile8Bit(file, ei->move_direction_initial);
6672         putFile8Bit(file, ei->move_stepsize);
6673
6674         for (y = 0; y < 3; y++)
6675           for (x = 0; x < 3; x++)
6676             putFile16BitBE(file, ei->content.e[x][y]);
6677
6678         putFile32BitBE(file, ei->change->events);
6679
6680         putFile16BitBE(file, ei->change->target_element);
6681
6682         putFile16BitBE(file, ei->change->delay_fixed);
6683         putFile16BitBE(file, ei->change->delay_random);
6684         putFile16BitBE(file, ei->change->delay_frames);
6685
6686         putFile16BitBE(file, ei->change->initial_trigger_element);
6687
6688         putFile8Bit(file, ei->change->explode);
6689         putFile8Bit(file, ei->change->use_target_content);
6690         putFile8Bit(file, ei->change->only_if_complete);
6691         putFile8Bit(file, ei->change->use_random_replace);
6692
6693         putFile8Bit(file, ei->change->random_percentage);
6694         putFile8Bit(file, ei->change->replace_when);
6695
6696         for (y = 0; y < 3; y++)
6697           for (x = 0; x < 3; x++)
6698             putFile16BitBE(file, ei->change->content.e[x][y]);
6699
6700         putFile8Bit(file, ei->slippery_type);
6701
6702         /* some free bytes for future properties and padding */
6703         WriteUnusedBytesToFile(file, LEVEL_CPART_CUS3_UNUSED);
6704       }
6705
6706       check++;
6707     }
6708   }
6709
6710   if (check != num_changed_custom_elements)     /* should not happen */
6711     Error(ERR_WARN, "inconsistent number of custom element properties");
6712 }
6713 #endif
6714
6715 #if ENABLE_HISTORIC_CHUNKS
6716 static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
6717 {
6718   struct ElementInfo *ei = &element_info[element];
6719   int i, j, x, y;
6720
6721   /* ---------- custom element base property values (96 bytes) ------------- */
6722
6723   putFile16BitBE(file, element);
6724
6725   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
6726     putFile8Bit(file, ei->description[i]);
6727
6728   putFile32BitBE(file, ei->properties[EP_BITFIELD_BASE_NR]);
6729
6730   WriteUnusedBytesToFile(file, 4);      /* reserved for more base properties */
6731
6732   putFile8Bit(file, ei->num_change_pages);
6733
6734   putFile16BitBE(file, ei->ce_value_fixed_initial);
6735   putFile16BitBE(file, ei->ce_value_random_initial);
6736   putFile8Bit(file, ei->use_last_ce_value);
6737
6738   putFile8Bit(file, ei->use_gfx_element);
6739   putFile16BitBE(file, ei->gfx_element_initial);
6740
6741   putFile8Bit(file, ei->collect_score_initial);
6742   putFile8Bit(file, ei->collect_count_initial);
6743
6744   putFile8Bit(file, ei->drop_delay_fixed);
6745   putFile8Bit(file, ei->push_delay_fixed);
6746   putFile8Bit(file, ei->drop_delay_random);
6747   putFile8Bit(file, ei->push_delay_random);
6748   putFile16BitBE(file, ei->move_delay_fixed);
6749   putFile16BitBE(file, ei->move_delay_random);
6750
6751   /* bits 0 - 15 of "move_pattern" ... */
6752   putFile16BitBE(file, ei->move_pattern & 0xffff);
6753   putFile8Bit(file, ei->move_direction_initial);
6754   putFile8Bit(file, ei->move_stepsize);
6755
6756   putFile8Bit(file, ei->slippery_type);
6757
6758   for (y = 0; y < 3; y++)
6759     for (x = 0; x < 3; x++)
6760       putFile16BitBE(file, ei->content.e[x][y]);
6761
6762   putFile16BitBE(file, ei->move_enter_element);
6763   putFile16BitBE(file, ei->move_leave_element);
6764   putFile8Bit(file, ei->move_leave_type);
6765
6766   /* ... bits 16 - 31 of "move_pattern" (not nice, but downward compatible) */
6767   putFile16BitBE(file, (ei->move_pattern >> 16) & 0xffff);
6768
6769   putFile8Bit(file, ei->access_direction);
6770
6771   putFile8Bit(file, ei->explosion_delay);
6772   putFile8Bit(file, ei->ignition_delay);
6773   putFile8Bit(file, ei->explosion_type);
6774
6775   /* some free bytes for future custom property values and padding */
6776   WriteUnusedBytesToFile(file, 1);
6777
6778   /* ---------- change page property values (48 bytes) --------------------- */
6779
6780   for (i = 0; i < ei->num_change_pages; i++)
6781   {
6782     struct ElementChangeInfo *change = &ei->change_page[i];
6783     unsigned int event_bits;
6784
6785     /* bits 0 - 31 of "has_event[]" ... */
6786     event_bits = 0;
6787     for (j = 0; j < MIN(NUM_CHANGE_EVENTS, 32); j++)
6788       if (change->has_event[j])
6789         event_bits |= (1 << j);
6790     putFile32BitBE(file, event_bits);
6791
6792     putFile16BitBE(file, change->target_element);
6793
6794     putFile16BitBE(file, change->delay_fixed);
6795     putFile16BitBE(file, change->delay_random);
6796     putFile16BitBE(file, change->delay_frames);
6797
6798     putFile16BitBE(file, change->initial_trigger_element);
6799
6800     putFile8Bit(file, change->explode);
6801     putFile8Bit(file, change->use_target_content);
6802     putFile8Bit(file, change->only_if_complete);
6803     putFile8Bit(file, change->use_random_replace);
6804
6805     putFile8Bit(file, change->random_percentage);
6806     putFile8Bit(file, change->replace_when);
6807
6808     for (y = 0; y < 3; y++)
6809       for (x = 0; x < 3; x++)
6810         putFile16BitBE(file, change->target_content.e[x][y]);
6811
6812     putFile8Bit(file, change->can_change);
6813
6814     putFile8Bit(file, change->trigger_side);
6815
6816     putFile8Bit(file, change->trigger_player);
6817     putFile8Bit(file, (change->trigger_page == CH_PAGE_ANY ? CH_PAGE_ANY_FILE :
6818                        log_2(change->trigger_page)));
6819
6820     putFile8Bit(file, change->has_action);
6821     putFile8Bit(file, change->action_type);
6822     putFile8Bit(file, change->action_mode);
6823     putFile16BitBE(file, change->action_arg);
6824
6825     /* ... bits 32 - 39 of "has_event[]" (not nice, but downward compatible) */
6826     event_bits = 0;
6827     for (j = 32; j < NUM_CHANGE_EVENTS; j++)
6828       if (change->has_event[j])
6829         event_bits |= (1 << (j - 32));
6830     putFile8Bit(file, event_bits);
6831   }
6832 }
6833 #endif
6834
6835 #if ENABLE_HISTORIC_CHUNKS
6836 static void SaveLevel_GRP1(FILE *file, struct LevelInfo *level, int element)
6837 {
6838   struct ElementInfo *ei = &element_info[element];
6839   struct ElementGroupInfo *group = ei->group;
6840   int i;
6841
6842   putFile16BitBE(file, element);
6843
6844   for (i = 0; i < MAX_ELEMENT_NAME_LEN; i++)
6845     putFile8Bit(file, ei->description[i]);
6846
6847   putFile8Bit(file, group->num_elements);
6848
6849   putFile8Bit(file, ei->use_gfx_element);
6850   putFile16BitBE(file, ei->gfx_element_initial);
6851
6852   putFile8Bit(file, group->choice_mode);
6853
6854   /* some free bytes for future values and padding */
6855   WriteUnusedBytesToFile(file, 3);
6856
6857   for (i = 0; i < MAX_ELEMENTS_IN_GROUP; i++)
6858     putFile16BitBE(file, group->element[i]);
6859 }
6860 #endif
6861
6862 static int SaveLevel_MicroChunk(FILE *file, struct LevelFileConfigInfo *entry,
6863                                 boolean write_element)
6864 {
6865   int save_type = entry->save_type;
6866   int data_type = entry->data_type;
6867   int conf_type = entry->conf_type;
6868   int byte_mask = conf_type & CONF_MASK_BYTES;
6869   int element = entry->element;
6870   int default_value = entry->default_value;
6871   int num_bytes = 0;
6872   boolean modified = FALSE;
6873
6874   if (byte_mask != CONF_MASK_MULTI_BYTES)
6875   {
6876     void *value_ptr = entry->value;
6877     int value = (data_type == TYPE_BOOLEAN ? *(boolean *)value_ptr :
6878                  *(int *)value_ptr);
6879
6880     /* check if any settings have been modified before saving them */
6881     if (value != default_value)
6882       modified = TRUE;
6883
6884     /* do not save if explicitly told or if unmodified default settings */
6885     if ((save_type == SAVE_CONF_NEVER) ||
6886         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6887       return 0;
6888
6889     if (write_element)
6890       num_bytes += putFile16BitBE(file, element);
6891
6892     num_bytes += putFile8Bit(file, conf_type);
6893     num_bytes += (byte_mask == CONF_MASK_1_BYTE ? putFile8Bit   (file, value) :
6894                   byte_mask == CONF_MASK_2_BYTE ? putFile16BitBE(file, value) :
6895                   byte_mask == CONF_MASK_4_BYTE ? putFile32BitBE(file, value) :
6896                   0);
6897   }
6898   else if (data_type == TYPE_STRING)
6899   {
6900     char *default_string = entry->default_string;
6901     char *string = (char *)(entry->value);
6902     int string_length = strlen(string);
6903     int i;
6904
6905     /* check if any settings have been modified before saving them */
6906     if (!strEqual(string, default_string))
6907       modified = TRUE;
6908
6909     /* do not save if explicitly told or if unmodified default settings */
6910     if ((save_type == SAVE_CONF_NEVER) ||
6911         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6912       return 0;
6913
6914     if (write_element)
6915       num_bytes += putFile16BitBE(file, element);
6916
6917     num_bytes += putFile8Bit(file, conf_type);
6918     num_bytes += putFile16BitBE(file, string_length);
6919
6920     for (i = 0; i < string_length; i++)
6921       num_bytes += putFile8Bit(file, string[i]);
6922   }
6923   else if (data_type == TYPE_ELEMENT_LIST)
6924   {
6925     int *element_array = (int *)(entry->value);
6926     int num_elements = *(int *)(entry->num_entities);
6927     int i;
6928
6929     /* check if any settings have been modified before saving them */
6930     for (i = 0; i < num_elements; i++)
6931       if (element_array[i] != default_value)
6932         modified = TRUE;
6933
6934     /* do not save if explicitly told or if unmodified default settings */
6935     if ((save_type == SAVE_CONF_NEVER) ||
6936         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6937       return 0;
6938
6939     if (write_element)
6940       num_bytes += putFile16BitBE(file, element);
6941
6942     num_bytes += putFile8Bit(file, conf_type);
6943     num_bytes += putFile16BitBE(file, num_elements * CONF_ELEMENT_NUM_BYTES);
6944
6945     for (i = 0; i < num_elements; i++)
6946       num_bytes += putFile16BitBE(file, element_array[i]);
6947   }
6948   else if (data_type == TYPE_CONTENT_LIST)
6949   {
6950     struct Content *content = (struct Content *)(entry->value);
6951     int num_contents = *(int *)(entry->num_entities);
6952     int i, x, y;
6953
6954     /* check if any settings have been modified before saving them */
6955     for (i = 0; i < num_contents; i++)
6956       for (y = 0; y < 3; y++)
6957         for (x = 0; x < 3; x++)
6958           if (content[i].e[x][y] != default_value)
6959             modified = TRUE;
6960
6961     /* do not save if explicitly told or if unmodified default settings */
6962     if ((save_type == SAVE_CONF_NEVER) ||
6963         (save_type == SAVE_CONF_WHEN_CHANGED && !modified))
6964       return 0;
6965
6966     if (write_element)
6967       num_bytes += putFile16BitBE(file, element);
6968
6969     num_bytes += putFile8Bit(file, conf_type);
6970     num_bytes += putFile16BitBE(file, num_contents * CONF_CONTENT_NUM_BYTES);
6971
6972     for (i = 0; i < num_contents; i++)
6973       for (y = 0; y < 3; y++)
6974         for (x = 0; x < 3; x++)
6975           num_bytes += putFile16BitBE(file, content[i].e[x][y]);
6976   }
6977
6978   return num_bytes;
6979 }
6980
6981 static int SaveLevel_INFO(FILE *file, struct LevelInfo *level)
6982 {
6983   int chunk_size = 0;
6984   int i;
6985
6986   li = *level;          /* copy level data into temporary buffer */
6987
6988   for (i = 0; chunk_config_INFO[i].data_type != -1; i++)
6989     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_INFO[i], FALSE);
6990
6991   return chunk_size;
6992 }
6993
6994 static int SaveLevel_ELEM(FILE *file, struct LevelInfo *level)
6995 {
6996   int chunk_size = 0;
6997   int i;
6998
6999   li = *level;          /* copy level data into temporary buffer */
7000
7001   for (i = 0; chunk_config_ELEM[i].data_type != -1; i++)
7002     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_ELEM[i], TRUE);
7003
7004   return chunk_size;
7005 }
7006
7007 static int SaveLevel_NOTE(FILE *file, struct LevelInfo *level, int element)
7008 {
7009   int envelope_nr = element - EL_ENVELOPE_1;
7010   int chunk_size = 0;
7011   int i;
7012
7013   chunk_size += putFile16BitBE(file, element);
7014
7015   /* copy envelope data into temporary buffer */
7016   xx_envelope = level->envelope[envelope_nr];
7017
7018   for (i = 0; chunk_config_NOTE[i].data_type != -1; i++)
7019     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_NOTE[i], FALSE);
7020
7021   return chunk_size;
7022 }
7023
7024 static int SaveLevel_CUSX(FILE *file, struct LevelInfo *level, int element)
7025 {
7026   struct ElementInfo *ei = &element_info[element];
7027   int chunk_size = 0;
7028   int i, j;
7029
7030   chunk_size += putFile16BitBE(file, element);
7031
7032   xx_ei = *ei;          /* copy element data into temporary buffer */
7033
7034   /* set default description string for this specific element */
7035   strcpy(xx_default_description, getDefaultElementDescription(ei));
7036
7037   for (i = 0; chunk_config_CUSX_base[i].data_type != -1; i++)
7038     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_CUSX_base[i], FALSE);
7039
7040   for (i = 0; i < ei->num_change_pages; i++)
7041   {
7042     struct ElementChangeInfo *change = &ei->change_page[i];
7043
7044     xx_current_change_page = i;
7045
7046     xx_change = *change;        /* copy change data into temporary buffer */
7047
7048     resetEventBits();
7049     setEventBitsFromEventFlags(change);
7050
7051     for (j = 0; chunk_config_CUSX_change[j].data_type != -1; j++)
7052       chunk_size += SaveLevel_MicroChunk(file, &chunk_config_CUSX_change[j],
7053                                          FALSE);
7054   }
7055
7056   return chunk_size;
7057 }
7058
7059 static int SaveLevel_GRPX(FILE *file, struct LevelInfo *level, int element)
7060 {
7061   struct ElementInfo *ei = &element_info[element];
7062   struct ElementGroupInfo *group = ei->group;
7063   int chunk_size = 0;
7064   int i;
7065
7066   chunk_size += putFile16BitBE(file, element);
7067
7068   xx_ei = *ei;          /* copy element data into temporary buffer */
7069   xx_group = *group;    /* copy group data into temporary buffer */
7070
7071   /* set default description string for this specific element */
7072   strcpy(xx_default_description, getDefaultElementDescription(ei));
7073
7074   for (i = 0; chunk_config_GRPX[i].data_type != -1; i++)
7075     chunk_size += SaveLevel_MicroChunk(file, &chunk_config_GRPX[i], FALSE);
7076
7077   return chunk_size;
7078 }
7079
7080 static void SaveLevelFromFilename(struct LevelInfo *level, char *filename,
7081                                   boolean save_as_template)
7082 {
7083   int chunk_size;
7084   int i;
7085   FILE *file;
7086
7087   if (!(file = fopen(filename, MODE_WRITE)))
7088   {
7089     Error(ERR_WARN, "cannot save level file '%s'", filename);
7090     return;
7091   }
7092
7093   level->file_version = FILE_VERSION_ACTUAL;
7094   level->game_version = GAME_VERSION_ACTUAL;
7095
7096   level->creation_date = getCurrentDate();
7097
7098   putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
7099   putFileChunkBE(file, "CAVE", CHUNK_SIZE_NONE);
7100
7101   chunk_size = SaveLevel_VERS(NULL, level);
7102   putFileChunkBE(file, "VERS", chunk_size);
7103   SaveLevel_VERS(file, level);
7104
7105   chunk_size = SaveLevel_DATE(NULL, level);
7106   putFileChunkBE(file, "DATE", chunk_size);
7107   SaveLevel_DATE(file, level);
7108
7109   chunk_size = SaveLevel_NAME(NULL, level);
7110   putFileChunkBE(file, "NAME", chunk_size);
7111   SaveLevel_NAME(file, level);
7112
7113   chunk_size = SaveLevel_AUTH(NULL, level);
7114   putFileChunkBE(file, "AUTH", chunk_size);
7115   SaveLevel_AUTH(file, level);
7116
7117   chunk_size = SaveLevel_INFO(NULL, level);
7118   putFileChunkBE(file, "INFO", chunk_size);
7119   SaveLevel_INFO(file, level);
7120
7121   chunk_size = SaveLevel_BODY(NULL, level);
7122   putFileChunkBE(file, "BODY", chunk_size);
7123   SaveLevel_BODY(file, level);
7124
7125   chunk_size = SaveLevel_ELEM(NULL, level);
7126   if (chunk_size > LEVEL_CHUNK_ELEM_UNCHANGED)          /* save if changed */
7127   {
7128     putFileChunkBE(file, "ELEM", chunk_size);
7129     SaveLevel_ELEM(file, level);
7130   }
7131
7132   for (i = 0; i < NUM_ENVELOPES; i++)
7133   {
7134     int element = EL_ENVELOPE_1 + i;
7135
7136     chunk_size = SaveLevel_NOTE(NULL, level, element);
7137     if (chunk_size > LEVEL_CHUNK_NOTE_UNCHANGED)        /* save if changed */
7138     {
7139       putFileChunkBE(file, "NOTE", chunk_size);
7140       SaveLevel_NOTE(file, level, element);
7141     }
7142   }
7143
7144   /* if not using template level, check for non-default custom/group elements */
7145   if (!level->use_custom_template || save_as_template)
7146   {
7147     for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7148     {
7149       int element = EL_CUSTOM_START + i;
7150
7151       chunk_size = SaveLevel_CUSX(NULL, level, element);
7152       if (chunk_size > LEVEL_CHUNK_CUSX_UNCHANGED)      /* save if changed */
7153       {
7154         putFileChunkBE(file, "CUSX", chunk_size);
7155         SaveLevel_CUSX(file, level, element);
7156       }
7157     }
7158
7159     for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
7160     {
7161       int element = EL_GROUP_START + i;
7162
7163       chunk_size = SaveLevel_GRPX(NULL, level, element);
7164       if (chunk_size > LEVEL_CHUNK_GRPX_UNCHANGED)      /* save if changed */
7165       {
7166         putFileChunkBE(file, "GRPX", chunk_size);
7167         SaveLevel_GRPX(file, level, element);
7168       }
7169     }
7170   }
7171
7172   fclose(file);
7173
7174   SetFilePermissions(filename, PERMS_PRIVATE);
7175 }
7176
7177 void SaveLevel(int nr)
7178 {
7179   char *filename = getDefaultLevelFilename(nr);
7180
7181   SaveLevelFromFilename(&level, filename, FALSE);
7182 }
7183
7184 void SaveLevelTemplate()
7185 {
7186   char *filename = getLocalLevelTemplateFilename();
7187
7188   SaveLevelFromFilename(&level, filename, TRUE);
7189 }
7190
7191 boolean SaveLevelChecked(int nr)
7192 {
7193   char *filename = getDefaultLevelFilename(nr);
7194   boolean new_level = !fileExists(filename);
7195   boolean level_saved = FALSE;
7196
7197   if (new_level || Request("Save this level and kill the old?", REQ_ASK))
7198   {
7199     SaveLevel(nr);
7200
7201     if (new_level)
7202       Request("Level saved!", REQ_CONFIRM);
7203
7204     level_saved = TRUE;
7205   }
7206
7207   return level_saved;
7208 }
7209
7210 void DumpLevel(struct LevelInfo *level)
7211 {
7212   if (level->no_level_file || level->no_valid_file)
7213   {
7214     Error(ERR_WARN, "cannot dump -- no valid level file found");
7215
7216     return;
7217   }
7218
7219   PrintLine("-", 79);
7220   Print("Level xxx (file version %08d, game version %08d)\n",
7221         level->file_version, level->game_version);
7222   PrintLine("-", 79);
7223
7224   Print("Level author: '%s'\n", level->author);
7225   Print("Level title:  '%s'\n", level->name);
7226   Print("\n");
7227   Print("Playfield size: %d x %d\n", level->fieldx, level->fieldy);
7228   Print("\n");
7229   Print("Level time:  %d seconds\n", level->time);
7230   Print("Gems needed: %d\n", level->gems_needed);
7231   Print("\n");
7232   Print("Time for magic wall: %d seconds\n", level->time_magic_wall);
7233   Print("Time for wheel:      %d seconds\n", level->time_wheel);
7234   Print("Time for light:      %d seconds\n", level->time_light);
7235   Print("Time for timegate:   %d seconds\n", level->time_timegate);
7236   Print("\n");
7237   Print("Amoeba speed: %d\n", level->amoeba_speed);
7238   Print("\n");
7239
7240   Print("EM style slippery gems:      %s\n", (level->em_slippery_gems ? "yes" : "no"));
7241   Print("Player blocks last field:    %s\n", (level->block_last_field ? "yes" : "no"));
7242   Print("SP player blocks last field: %s\n", (level->sp_block_last_field ? "yes" : "no"));
7243   Print("use spring bug: %s\n", (level->use_spring_bug ? "yes" : "no"));
7244   Print("use step counter: %s\n", (level->use_step_counter ? "yes" : "no"));
7245
7246   PrintLine("-", 79);
7247 }
7248
7249
7250 /* ========================================================================= */
7251 /* tape file functions                                                       */
7252 /* ========================================================================= */
7253
7254 static void setTapeInfoToDefaults()
7255 {
7256   int i;
7257
7258   /* always start with reliable default values (empty tape) */
7259   TapeErase();
7260
7261   /* default values (also for pre-1.2 tapes) with only the first player */
7262   tape.player_participates[0] = TRUE;
7263   for (i = 1; i < MAX_PLAYERS; i++)
7264     tape.player_participates[i] = FALSE;
7265
7266   /* at least one (default: the first) player participates in every tape */
7267   tape.num_participating_players = 1;
7268
7269   tape.level_nr = level_nr;
7270   tape.counter = 0;
7271   tape.changed = FALSE;
7272
7273   tape.recording = FALSE;
7274   tape.playing = FALSE;
7275   tape.pausing = FALSE;
7276
7277   tape.no_valid_file = FALSE;
7278 }
7279
7280 static int LoadTape_VERS(File *file, int chunk_size, struct TapeInfo *tape)
7281 {
7282   tape->file_version = getFileVersion(file);
7283   tape->game_version = getFileVersion(file);
7284
7285   return chunk_size;
7286 }
7287
7288 static int LoadTape_HEAD(File *file, int chunk_size, struct TapeInfo *tape)
7289 {
7290   int i;
7291
7292   tape->random_seed = getFile32BitBE(file);
7293   tape->date        = getFile32BitBE(file);
7294   tape->length      = getFile32BitBE(file);
7295
7296   /* read header fields that are new since version 1.2 */
7297   if (tape->file_version >= FILE_VERSION_1_2)
7298   {
7299     byte store_participating_players = getFile8Bit(file);
7300     int engine_version;
7301
7302     /* since version 1.2, tapes store which players participate in the tape */
7303     tape->num_participating_players = 0;
7304     for (i = 0; i < MAX_PLAYERS; i++)
7305     {
7306       tape->player_participates[i] = FALSE;
7307
7308       if (store_participating_players & (1 << i))
7309       {
7310         tape->player_participates[i] = TRUE;
7311         tape->num_participating_players++;
7312       }
7313     }
7314
7315     ReadUnusedBytesFromFile(file, TAPE_CHUNK_HEAD_UNUSED);
7316
7317     engine_version = getFileVersion(file);
7318     if (engine_version > 0)
7319       tape->engine_version = engine_version;
7320     else
7321       tape->engine_version = tape->game_version;
7322   }
7323
7324   return chunk_size;
7325 }
7326
7327 static int LoadTape_INFO(File *file, int chunk_size, struct TapeInfo *tape)
7328 {
7329   int level_identifier_size;
7330   int i;
7331
7332   level_identifier_size = getFile16BitBE(file);
7333
7334   tape->level_identifier =
7335     checked_realloc(tape->level_identifier, level_identifier_size);
7336
7337   for (i = 0; i < level_identifier_size; i++)
7338     tape->level_identifier[i] = getFile8Bit(file);
7339
7340   tape->level_nr = getFile16BitBE(file);
7341
7342   chunk_size = 2 + level_identifier_size + 2;
7343
7344   return chunk_size;
7345 }
7346
7347 static int LoadTape_BODY(File *file, int chunk_size, struct TapeInfo *tape)
7348 {
7349   int i, j;
7350   int chunk_size_expected =
7351     (tape->num_participating_players + 1) * tape->length;
7352
7353   if (chunk_size_expected != chunk_size)
7354   {
7355     ReadUnusedBytesFromFile(file, chunk_size);
7356     return chunk_size_expected;
7357   }
7358
7359   for (i = 0; i < tape->length; i++)
7360   {
7361     if (i >= MAX_TAPE_LEN)
7362       break;
7363
7364     for (j = 0; j < MAX_PLAYERS; j++)
7365     {
7366       tape->pos[i].action[j] = MV_NONE;
7367
7368       if (tape->player_participates[j])
7369         tape->pos[i].action[j] = getFile8Bit(file);
7370     }
7371
7372     tape->pos[i].delay = getFile8Bit(file);
7373
7374     if (tape->file_version == FILE_VERSION_1_0)
7375     {
7376       /* eliminate possible diagonal moves in old tapes */
7377       /* this is only for backward compatibility */
7378
7379       byte joy_dir[4] = { JOY_LEFT, JOY_RIGHT, JOY_UP, JOY_DOWN };
7380       byte action = tape->pos[i].action[0];
7381       int k, num_moves = 0;
7382
7383       for (k = 0; k<4; k++)
7384       {
7385         if (action & joy_dir[k])
7386         {
7387           tape->pos[i + num_moves].action[0] = joy_dir[k];
7388           if (num_moves > 0)
7389             tape->pos[i + num_moves].delay = 0;
7390           num_moves++;
7391         }
7392       }
7393
7394       if (num_moves > 1)
7395       {
7396         num_moves--;
7397         i += num_moves;
7398         tape->length += num_moves;
7399       }
7400     }
7401     else if (tape->file_version < FILE_VERSION_2_0)
7402     {
7403       /* convert pre-2.0 tapes to new tape format */
7404
7405       if (tape->pos[i].delay > 1)
7406       {
7407         /* action part */
7408         tape->pos[i + 1] = tape->pos[i];
7409         tape->pos[i + 1].delay = 1;
7410
7411         /* delay part */
7412         for (j = 0; j < MAX_PLAYERS; j++)
7413           tape->pos[i].action[j] = MV_NONE;
7414         tape->pos[i].delay--;
7415
7416         i++;
7417         tape->length++;
7418       }
7419     }
7420
7421     if (checkEndOfFile(file))
7422       break;
7423   }
7424
7425   if (i != tape->length)
7426     chunk_size = (tape->num_participating_players + 1) * i;
7427
7428   return chunk_size;
7429 }
7430
7431 void LoadTape_SokobanSolution(char *filename)
7432 {
7433   File *file;
7434   int move_delay = TILESIZE / level.initial_player_stepsize[0];
7435
7436   if (!(file = openFile(filename, MODE_READ)))
7437   {
7438     tape.no_valid_file = TRUE;
7439
7440     return;
7441   }
7442
7443   while (!checkEndOfFile(file))
7444   {
7445     unsigned char c = getByteFromFile(file);
7446
7447     if (checkEndOfFile(file))
7448       break;
7449
7450     switch (c)
7451     {
7452       case 'u':
7453       case 'U':
7454         tape.pos[tape.length].action[0] = MV_UP;
7455         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7456         tape.length++;
7457         break;
7458
7459       case 'd':
7460       case 'D':
7461         tape.pos[tape.length].action[0] = MV_DOWN;
7462         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7463         tape.length++;
7464         break;
7465
7466       case 'l':
7467       case 'L':
7468         tape.pos[tape.length].action[0] = MV_LEFT;
7469         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7470         tape.length++;
7471         break;
7472
7473       case 'r':
7474       case 'R':
7475         tape.pos[tape.length].action[0] = MV_RIGHT;
7476         tape.pos[tape.length].delay = move_delay + (c < 'a' ? 2 : 0);
7477         tape.length++;
7478         break;
7479
7480       case '\n':
7481       case '\r':
7482       case '\t':
7483       case ' ':
7484         /* ignore white-space characters */
7485         break;
7486
7487       default:
7488         tape.no_valid_file = TRUE;
7489
7490         Error(ERR_WARN, "unsupported Sokoban solution file '%s' ['%d']", filename, c);
7491
7492         break;
7493     }
7494   }
7495
7496   closeFile(file);
7497
7498   if (tape.no_valid_file)
7499     return;
7500
7501   tape.length_frames  = GetTapeLengthFrames();
7502   tape.length_seconds = GetTapeLengthSeconds();
7503 }
7504
7505 void LoadTapeFromFilename(char *filename)
7506 {
7507   char cookie[MAX_LINE_LEN];
7508   char chunk_name[CHUNK_ID_LEN + 1];
7509   File *file;
7510   int chunk_size;
7511
7512   /* always start with reliable default values */
7513   setTapeInfoToDefaults();
7514
7515   if (strSuffix(filename, ".sln"))
7516   {
7517     LoadTape_SokobanSolution(filename);
7518
7519     return;
7520   }
7521
7522   if (!(file = openFile(filename, MODE_READ)))
7523   {
7524     tape.no_valid_file = TRUE;
7525
7526     return;
7527   }
7528
7529   getFileChunkBE(file, chunk_name, NULL);
7530   if (strEqual(chunk_name, "RND1"))
7531   {
7532     getFile32BitBE(file);               /* not used */
7533
7534     getFileChunkBE(file, chunk_name, NULL);
7535     if (!strEqual(chunk_name, "TAPE"))
7536     {
7537       tape.no_valid_file = TRUE;
7538
7539       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
7540
7541       closeFile(file);
7542
7543       return;
7544     }
7545   }
7546   else  /* check for pre-2.0 file format with cookie string */
7547   {
7548     strcpy(cookie, chunk_name);
7549     if (getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4) == NULL)
7550       cookie[4] = '\0';
7551     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
7552       cookie[strlen(cookie) - 1] = '\0';
7553
7554     if (!checkCookieString(cookie, TAPE_COOKIE_TMPL))
7555     {
7556       tape.no_valid_file = TRUE;
7557
7558       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
7559
7560       closeFile(file);
7561
7562       return;
7563     }
7564
7565     if ((tape.file_version = getFileVersionFromCookieString(cookie)) == -1)
7566     {
7567       tape.no_valid_file = TRUE;
7568
7569       Error(ERR_WARN, "unsupported version of tape file '%s'", filename);
7570
7571       closeFile(file);
7572
7573       return;
7574     }
7575
7576     /* pre-2.0 tape files have no game version, so use file version here */
7577     tape.game_version = tape.file_version;
7578   }
7579
7580   if (tape.file_version < FILE_VERSION_1_2)
7581   {
7582     /* tape files from versions before 1.2.0 without chunk structure */
7583     LoadTape_HEAD(file, TAPE_CHUNK_HEAD_SIZE, &tape);
7584     LoadTape_BODY(file, 2 * tape.length,      &tape);
7585   }
7586   else
7587   {
7588     static struct
7589     {
7590       char *name;
7591       int size;
7592       int (*loader)(File *, int, struct TapeInfo *);
7593     }
7594     chunk_info[] =
7595     {
7596       { "VERS", TAPE_CHUNK_VERS_SIZE,   LoadTape_VERS },
7597       { "HEAD", TAPE_CHUNK_HEAD_SIZE,   LoadTape_HEAD },
7598       { "INFO", -1,                     LoadTape_INFO },
7599       { "BODY", -1,                     LoadTape_BODY },
7600       {  NULL,  0,                      NULL }
7601     };
7602
7603     while (getFileChunkBE(file, chunk_name, &chunk_size))
7604     {
7605       int i = 0;
7606
7607       while (chunk_info[i].name != NULL &&
7608              !strEqual(chunk_name, chunk_info[i].name))
7609         i++;
7610
7611       if (chunk_info[i].name == NULL)
7612       {
7613         Error(ERR_WARN, "unknown chunk '%s' in tape file '%s'",
7614               chunk_name, filename);
7615         ReadUnusedBytesFromFile(file, chunk_size);
7616       }
7617       else if (chunk_info[i].size != -1 &&
7618                chunk_info[i].size != chunk_size)
7619       {
7620         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
7621               chunk_size, chunk_name, filename);
7622         ReadUnusedBytesFromFile(file, chunk_size);
7623       }
7624       else
7625       {
7626         /* call function to load this tape chunk */
7627         int chunk_size_expected =
7628           (chunk_info[i].loader)(file, chunk_size, &tape);
7629
7630         /* the size of some chunks cannot be checked before reading other
7631            chunks first (like "HEAD" and "BODY") that contain some header
7632            information, so check them here */
7633         if (chunk_size_expected != chunk_size)
7634         {
7635           Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
7636                 chunk_size, chunk_name, filename);
7637         }
7638       }
7639     }
7640   }
7641
7642   closeFile(file);
7643
7644   tape.length_frames  = GetTapeLengthFrames();
7645   tape.length_seconds = GetTapeLengthSeconds();
7646
7647 #if 0
7648   printf("::: tape file version: %d\n",   tape.file_version);
7649   printf("::: tape game version: %d\n",   tape.game_version);
7650   printf("::: tape engine version: %d\n", tape.engine_version);
7651 #endif
7652 }
7653
7654 void LoadTape(int nr)
7655 {
7656   char *filename = getTapeFilename(nr);
7657
7658   LoadTapeFromFilename(filename);
7659 }
7660
7661 void LoadSolutionTape(int nr)
7662 {
7663   char *filename = getSolutionTapeFilename(nr);
7664
7665   LoadTapeFromFilename(filename);
7666
7667   if (TAPE_IS_EMPTY(tape) &&
7668       level.game_engine_type == GAME_ENGINE_TYPE_SP &&
7669       level.native_sp_level->demo.is_available)
7670     CopyNativeTape_SP_to_RND(&level);
7671 }
7672
7673 static void SaveTape_VERS(FILE *file, struct TapeInfo *tape)
7674 {
7675   putFileVersion(file, tape->file_version);
7676   putFileVersion(file, tape->game_version);
7677 }
7678
7679 static void SaveTape_HEAD(FILE *file, struct TapeInfo *tape)
7680 {
7681   int i;
7682   byte store_participating_players = 0;
7683
7684   /* set bits for participating players for compact storage */
7685   for (i = 0; i < MAX_PLAYERS; i++)
7686     if (tape->player_participates[i])
7687       store_participating_players |= (1 << i);
7688
7689   putFile32BitBE(file, tape->random_seed);
7690   putFile32BitBE(file, tape->date);
7691   putFile32BitBE(file, tape->length);
7692
7693   putFile8Bit(file, store_participating_players);
7694
7695   /* unused bytes not at the end here for 4-byte alignment of engine_version */
7696   WriteUnusedBytesToFile(file, TAPE_CHUNK_HEAD_UNUSED);
7697
7698   putFileVersion(file, tape->engine_version);
7699 }
7700
7701 static void SaveTape_INFO(FILE *file, struct TapeInfo *tape)
7702 {
7703   int level_identifier_size = strlen(tape->level_identifier) + 1;
7704   int i;
7705
7706   putFile16BitBE(file, level_identifier_size);
7707
7708   for (i = 0; i < level_identifier_size; i++)
7709     putFile8Bit(file, tape->level_identifier[i]);
7710
7711   putFile16BitBE(file, tape->level_nr);
7712 }
7713
7714 static void SaveTape_BODY(FILE *file, struct TapeInfo *tape)
7715 {
7716   int i, j;
7717
7718   for (i = 0; i < tape->length; i++)
7719   {
7720     for (j = 0; j < MAX_PLAYERS; j++)
7721       if (tape->player_participates[j])
7722         putFile8Bit(file, tape->pos[i].action[j]);
7723
7724     putFile8Bit(file, tape->pos[i].delay);
7725   }
7726 }
7727
7728 void SaveTape(int nr)
7729 {
7730   char *filename = getTapeFilename(nr);
7731   FILE *file;
7732   int num_participating_players = 0;
7733   int info_chunk_size;
7734   int body_chunk_size;
7735   int i;
7736
7737   InitTapeDirectory(leveldir_current->subdir);
7738
7739   if (!(file = fopen(filename, MODE_WRITE)))
7740   {
7741     Error(ERR_WARN, "cannot save level recording file '%s'", filename);
7742     return;
7743   }
7744
7745   tape.file_version = FILE_VERSION_ACTUAL;
7746   tape.game_version = GAME_VERSION_ACTUAL;
7747
7748   /* count number of participating players  */
7749   for (i = 0; i < MAX_PLAYERS; i++)
7750     if (tape.player_participates[i])
7751       num_participating_players++;
7752
7753   info_chunk_size = 2 + (strlen(tape.level_identifier) + 1) + 2;
7754   body_chunk_size = (num_participating_players + 1) * tape.length;
7755
7756   putFileChunkBE(file, "RND1", CHUNK_SIZE_UNDEFINED);
7757   putFileChunkBE(file, "TAPE", CHUNK_SIZE_NONE);
7758
7759   putFileChunkBE(file, "VERS", TAPE_CHUNK_VERS_SIZE);
7760   SaveTape_VERS(file, &tape);
7761
7762   putFileChunkBE(file, "HEAD", TAPE_CHUNK_HEAD_SIZE);
7763   SaveTape_HEAD(file, &tape);
7764
7765   putFileChunkBE(file, "INFO", info_chunk_size);
7766   SaveTape_INFO(file, &tape);
7767
7768   putFileChunkBE(file, "BODY", body_chunk_size);
7769   SaveTape_BODY(file, &tape);
7770
7771   fclose(file);
7772
7773   SetFilePermissions(filename, PERMS_PRIVATE);
7774
7775   tape.changed = FALSE;
7776 }
7777
7778 boolean SaveTapeChecked(int nr)
7779 {
7780   char *filename = getTapeFilename(nr);
7781   boolean new_tape = !fileExists(filename);
7782   boolean tape_saved = FALSE;
7783
7784   if (new_tape || Request("Replace old tape?", REQ_ASK))
7785   {
7786     SaveTape(nr);
7787
7788     if (new_tape)
7789       Request("Tape saved!", REQ_CONFIRM);
7790
7791     tape_saved = TRUE;
7792   }
7793
7794   return tape_saved;
7795 }
7796
7797 void DumpTape(struct TapeInfo *tape)
7798 {
7799   int tape_frame_counter;
7800   int i, j;
7801
7802   if (tape->no_valid_file)
7803   {
7804     Error(ERR_WARN, "cannot dump -- no valid tape file found");
7805
7806     return;
7807   }
7808
7809   PrintLine("-", 79);
7810   Print("Tape of Level %03d (file version %08d, game version %08d)\n",
7811         tape->level_nr, tape->file_version, tape->game_version);
7812   Print("                  (effective engine version %08d)\n",
7813         tape->engine_version);
7814   Print("Level series identifier: '%s'\n", tape->level_identifier);
7815   PrintLine("-", 79);
7816
7817   tape_frame_counter = 0;
7818
7819   for (i = 0; i < tape->length; i++)
7820   {
7821     if (i >= MAX_TAPE_LEN)
7822       break;
7823
7824     Print("%04d: ", i);
7825
7826     for (j = 0; j < MAX_PLAYERS; j++)
7827     {
7828       if (tape->player_participates[j])
7829       {
7830         int action = tape->pos[i].action[j];
7831
7832         Print("%d:%02x ", j, action);
7833         Print("[%c%c%c%c|%c%c] - ",
7834               (action & JOY_LEFT ? '<' : ' '),
7835               (action & JOY_RIGHT ? '>' : ' '),
7836               (action & JOY_UP ? '^' : ' '),
7837               (action & JOY_DOWN ? 'v' : ' '),
7838               (action & JOY_BUTTON_1 ? '1' : ' '),
7839               (action & JOY_BUTTON_2 ? '2' : ' '));
7840       }
7841     }
7842
7843     Print("(%03d) ", tape->pos[i].delay);
7844     Print("[%05d]\n", tape_frame_counter);
7845
7846     tape_frame_counter += tape->pos[i].delay;
7847   }
7848
7849   PrintLine("-", 79);
7850 }
7851
7852
7853 /* ========================================================================= */
7854 /* score file functions                                                      */
7855 /* ========================================================================= */
7856
7857 void LoadScore(int nr)
7858 {
7859   int i;
7860   char *filename = getScoreFilename(nr);
7861   char cookie[MAX_LINE_LEN];
7862   char line[MAX_LINE_LEN];
7863   char *line_ptr;
7864   FILE *file;
7865
7866   /* always start with reliable default values */
7867   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
7868   {
7869     strcpy(highscore[i].Name, EMPTY_PLAYER_NAME);
7870     highscore[i].Score = 0;
7871   }
7872
7873   if (!(file = fopen(filename, MODE_READ)))
7874     return;
7875
7876   /* check file identifier */
7877   if (fgets(cookie, MAX_LINE_LEN, file) == NULL)
7878     cookie[0] = '\0';
7879   if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
7880     cookie[strlen(cookie) - 1] = '\0';
7881
7882   if (!checkCookieString(cookie, SCORE_COOKIE))
7883   {
7884     Error(ERR_WARN, "unknown format of score file '%s'", filename);
7885     fclose(file);
7886     return;
7887   }
7888
7889   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
7890   {
7891     if (fscanf(file, "%d", &highscore[i].Score) == EOF)
7892       Error(ERR_WARN, "fscanf() failed; %s", strerror(errno));
7893     if (fgets(line, MAX_LINE_LEN, file) == NULL)
7894       line[0] = '\0';
7895
7896     if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
7897       line[strlen(line) - 1] = '\0';
7898
7899     for (line_ptr = line; *line_ptr; line_ptr++)
7900     {
7901       if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != '\0')
7902       {
7903         strncpy(highscore[i].Name, line_ptr, MAX_PLAYER_NAME_LEN);
7904         highscore[i].Name[MAX_PLAYER_NAME_LEN] = '\0';
7905         break;
7906       }
7907     }
7908   }
7909
7910   fclose(file);
7911 }
7912
7913 void SaveScore(int nr)
7914 {
7915   int i;
7916   int permissions = (program.global_scores ? PERMS_PUBLIC : PERMS_PRIVATE);
7917   char *filename = getScoreFilename(nr);
7918   FILE *file;
7919
7920   InitScoreDirectory(leveldir_current->subdir);
7921
7922   if (!(file = fopen(filename, MODE_WRITE)))
7923   {
7924     Error(ERR_WARN, "cannot save score for level %d", nr);
7925     return;
7926   }
7927
7928   fprintf(file, "%s\n\n", SCORE_COOKIE);
7929
7930   for (i = 0; i < MAX_SCORE_ENTRIES; i++)
7931     fprintf(file, "%d %s\n", highscore[i].Score, highscore[i].Name);
7932
7933   fclose(file);
7934
7935   SetFilePermissions(filename, permissions);
7936 }
7937
7938
7939 /* ========================================================================= */
7940 /* setup file functions                                                      */
7941 /* ========================================================================= */
7942
7943 #define TOKEN_STR_PLAYER_PREFIX                 "player_"
7944
7945 /* global setup */
7946 #define SETUP_TOKEN_PLAYER_NAME                 0
7947 #define SETUP_TOKEN_SOUND                       1
7948 #define SETUP_TOKEN_SOUND_LOOPS                 2
7949 #define SETUP_TOKEN_SOUND_MUSIC                 3
7950 #define SETUP_TOKEN_SOUND_SIMPLE                4
7951 #define SETUP_TOKEN_TOONS                       5
7952 #define SETUP_TOKEN_SCROLL_DELAY                6
7953 #define SETUP_TOKEN_SCROLL_DELAY_VALUE          7
7954 #define SETUP_TOKEN_ENGINE_SNAPSHOT_MODE        8
7955 #define SETUP_TOKEN_ENGINE_SNAPSHOT_MEMORY      9
7956 #define SETUP_TOKEN_FADE_SCREENS                10
7957 #define SETUP_TOKEN_AUTORECORD                  11
7958 #define SETUP_TOKEN_SHOW_TITLESCREEN            12
7959 #define SETUP_TOKEN_QUICK_DOORS                 13
7960 #define SETUP_TOKEN_TEAM_MODE                   14
7961 #define SETUP_TOKEN_HANDICAP                    15
7962 #define SETUP_TOKEN_SKIP_LEVELS                 16
7963 #define SETUP_TOKEN_INCREMENT_LEVELS            17
7964 #define SETUP_TOKEN_TIME_LIMIT                  18
7965 #define SETUP_TOKEN_FULLSCREEN                  19
7966 #define SETUP_TOKEN_WINDOW_SCALING_PERCENT      20
7967 #define SETUP_TOKEN_WINDOW_SCALING_QUALITY      21
7968 #define SETUP_TOKEN_SCREEN_RENDERING_MODE       22
7969 #define SETUP_TOKEN_ASK_ON_ESCAPE               23
7970 #define SETUP_TOKEN_ASK_ON_ESCAPE_EDITOR        24
7971 #define SETUP_TOKEN_QUICK_SWITCH                25
7972 #define SETUP_TOKEN_INPUT_ON_FOCUS              26
7973 #define SETUP_TOKEN_PREFER_AGA_GRAPHICS         27
7974 #define SETUP_TOKEN_GAME_FRAME_DELAY            28
7975 #define SETUP_TOKEN_SP_SHOW_BORDER_ELEMENTS     29
7976 #define SETUP_TOKEN_SMALL_GAME_GRAPHICS         30
7977 #define SETUP_TOKEN_SHOW_SNAPSHOT_BUTTONS       31
7978 #define SETUP_TOKEN_GRAPHICS_SET                32
7979 #define SETUP_TOKEN_SOUNDS_SET                  33
7980 #define SETUP_TOKEN_MUSIC_SET                   34
7981 #define SETUP_TOKEN_OVERRIDE_LEVEL_GRAPHICS     35
7982 #define SETUP_TOKEN_OVERRIDE_LEVEL_SOUNDS       36
7983 #define SETUP_TOKEN_OVERRIDE_LEVEL_MUSIC        37
7984 #define SETUP_TOKEN_VOLUME_SIMPLE               38
7985 #define SETUP_TOKEN_VOLUME_LOOPS                39
7986 #define SETUP_TOKEN_VOLUME_MUSIC                40
7987 #define SETUP_TOKEN_TOUCH_CONTROL_TYPE          41
7988 #define SETUP_TOKEN_TOUCH_MOVE_DISTANCE         42
7989 #define SETUP_TOKEN_TOUCH_DROP_DISTANCE         43
7990
7991 #define NUM_GLOBAL_SETUP_TOKENS                 44
7992
7993 /* editor setup */
7994 #define SETUP_TOKEN_EDITOR_EL_CLASSIC           0
7995 #define SETUP_TOKEN_EDITOR_EL_CUSTOM            1
7996 #define SETUP_TOKEN_EDITOR_EL_USER_DEFINED      2
7997 #define SETUP_TOKEN_EDITOR_EL_DYNAMIC           3
7998 #define SETUP_TOKEN_EDITOR_EL_HEADLINES         4
7999 #define SETUP_TOKEN_EDITOR_SHOW_ELEMENT_TOKEN   5
8000
8001 #define NUM_EDITOR_SETUP_TOKENS                 6
8002
8003 /* editor cascade setup */
8004 #define SETUP_TOKEN_EDITOR_CASCADE_BD           0
8005 #define SETUP_TOKEN_EDITOR_CASCADE_EM           1
8006 #define SETUP_TOKEN_EDITOR_CASCADE_EMC          2
8007 #define SETUP_TOKEN_EDITOR_CASCADE_RND          3
8008 #define SETUP_TOKEN_EDITOR_CASCADE_SB           4
8009 #define SETUP_TOKEN_EDITOR_CASCADE_SP           5
8010 #define SETUP_TOKEN_EDITOR_CASCADE_DC           6
8011 #define SETUP_TOKEN_EDITOR_CASCADE_DX           7
8012 #define SETUP_TOKEN_EDITOR_CASCADE_TEXT         8
8013 #define SETUP_TOKEN_EDITOR_CASCADE_STEELTEXT    9
8014 #define SETUP_TOKEN_EDITOR_CASCADE_CE           10
8015 #define SETUP_TOKEN_EDITOR_CASCADE_GE           11
8016 #define SETUP_TOKEN_EDITOR_CASCADE_REF          12
8017 #define SETUP_TOKEN_EDITOR_CASCADE_USER         13
8018 #define SETUP_TOKEN_EDITOR_CASCADE_DYNAMIC      14
8019
8020 #define NUM_EDITOR_CASCADE_SETUP_TOKENS         15
8021
8022 /* shortcut setup */
8023 #define SETUP_TOKEN_SHORTCUT_SAVE_GAME          0
8024 #define SETUP_TOKEN_SHORTCUT_LOAD_GAME          1
8025 #define SETUP_TOKEN_SHORTCUT_TOGGLE_PAUSE       2
8026 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_1     3
8027 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_2     4
8028 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_3     5
8029 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_4     6
8030 #define SETUP_TOKEN_SHORTCUT_FOCUS_PLAYER_ALL   7
8031 #define SETUP_TOKEN_SHORTCUT_TAPE_EJECT         8
8032 #define SETUP_TOKEN_SHORTCUT_TAPE_EXTRA         9
8033 #define SETUP_TOKEN_SHORTCUT_TAPE_STOP          10
8034 #define SETUP_TOKEN_SHORTCUT_TAPE_PAUSE         11
8035 #define SETUP_TOKEN_SHORTCUT_TAPE_RECORD        12
8036 #define SETUP_TOKEN_SHORTCUT_TAPE_PLAY          13
8037 #define SETUP_TOKEN_SHORTCUT_SOUND_SIMPLE       14
8038 #define SETUP_TOKEN_SHORTCUT_SOUND_LOOPS        15
8039 #define SETUP_TOKEN_SHORTCUT_SOUND_MUSIC        16
8040 #define SETUP_TOKEN_SHORTCUT_SNAP_LEFT          17
8041 #define SETUP_TOKEN_SHORTCUT_SNAP_RIGHT         18
8042 #define SETUP_TOKEN_SHORTCUT_SNAP_UP            19
8043 #define SETUP_TOKEN_SHORTCUT_SNAP_DOWN          20
8044
8045 #define NUM_SHORTCUT_SETUP_TOKENS               21
8046
8047 /* player setup */
8048 #define SETUP_TOKEN_PLAYER_USE_JOYSTICK         0
8049 #define SETUP_TOKEN_PLAYER_JOY_DEVICE_NAME      1
8050 #define SETUP_TOKEN_PLAYER_JOY_XLEFT            2
8051 #define SETUP_TOKEN_PLAYER_JOY_XMIDDLE          3
8052 #define SETUP_TOKEN_PLAYER_JOY_XRIGHT           4
8053 #define SETUP_TOKEN_PLAYER_JOY_YUPPER           5
8054 #define SETUP_TOKEN_PLAYER_JOY_YMIDDLE          6
8055 #define SETUP_TOKEN_PLAYER_JOY_YLOWER           7
8056 #define SETUP_TOKEN_PLAYER_JOY_SNAP             8
8057 #define SETUP_TOKEN_PLAYER_JOY_DROP             9
8058 #define SETUP_TOKEN_PLAYER_KEY_LEFT             10
8059 #define SETUP_TOKEN_PLAYER_KEY_RIGHT            11
8060 #define SETUP_TOKEN_PLAYER_KEY_UP               12
8061 #define SETUP_TOKEN_PLAYER_KEY_DOWN             13
8062 #define SETUP_TOKEN_PLAYER_KEY_SNAP             14
8063 #define SETUP_TOKEN_PLAYER_KEY_DROP             15
8064
8065 #define NUM_PLAYER_SETUP_TOKENS                 16
8066
8067 /* system setup */
8068 #define SETUP_TOKEN_SYSTEM_SDL_VIDEODRIVER      0
8069 #define SETUP_TOKEN_SYSTEM_SDL_AUDIODRIVER      1
8070 #define SETUP_TOKEN_SYSTEM_AUDIO_FRAGMENT_SIZE  2
8071
8072 #define NUM_SYSTEM_SETUP_TOKENS                 3
8073
8074 /* internal setup */
8075 #define SETUP_TOKEN_INT_PROGRAM_TITLE           0
8076 #define SETUP_TOKEN_INT_PROGRAM_VERSION         1
8077 #define SETUP_TOKEN_INT_PROGRAM_AUTHOR          2
8078 #define SETUP_TOKEN_INT_PROGRAM_EMAIL           3
8079 #define SETUP_TOKEN_INT_PROGRAM_WEBSITE         4
8080 #define SETUP_TOKEN_INT_PROGRAM_COPYRIGHT       5
8081 #define SETUP_TOKEN_INT_PROGRAM_COMPANY         6
8082 #define SETUP_TOKEN_INT_PROGRAM_ICON_FILE       7
8083 #define SETUP_TOKEN_INT_DEFAULT_GRAPHICS_SET    8
8084 #define SETUP_TOKEN_INT_DEFAULT_SOUNDS_SET      9
8085 #define SETUP_TOKEN_INT_DEFAULT_MUSIC_SET       10
8086 #define SETUP_TOKEN_INT_FALLBACK_GRAPHICS_FILE  11
8087 #define SETUP_TOKEN_INT_FALLBACK_SOUNDS_FILE    12
8088 #define SETUP_TOKEN_INT_FALLBACK_MUSIC_FILE     13
8089 #define SETUP_TOKEN_INT_DEFAULT_LEVEL_SERIES    14
8090 #define SETUP_TOKEN_INT_CHOOSE_FROM_TOP_LEVELDIR 15
8091 #define SETUP_TOKEN_INT_SHOW_SCALING_IN_TITLE   16
8092 #define SETUP_TOKEN_INT_DEFAULT_WINDOW_WIDTH    17
8093 #define SETUP_TOKEN_INT_DEFAULT_WINDOW_HEIGHT   18
8094
8095 #define NUM_INTERNAL_SETUP_TOKENS               19
8096
8097 /* debug setup */
8098 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_0         0
8099 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_1         1
8100 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_2         2
8101 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_3         3
8102 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_4         4
8103 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_5         5
8104 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_6         6
8105 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_7         7
8106 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_8         8
8107 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_9         9
8108 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_0     10
8109 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_1     11
8110 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_2     12
8111 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_3     13
8112 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_4     14
8113 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_5     15
8114 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_6     16
8115 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_7     17
8116 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_8     18
8117 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_KEY_9     19
8118 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_USE_MOD_KEY 20
8119 #define SETUP_TOKEN_DEBUG_FRAME_DELAY_GAME_ONLY 21
8120 #define SETUP_TOKEN_DEBUG_SHOW_FRAMES_PER_SECOND 22
8121
8122 #define NUM_DEBUG_SETUP_TOKENS                  23
8123
8124 /* options setup */
8125 #define SETUP_TOKEN_OPTIONS_VERBOSE             0
8126
8127 #define NUM_OPTIONS_SETUP_TOKENS                1
8128
8129
8130 static struct SetupInfo si;
8131 static struct SetupEditorInfo sei;
8132 static struct SetupEditorCascadeInfo seci;
8133 static struct SetupShortcutInfo ssi;
8134 static struct SetupInputInfo sii;
8135 static struct SetupSystemInfo syi;
8136 static struct SetupInternalInfo sxi;
8137 static struct SetupDebugInfo sdi;
8138 static struct OptionInfo soi;
8139
8140 static struct TokenInfo global_setup_tokens[] =
8141 {
8142   { TYPE_STRING, &si.player_name,             "player_name"             },
8143   { TYPE_SWITCH, &si.sound,                   "sound"                   },
8144   { TYPE_SWITCH, &si.sound_loops,             "repeating_sound_loops"   },
8145   { TYPE_SWITCH, &si.sound_music,             "background_music"        },
8146   { TYPE_SWITCH, &si.sound_simple,            "simple_sound_effects"    },
8147   { TYPE_SWITCH, &si.toons,                   "toons"                   },
8148   { TYPE_SWITCH, &si.scroll_delay,            "scroll_delay"            },
8149   { TYPE_INTEGER,&si.scroll_delay_value,      "scroll_delay_value"      },
8150   { TYPE_STRING, &si.engine_snapshot_mode,    "engine_snapshot_mode"    },
8151   { TYPE_INTEGER,&si.engine_snapshot_memory,  "engine_snapshot_memory"  },
8152   { TYPE_SWITCH, &si.fade_screens,            "fade_screens"            },
8153   { TYPE_SWITCH, &si.autorecord,              "automatic_tape_recording"},
8154   { TYPE_SWITCH, &si.show_titlescreen,        "show_titlescreen"        },
8155   { TYPE_SWITCH, &si.quick_doors,             "quick_doors"             },
8156   { TYPE_SWITCH, &si.team_mode,               "team_mode"               },
8157   { TYPE_SWITCH, &si.handicap,                "handicap"                },
8158   { TYPE_SWITCH, &si.skip_levels,             "skip_levels"             },
8159   { TYPE_SWITCH, &si.increment_levels,        "increment_levels"        },
8160   { TYPE_SWITCH, &si.time_limit,              "time_limit"              },
8161   { TYPE_SWITCH, &si.fullscreen,              "fullscreen"              },
8162   { TYPE_INTEGER,&si.window_scaling_percent,  "window_scaling_percent"  },
8163   { TYPE_STRING, &si.window_scaling_quality,  "window_scaling_quality"  },
8164   { TYPE_STRING, &si.screen_rendering_mode,   "screen_rendering_mode"   },
8165   { TYPE_SWITCH, &si.ask_on_escape,           "ask_on_escape"           },
8166   { TYPE_SWITCH, &si.ask_on_escape_editor,    "ask_on_escape_editor"    },
8167   { TYPE_SWITCH, &si.quick_switch,            "quick_player_switch"     },
8168   { TYPE_SWITCH, &si.input_on_focus,          "input_on_focus"          },
8169   { TYPE_SWITCH, &si.prefer_aga_graphics,     "prefer_aga_graphics"     },
8170   { TYPE_INTEGER,&si.game_frame_delay,        "game_frame_delay"        },
8171   { TYPE_SWITCH, &si.sp_show_border_elements, "sp_show_border_elements" },
8172   { TYPE_SWITCH, &si.small_game_graphics,     "small_game_graphics"     },
8173   { TYPE_SWITCH, &si.show_snapshot_buttons,   "show_snapshot_buttons"   },
8174   { TYPE_STRING, &si.graphics_set,            "graphics_set"            },
8175   { TYPE_STRING, &si.sounds_set,              "sounds_set"              },
8176   { TYPE_STRING, &si.music_set,               "music_set"               },
8177   { TYPE_SWITCH3,&si.override_level_graphics, "override_level_graphics" },
8178   { TYPE_SWITCH3,&si.override_level_sounds,   "override_level_sounds"   },
8179   { TYPE_SWITCH3,&si.override_level_music,    "override_level_music"    },
8180   { TYPE_INTEGER,&si.volume_simple,           "volume_simple"           },
8181   { TYPE_INTEGER,&si.volume_loops,            "volume_loops"            },
8182   { TYPE_INTEGER,&si.volume_music,            "volume_music"            },
8183   { TYPE_STRING, &si.touch.control_type,      "touch.control_type"      },
8184   { TYPE_INTEGER,&si.touch.move_distance,     "touch.move_distance"     },
8185   { TYPE_INTEGER,&si.touch.drop_distance,     "touch.drop_distance"     },
8186 };
8187
8188 static struct TokenInfo editor_setup_tokens[] =
8189 {
8190   { TYPE_SWITCH, &sei.el_classic,       "editor.el_classic"             },
8191   { TYPE_SWITCH, &sei.el_custom,        "editor.el_custom"              },
8192   { TYPE_SWITCH, &sei.el_user_defined,  "editor.el_user_defined"        },
8193   { TYPE_SWITCH, &sei.el_dynamic,       "editor.el_dynamic"             },
8194   { TYPE_SWITCH, &sei.el_headlines,     "editor.el_headlines"           },
8195   { TYPE_SWITCH, &sei.show_element_token,"editor.show_element_token"    },
8196 };
8197
8198 static struct TokenInfo editor_cascade_setup_tokens[] =
8199 {
8200   { TYPE_SWITCH, &seci.el_bd,           "editor.cascade.el_bd"          },
8201   { TYPE_SWITCH, &seci.el_em,           "editor.cascade.el_em"          },
8202   { TYPE_SWITCH, &seci.el_emc,          "editor.cascade.el_emc"         },
8203   { TYPE_SWITCH, &seci.el_rnd,          "editor.cascade.el_rnd"         },
8204   { TYPE_SWITCH, &seci.el_sb,           "editor.cascade.el_sb"          },
8205   { TYPE_SWITCH, &seci.el_sp,           "editor.cascade.el_sp"          },
8206   { TYPE_SWITCH, &seci.el_dc,           "editor.cascade.el_dc"          },
8207   { TYPE_SWITCH, &seci.el_dx,           "editor.cascade.el_dx"          },
8208   { TYPE_SWITCH, &seci.el_chars,        "editor.cascade.el_chars"       },
8209   { TYPE_SWITCH, &seci.el_steel_chars,  "editor.cascade.el_steel_chars" },
8210   { TYPE_SWITCH, &seci.el_ce,           "editor.cascade.el_ce"          },
8211   { TYPE_SWITCH, &seci.el_ge,           "editor.cascade.el_ge"          },
8212   { TYPE_SWITCH, &seci.el_ref,          "editor.cascade.el_ref"         },
8213   { TYPE_SWITCH, &seci.el_user,         "editor.cascade.el_user"        },
8214   { TYPE_SWITCH, &seci.el_dynamic,      "editor.cascade.el_dynamic"     },
8215 };
8216
8217 static struct TokenInfo shortcut_setup_tokens[] =
8218 {
8219   { TYPE_KEY_X11, &ssi.save_game,       "shortcut.save_game"            },
8220   { TYPE_KEY_X11, &ssi.load_game,       "shortcut.load_game"            },
8221   { TYPE_KEY_X11, &ssi.toggle_pause,    "shortcut.toggle_pause"         },
8222   { TYPE_KEY_X11, &ssi.focus_player[0], "shortcut.focus_player_1"       },
8223   { TYPE_KEY_X11, &ssi.focus_player[1], "shortcut.focus_player_2"       },
8224   { TYPE_KEY_X11, &ssi.focus_player[2], "shortcut.focus_player_3"       },
8225   { TYPE_KEY_X11, &ssi.focus_player[3], "shortcut.focus_player_4"       },
8226   { TYPE_KEY_X11, &ssi.focus_player_all,"shortcut.focus_player_all"     },
8227   { TYPE_KEY_X11, &ssi.tape_eject,      "shortcut.tape_eject"           },
8228   { TYPE_KEY_X11, &ssi.tape_extra,      "shortcut.tape_extra"           },
8229   { TYPE_KEY_X11, &ssi.tape_stop,       "shortcut.tape_stop"            },
8230   { TYPE_KEY_X11, &ssi.tape_pause,      "shortcut.tape_pause"           },
8231   { TYPE_KEY_X11, &ssi.tape_record,     "shortcut.tape_record"          },
8232   { TYPE_KEY_X11, &ssi.tape_play,       "shortcut.tape_play"            },
8233   { TYPE_KEY_X11, &ssi.sound_simple,    "shortcut.sound_simple"         },
8234   { TYPE_KEY_X11, &ssi.sound_loops,     "shortcut.sound_loops"          },
8235   { TYPE_KEY_X11, &ssi.sound_music,     "shortcut.sound_music"          },
8236   { TYPE_KEY_X11, &ssi.snap_left,       "shortcut.snap_left"            },
8237   { TYPE_KEY_X11, &ssi.snap_right,      "shortcut.snap_right"           },
8238   { TYPE_KEY_X11, &ssi.snap_up,         "shortcut.snap_up"              },
8239   { TYPE_KEY_X11, &ssi.snap_down,       "shortcut.snap_down"            },
8240 };
8241
8242 static struct TokenInfo player_setup_tokens[] =
8243 {
8244   { TYPE_BOOLEAN, &sii.use_joystick,    ".use_joystick"                 },
8245   { TYPE_STRING,  &sii.joy.device_name, ".joy.device_name"              },
8246   { TYPE_INTEGER, &sii.joy.xleft,       ".joy.xleft"                    },
8247   { TYPE_INTEGER, &sii.joy.xmiddle,     ".joy.xmiddle"                  },
8248   { TYPE_INTEGER, &sii.joy.xright,      ".joy.xright"                   },
8249   { TYPE_INTEGER, &sii.joy.yupper,      ".joy.yupper"                   },
8250   { TYPE_INTEGER, &sii.joy.ymiddle,     ".joy.ymiddle"                  },
8251   { TYPE_INTEGER, &sii.joy.ylower,      ".joy.ylower"                   },
8252   { TYPE_INTEGER, &sii.joy.snap,        ".joy.snap_field"               },
8253   { TYPE_INTEGER, &sii.joy.drop,        ".joy.place_bomb"               },
8254   { TYPE_KEY_X11, &sii.key.left,        ".key.move_left"                },
8255   { TYPE_KEY_X11, &sii.key.right,       ".key.move_right"               },
8256   { TYPE_KEY_X11, &sii.key.up,          ".key.move_up"                  },
8257   { TYPE_KEY_X11, &sii.key.down,        ".key.move_down"                },
8258   { TYPE_KEY_X11, &sii.key.snap,        ".key.snap_field"               },
8259   { TYPE_KEY_X11, &sii.key.drop,        ".key.place_bomb"               },
8260 };
8261
8262 static struct TokenInfo system_setup_tokens[] =
8263 {
8264   { TYPE_STRING,  &syi.sdl_videodriver,    "system.sdl_videodriver"     },
8265   { TYPE_STRING,  &syi.sdl_audiodriver,    "system.sdl_audiodriver"     },
8266   { TYPE_INTEGER, &syi.audio_fragment_size,"system.audio_fragment_size" },
8267 };
8268
8269 static struct TokenInfo internal_setup_tokens[] =
8270 {
8271   { TYPE_STRING, &sxi.program_title,            "program_title"         },
8272   { TYPE_STRING, &sxi.program_version,          "program_version"       },
8273   { TYPE_STRING, &sxi.program_author,           "program_author"        },
8274   { TYPE_STRING, &sxi.program_email,            "program_email"         },
8275   { TYPE_STRING, &sxi.program_website,          "program_website"       },
8276   { TYPE_STRING, &sxi.program_copyright,        "program_copyright"     },
8277   { TYPE_STRING, &sxi.program_company,          "program_company"       },
8278   { TYPE_STRING, &sxi.program_icon_file,        "program_icon_file"     },
8279   { TYPE_STRING, &sxi.default_graphics_set,     "default_graphics_set"  },
8280   { TYPE_STRING, &sxi.default_sounds_set,       "default_sounds_set"    },
8281   { TYPE_STRING, &sxi.default_music_set,        "default_music_set"     },
8282   { TYPE_STRING, &sxi.fallback_graphics_file,   "fallback_graphics_file"},
8283   { TYPE_STRING, &sxi.fallback_sounds_file,     "fallback_sounds_file"  },
8284   { TYPE_STRING, &sxi.fallback_music_file,      "fallback_music_file"   },
8285   { TYPE_STRING, &sxi.default_level_series,     "default_level_series"  },
8286   { TYPE_BOOLEAN,&sxi.choose_from_top_leveldir, "choose_from_top_leveldir" },
8287   { TYPE_BOOLEAN,&sxi.show_scaling_in_title,    "show_scaling_in_title" },
8288   { TYPE_INTEGER,&sxi.default_window_width,     "default_window_width"  },
8289   { TYPE_INTEGER,&sxi.default_window_height,    "default_window_height" },
8290 };
8291
8292 static struct TokenInfo debug_setup_tokens[] =
8293 {
8294   { TYPE_INTEGER, &sdi.frame_delay[0],          "debug.frame_delay_0"   },
8295   { TYPE_INTEGER, &sdi.frame_delay[1],          "debug.frame_delay_1"   },
8296   { TYPE_INTEGER, &sdi.frame_delay[2],          "debug.frame_delay_2"   },
8297   { TYPE_INTEGER, &sdi.frame_delay[3],          "debug.frame_delay_3"   },
8298   { TYPE_INTEGER, &sdi.frame_delay[4],          "debug.frame_delay_4"   },
8299   { TYPE_INTEGER, &sdi.frame_delay[5],          "debug.frame_delay_5"   },
8300   { TYPE_INTEGER, &sdi.frame_delay[6],          "debug.frame_delay_6"   },
8301   { TYPE_INTEGER, &sdi.frame_delay[7],          "debug.frame_delay_7"   },
8302   { TYPE_INTEGER, &sdi.frame_delay[8],          "debug.frame_delay_8"   },
8303   { TYPE_INTEGER, &sdi.frame_delay[9],          "debug.frame_delay_9"   },
8304   { TYPE_KEY_X11, &sdi.frame_delay_key[0],      "debug.key.frame_delay_0" },
8305   { TYPE_KEY_X11, &sdi.frame_delay_key[1],      "debug.key.frame_delay_1" },
8306   { TYPE_KEY_X11, &sdi.frame_delay_key[2],      "debug.key.frame_delay_2" },
8307   { TYPE_KEY_X11, &sdi.frame_delay_key[3],      "debug.key.frame_delay_3" },
8308   { TYPE_KEY_X11, &sdi.frame_delay_key[4],      "debug.key.frame_delay_4" },
8309   { TYPE_KEY_X11, &sdi.frame_delay_key[5],      "debug.key.frame_delay_5" },
8310   { TYPE_KEY_X11, &sdi.frame_delay_key[6],      "debug.key.frame_delay_6" },
8311   { TYPE_KEY_X11, &sdi.frame_delay_key[7],      "debug.key.frame_delay_7" },
8312   { TYPE_KEY_X11, &sdi.frame_delay_key[8],      "debug.key.frame_delay_8" },
8313   { TYPE_KEY_X11, &sdi.frame_delay_key[9],      "debug.key.frame_delay_9" },
8314   { TYPE_BOOLEAN, &sdi.frame_delay_use_mod_key,"debug.frame_delay.use_mod_key"},
8315   { TYPE_BOOLEAN, &sdi.frame_delay_game_only,  "debug.frame_delay.game_only" },
8316   { TYPE_BOOLEAN, &sdi.show_frames_per_second, "debug.show_frames_per_second" },
8317 };
8318
8319 static struct TokenInfo options_setup_tokens[] =
8320 {
8321   { TYPE_BOOLEAN, &soi.verbose,         "options.verbose"               },
8322 };
8323
8324 static char *get_corrected_login_name(char *login_name)
8325 {
8326   /* needed because player name must be a fixed length string */
8327   char *login_name_new = checked_malloc(MAX_PLAYER_NAME_LEN + 1);
8328
8329   strncpy(login_name_new, login_name, MAX_PLAYER_NAME_LEN);
8330   login_name_new[MAX_PLAYER_NAME_LEN] = '\0';
8331
8332   if (strlen(login_name) > MAX_PLAYER_NAME_LEN)         /* name has been cut */
8333     if (strchr(login_name_new, ' '))
8334       *strchr(login_name_new, ' ') = '\0';
8335
8336   return login_name_new;
8337 }
8338
8339 static void setSetupInfoToDefaults(struct SetupInfo *si)
8340 {
8341   int i;
8342
8343   si->player_name = get_corrected_login_name(getLoginName());
8344
8345   si->sound = TRUE;
8346   si->sound_loops = TRUE;
8347   si->sound_music = TRUE;
8348   si->sound_simple = TRUE;
8349   si->toons = TRUE;
8350   si->scroll_delay = TRUE;
8351   si->scroll_delay_value = STD_SCROLL_DELAY;
8352   si->engine_snapshot_mode = getStringCopy(STR_SNAPSHOT_MODE_DEFAULT);
8353   si->engine_snapshot_memory = SNAPSHOT_MEMORY_DEFAULT;
8354   si->fade_screens = TRUE;
8355   si->autorecord = TRUE;
8356   si->show_titlescreen = TRUE;
8357   si->quick_doors = FALSE;
8358   si->team_mode = FALSE;
8359   si->handicap = TRUE;
8360   si->skip_levels = TRUE;
8361   si->increment_levels = TRUE;
8362   si->time_limit = TRUE;
8363   si->fullscreen = FALSE;
8364   si->window_scaling_percent = STD_WINDOW_SCALING_PERCENT;
8365   si->window_scaling_quality = getStringCopy(SCALING_QUALITY_DEFAULT);
8366   si->screen_rendering_mode = getStringCopy(STR_SPECIAL_RENDERING_DEFAULT);
8367   si->ask_on_escape = TRUE;
8368   si->ask_on_escape_editor = TRUE;
8369   si->quick_switch = FALSE;
8370   si->input_on_focus = FALSE;
8371   si->prefer_aga_graphics = TRUE;
8372   si->game_frame_delay = GAME_FRAME_DELAY;
8373   si->sp_show_border_elements = FALSE;
8374   si->small_game_graphics = FALSE;
8375   si->show_snapshot_buttons = FALSE;
8376
8377   si->graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
8378   si->sounds_set   = getStringCopy(SND_CLASSIC_SUBDIR);
8379   si->music_set    = getStringCopy(MUS_CLASSIC_SUBDIR);
8380
8381   si->override_level_graphics = FALSE;
8382   si->override_level_sounds = FALSE;
8383   si->override_level_music = FALSE;
8384
8385   si->volume_simple = 100;              /* percent */
8386   si->volume_loops = 100;               /* percent */
8387   si->volume_music = 100;               /* percent */
8388
8389   si->touch.control_type = getStringCopy(TOUCH_CONTROL_DEFAULT);
8390   si->touch.move_distance = TOUCH_MOVE_DISTANCE_DEFAULT;        /* percent */
8391   si->touch.drop_distance = TOUCH_DROP_DISTANCE_DEFAULT;        /* percent */
8392
8393   si->editor.el_boulderdash             = TRUE;
8394   si->editor.el_emerald_mine            = TRUE;
8395   si->editor.el_emerald_mine_club       = TRUE;
8396   si->editor.el_more                    = TRUE;
8397   si->editor.el_sokoban                 = TRUE;
8398   si->editor.el_supaplex                = TRUE;
8399   si->editor.el_diamond_caves           = TRUE;
8400   si->editor.el_dx_boulderdash          = TRUE;
8401   si->editor.el_chars                   = TRUE;
8402   si->editor.el_steel_chars             = TRUE;
8403
8404   si->editor.el_classic                 = TRUE;
8405   si->editor.el_custom                  = TRUE;
8406
8407   si->editor.el_user_defined            = FALSE;
8408   si->editor.el_dynamic                 = TRUE;
8409
8410   si->editor.el_headlines               = TRUE;
8411
8412   si->editor.show_element_token         = FALSE;
8413
8414   si->editor.use_template_for_new_levels = TRUE;
8415
8416   si->shortcut.save_game        = DEFAULT_KEY_SAVE_GAME;
8417   si->shortcut.load_game        = DEFAULT_KEY_LOAD_GAME;
8418   si->shortcut.toggle_pause     = DEFAULT_KEY_TOGGLE_PAUSE;
8419
8420   si->shortcut.focus_player[0]  = DEFAULT_KEY_FOCUS_PLAYER_1;
8421   si->shortcut.focus_player[1]  = DEFAULT_KEY_FOCUS_PLAYER_2;
8422   si->shortcut.focus_player[2]  = DEFAULT_KEY_FOCUS_PLAYER_3;
8423   si->shortcut.focus_player[3]  = DEFAULT_KEY_FOCUS_PLAYER_4;
8424   si->shortcut.focus_player_all = DEFAULT_KEY_FOCUS_PLAYER_ALL;
8425
8426   si->shortcut.tape_eject       = DEFAULT_KEY_TAPE_EJECT;
8427   si->shortcut.tape_extra       = DEFAULT_KEY_TAPE_EXTRA;
8428   si->shortcut.tape_stop        = DEFAULT_KEY_TAPE_STOP;
8429   si->shortcut.tape_pause       = DEFAULT_KEY_TAPE_PAUSE;
8430   si->shortcut.tape_record      = DEFAULT_KEY_TAPE_RECORD;
8431   si->shortcut.tape_play        = DEFAULT_KEY_TAPE_PLAY;
8432
8433   si->shortcut.sound_simple     = DEFAULT_KEY_SOUND_SIMPLE;
8434   si->shortcut.sound_loops      = DEFAULT_KEY_SOUND_LOOPS;
8435   si->shortcut.sound_music      = DEFAULT_KEY_SOUND_MUSIC;
8436
8437   si->shortcut.snap_left        = DEFAULT_KEY_SNAP_LEFT;
8438   si->shortcut.snap_right       = DEFAULT_KEY_SNAP_RIGHT;
8439   si->shortcut.snap_up          = DEFAULT_KEY_SNAP_UP;
8440   si->shortcut.snap_down        = DEFAULT_KEY_SNAP_DOWN;
8441
8442   for (i = 0; i < MAX_PLAYERS; i++)
8443   {
8444     si->input[i].use_joystick = FALSE;
8445     si->input[i].joy.device_name=getStringCopy(getDeviceNameFromJoystickNr(i));
8446     si->input[i].joy.xleft   = JOYSTICK_XLEFT;
8447     si->input[i].joy.xmiddle = JOYSTICK_XMIDDLE;
8448     si->input[i].joy.xright  = JOYSTICK_XRIGHT;
8449     si->input[i].joy.yupper  = JOYSTICK_YUPPER;
8450     si->input[i].joy.ymiddle = JOYSTICK_YMIDDLE;
8451     si->input[i].joy.ylower  = JOYSTICK_YLOWER;
8452     si->input[i].joy.snap  = (i == 0 ? JOY_BUTTON_1 : 0);
8453     si->input[i].joy.drop  = (i == 0 ? JOY_BUTTON_2 : 0);
8454     si->input[i].key.left  = (i == 0 ? DEFAULT_KEY_LEFT  : KSYM_UNDEFINED);
8455     si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KSYM_UNDEFINED);
8456     si->input[i].key.up    = (i == 0 ? DEFAULT_KEY_UP    : KSYM_UNDEFINED);
8457     si->input[i].key.down  = (i == 0 ? DEFAULT_KEY_DOWN  : KSYM_UNDEFINED);
8458     si->input[i].key.snap  = (i == 0 ? DEFAULT_KEY_SNAP  : KSYM_UNDEFINED);
8459     si->input[i].key.drop  = (i == 0 ? DEFAULT_KEY_DROP  : KSYM_UNDEFINED);
8460   }
8461
8462   si->system.sdl_videodriver = getStringCopy(ARG_DEFAULT);
8463   si->system.sdl_audiodriver = getStringCopy(ARG_DEFAULT);
8464   si->system.audio_fragment_size = DEFAULT_AUDIO_FRAGMENT_SIZE;
8465
8466   si->internal.program_title     = getStringCopy(PROGRAM_TITLE_STRING);
8467   si->internal.program_version   = getStringCopy(getProgramRealVersionString());
8468   si->internal.program_author    = getStringCopy(PROGRAM_AUTHOR_STRING);
8469   si->internal.program_email     = getStringCopy(PROGRAM_EMAIL_STRING);
8470   si->internal.program_website   = getStringCopy(PROGRAM_WEBSITE_STRING);
8471   si->internal.program_copyright = getStringCopy(PROGRAM_COPYRIGHT_STRING);
8472   si->internal.program_company   = getStringCopy(PROGRAM_COMPANY_STRING);
8473
8474   si->internal.program_icon_file = getStringCopy(PROGRAM_ICON_FILENAME);
8475
8476   si->internal.default_graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
8477   si->internal.default_sounds_set   = getStringCopy(SND_CLASSIC_SUBDIR);
8478   si->internal.default_music_set    = getStringCopy(MUS_CLASSIC_SUBDIR);
8479
8480   si->internal.fallback_graphics_file = getStringCopy(UNDEFINED_FILENAME);
8481   si->internal.fallback_sounds_file   = getStringCopy(UNDEFINED_FILENAME);
8482   si->internal.fallback_music_file    = getStringCopy(UNDEFINED_FILENAME);
8483
8484   si->internal.default_level_series = getStringCopy(UNDEFINED_LEVELSET);
8485   si->internal.choose_from_top_leveldir = FALSE;
8486   si->internal.show_scaling_in_title = TRUE;
8487
8488   si->internal.default_window_width  = WIN_XSIZE_DEFAULT;
8489   si->internal.default_window_height = WIN_YSIZE_DEFAULT;
8490
8491   si->debug.frame_delay[0] = DEFAULT_FRAME_DELAY_0;
8492   si->debug.frame_delay[1] = DEFAULT_FRAME_DELAY_1;
8493   si->debug.frame_delay[2] = DEFAULT_FRAME_DELAY_2;
8494   si->debug.frame_delay[3] = DEFAULT_FRAME_DELAY_3;
8495   si->debug.frame_delay[4] = DEFAULT_FRAME_DELAY_4;
8496   si->debug.frame_delay[5] = DEFAULT_FRAME_DELAY_5;
8497   si->debug.frame_delay[6] = DEFAULT_FRAME_DELAY_6;
8498   si->debug.frame_delay[7] = DEFAULT_FRAME_DELAY_7;
8499   si->debug.frame_delay[8] = DEFAULT_FRAME_DELAY_8;
8500   si->debug.frame_delay[9] = DEFAULT_FRAME_DELAY_9;
8501
8502   si->debug.frame_delay_key[0] = DEFAULT_KEY_FRAME_DELAY_0;
8503   si->debug.frame_delay_key[1] = DEFAULT_KEY_FRAME_DELAY_1;
8504   si->debug.frame_delay_key[2] = DEFAULT_KEY_FRAME_DELAY_2;
8505   si->debug.frame_delay_key[3] = DEFAULT_KEY_FRAME_DELAY_3;
8506   si->debug.frame_delay_key[4] = DEFAULT_KEY_FRAME_DELAY_4;
8507   si->debug.frame_delay_key[5] = DEFAULT_KEY_FRAME_DELAY_5;
8508   si->debug.frame_delay_key[6] = DEFAULT_KEY_FRAME_DELAY_6;
8509   si->debug.frame_delay_key[7] = DEFAULT_KEY_FRAME_DELAY_7;
8510   si->debug.frame_delay_key[8] = DEFAULT_KEY_FRAME_DELAY_8;
8511   si->debug.frame_delay_key[9] = DEFAULT_KEY_FRAME_DELAY_9;
8512
8513   si->debug.frame_delay_use_mod_key = DEFAULT_FRAME_DELAY_USE_MOD_KEY;
8514   si->debug.frame_delay_game_only   = DEFAULT_FRAME_DELAY_GAME_ONLY;
8515
8516   si->debug.show_frames_per_second = FALSE;
8517
8518   si->options.verbose = FALSE;
8519
8520 #if defined(PLATFORM_ANDROID)
8521   si->fullscreen = TRUE;
8522 #endif
8523 }
8524
8525 static void setSetupInfoToDefaults_EditorCascade(struct SetupInfo *si)
8526 {
8527   si->editor_cascade.el_bd              = TRUE;
8528   si->editor_cascade.el_em              = TRUE;
8529   si->editor_cascade.el_emc             = TRUE;
8530   si->editor_cascade.el_rnd             = TRUE;
8531   si->editor_cascade.el_sb              = TRUE;
8532   si->editor_cascade.el_sp              = TRUE;
8533   si->editor_cascade.el_dc              = TRUE;
8534   si->editor_cascade.el_dx              = TRUE;
8535
8536   si->editor_cascade.el_chars           = FALSE;
8537   si->editor_cascade.el_steel_chars     = FALSE;
8538   si->editor_cascade.el_ce              = FALSE;
8539   si->editor_cascade.el_ge              = FALSE;
8540   si->editor_cascade.el_ref             = FALSE;
8541   si->editor_cascade.el_user            = FALSE;
8542   si->editor_cascade.el_dynamic         = FALSE;
8543 }
8544
8545 #define MAX_HIDE_SETUP_TOKEN_SIZE               20
8546
8547 static char *getHideSetupToken(void *setup_value)
8548 {
8549   static char hide_setup_token[MAX_HIDE_SETUP_TOKEN_SIZE];
8550
8551   if (setup_value != NULL)
8552     snprintf(hide_setup_token, MAX_HIDE_SETUP_TOKEN_SIZE, "%p", setup_value);
8553
8554   return hide_setup_token;
8555 }
8556
8557 static void setHideSetupEntry(void *setup_value_raw)
8558 {
8559   /* !!! DIRTY WORKAROUND; TO BE FIXED AFTER THE MM ENGINE RELEASE !!! */
8560   void *setup_value = setup_value_raw - (void *)&si + (void *)&setup;
8561
8562   char *hide_setup_token = getHideSetupToken(setup_value);
8563
8564   if (setup_value != NULL)
8565     setHashEntry(hide_setup_hash, hide_setup_token, "");
8566 }
8567
8568 boolean hideSetupEntry(void *setup_value)
8569 {
8570   char *hide_setup_token = getHideSetupToken(setup_value);
8571
8572   return (setup_value != NULL &&
8573           getHashEntry(hide_setup_hash, hide_setup_token) != NULL);
8574 }
8575
8576 static void setSetupInfoFromTokenText(SetupFileHash *setup_file_hash,
8577                                       struct TokenInfo *token_info,
8578                                       int token_nr, char *token_text)
8579 {
8580   char *token_hide_text = getStringCat2(token_text, ".hide");
8581   char *token_hide_value = getHashEntry(setup_file_hash, token_hide_text);
8582
8583   /* set the value of this setup option in the setup option structure */
8584   setSetupInfo(token_info, token_nr, getHashEntry(setup_file_hash, token_text));
8585
8586   /* check if this setup option should be hidden in the setup menu */
8587   if (token_hide_value != NULL && get_boolean_from_string(token_hide_value))
8588     setHideSetupEntry(token_info[token_nr].value);
8589 }
8590
8591 static void setSetupInfoFromTokenInfo(SetupFileHash *setup_file_hash,
8592                                       struct TokenInfo *token_info,
8593                                       int token_nr)
8594 {
8595   setSetupInfoFromTokenText(setup_file_hash, token_info, token_nr,
8596                             token_info[token_nr].text);
8597 }
8598
8599 static void decodeSetupFileHash(SetupFileHash *setup_file_hash)
8600 {
8601   int i, pnr;
8602
8603   if (!setup_file_hash)
8604     return;
8605
8606   if (hide_setup_hash == NULL)
8607     hide_setup_hash = newSetupFileHash();
8608
8609   /* global setup */
8610   si = setup;
8611   for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
8612     setSetupInfoFromTokenInfo(setup_file_hash, global_setup_tokens, i);
8613   setup = si;
8614
8615   /* editor setup */
8616   sei = setup.editor;
8617   for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
8618     setSetupInfoFromTokenInfo(setup_file_hash, editor_setup_tokens, i);
8619   setup.editor = sei;
8620
8621   /* shortcut setup */
8622   ssi = setup.shortcut;
8623   for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
8624     setSetupInfoFromTokenInfo(setup_file_hash, shortcut_setup_tokens, i);
8625   setup.shortcut = ssi;
8626
8627   /* player setup */
8628   for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
8629   {
8630     char prefix[30];
8631
8632     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
8633
8634     sii = setup.input[pnr];
8635     for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
8636     {
8637       char full_token[100];
8638
8639       sprintf(full_token, "%s%s", prefix, player_setup_tokens[i].text);
8640       setSetupInfoFromTokenText(setup_file_hash, player_setup_tokens, i,
8641                                 full_token);
8642     }
8643     setup.input[pnr] = sii;
8644   }
8645
8646   /* system setup */
8647   syi = setup.system;
8648   for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
8649     setSetupInfoFromTokenInfo(setup_file_hash, system_setup_tokens, i);
8650   setup.system = syi;
8651
8652   /* internal setup */
8653   sxi = setup.internal;
8654   for (i = 0; i < NUM_INTERNAL_SETUP_TOKENS; i++)
8655     setSetupInfoFromTokenInfo(setup_file_hash, internal_setup_tokens, i);
8656   setup.internal = sxi;
8657
8658   /* debug setup */
8659   sdi = setup.debug;
8660   for (i = 0; i < NUM_DEBUG_SETUP_TOKENS; i++)
8661     setSetupInfoFromTokenInfo(setup_file_hash, debug_setup_tokens, i);
8662   setup.debug = sdi;
8663
8664   /* options setup */
8665   soi = setup.options;
8666   for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
8667     setSetupInfoFromTokenInfo(setup_file_hash, options_setup_tokens, i);
8668   setup.options = soi;
8669 }
8670
8671 static void decodeSetupFileHash_EditorCascade(SetupFileHash *setup_file_hash)
8672 {
8673   int i;
8674
8675   if (!setup_file_hash)
8676     return;
8677
8678   /* editor cascade setup */
8679   seci = setup.editor_cascade;
8680   for (i = 0; i < NUM_EDITOR_CASCADE_SETUP_TOKENS; i++)
8681     setSetupInfo(editor_cascade_setup_tokens, i,
8682                  getHashEntry(setup_file_hash,
8683                               editor_cascade_setup_tokens[i].text));
8684   setup.editor_cascade = seci;
8685 }
8686
8687 void LoadSetupFromFilename(char *filename)
8688 {
8689   SetupFileHash *setup_file_hash = loadSetupFileHash(filename);
8690
8691   if (setup_file_hash)
8692   {
8693     decodeSetupFileHash(setup_file_hash);
8694
8695     freeSetupFileHash(setup_file_hash);
8696   }
8697   else
8698   {
8699     Error(ERR_DEBUG, "using default setup values");
8700   }
8701 }
8702
8703 static void LoadSetup_SpecialPostProcessing()
8704 {
8705   char *player_name_new;
8706
8707   /* needed to work around problems with fixed length strings */
8708   player_name_new = get_corrected_login_name(setup.player_name);
8709   free(setup.player_name);
8710   setup.player_name = player_name_new;
8711
8712   /* "scroll_delay: on(3) / off(0)" was replaced by scroll delay value */
8713   if (setup.scroll_delay == FALSE)
8714   {
8715     setup.scroll_delay_value = MIN_SCROLL_DELAY;
8716     setup.scroll_delay = TRUE;                  /* now always "on" */
8717   }
8718
8719   /* make sure that scroll delay value stays inside valid range */
8720   setup.scroll_delay_value =
8721     MIN(MAX(MIN_SCROLL_DELAY, setup.scroll_delay_value), MAX_SCROLL_DELAY);
8722 }
8723
8724 void LoadSetup()
8725 {
8726   char *filename;
8727
8728   /* always start with reliable default values */
8729   setSetupInfoToDefaults(&setup);
8730
8731   /* try to load setup values from default setup file */
8732   filename = getDefaultSetupFilename();
8733
8734   if (fileExists(filename))
8735     LoadSetupFromFilename(filename);
8736
8737   /* try to load setup values from user setup file */
8738   filename = getSetupFilename();
8739
8740   LoadSetupFromFilename(filename);
8741
8742   LoadSetup_SpecialPostProcessing();
8743 }
8744
8745 void LoadSetup_EditorCascade()
8746 {
8747   char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
8748   SetupFileHash *setup_file_hash = NULL;
8749
8750   /* always start with reliable default values */
8751   setSetupInfoToDefaults_EditorCascade(&setup);
8752
8753   setup_file_hash = loadSetupFileHash(filename);
8754
8755   if (setup_file_hash)
8756   {
8757     decodeSetupFileHash_EditorCascade(setup_file_hash);
8758
8759     freeSetupFileHash(setup_file_hash);
8760   }
8761
8762   free(filename);
8763 }
8764
8765 static void addGameControllerMappingToHash(SetupFileHash *mappings_hash,
8766                                            char *mapping_line)
8767 {
8768   char mapping_guid[MAX_LINE_LEN];
8769   char *mapping_start, *mapping_end;
8770
8771   // get GUID from game controller mapping line: copy complete line
8772   strncpy(mapping_guid, mapping_line, MAX_LINE_LEN - 1);
8773   mapping_guid[MAX_LINE_LEN - 1] = '\0';
8774
8775   // get GUID from game controller mapping line: cut after GUID part
8776   mapping_start = strchr(mapping_guid, ',');
8777   if (mapping_start != NULL)
8778     *mapping_start = '\0';
8779
8780   // cut newline from game controller mapping line
8781   mapping_end = strchr(mapping_line, '\n');
8782   if (mapping_end != NULL)
8783     *mapping_end = '\0';
8784
8785   // add mapping entry to game controller mappings hash
8786   setHashEntry(mappings_hash, mapping_guid, mapping_line);
8787 }
8788
8789 static void LoadSetup_ReadGameControllerMappings(SetupFileHash *mappings_hash,
8790                                                  char *filename)
8791 {
8792   FILE *file;
8793
8794   if (!(file = fopen(filename, MODE_READ)))
8795   {
8796     Error(ERR_WARN, "cannot read game controller mappings file '%s'", filename);
8797
8798     return;
8799   }
8800
8801   while (!feof(file))
8802   {
8803     char line[MAX_LINE_LEN];
8804
8805     if (!fgets(line, MAX_LINE_LEN, file))
8806       break;
8807
8808     addGameControllerMappingToHash(mappings_hash, line);
8809   }
8810
8811   fclose(file);
8812 }
8813
8814 void SaveSetup()
8815 {
8816   char *filename = getSetupFilename();
8817   FILE *file;
8818   int i, pnr;
8819
8820   InitUserDataDirectory();
8821
8822   if (!(file = fopen(filename, MODE_WRITE)))
8823   {
8824     Error(ERR_WARN, "cannot write setup file '%s'", filename);
8825     return;
8826   }
8827
8828   fprintFileHeader(file, SETUP_FILENAME);
8829
8830   /* global setup */
8831   si = setup;
8832   for (i = 0; i < NUM_GLOBAL_SETUP_TOKENS; i++)
8833   {
8834     /* just to make things nicer :) */
8835     if (i == SETUP_TOKEN_PLAYER_NAME + 1 ||
8836         i == SETUP_TOKEN_GRAPHICS_SET ||
8837         i == SETUP_TOKEN_VOLUME_SIMPLE ||
8838         i == SETUP_TOKEN_TOUCH_CONTROL_TYPE)
8839       fprintf(file, "\n");
8840
8841     fprintf(file, "%s\n", getSetupLine(global_setup_tokens, "", i));
8842   }
8843
8844   /* editor setup */
8845   sei = setup.editor;
8846   fprintf(file, "\n");
8847   for (i = 0; i < NUM_EDITOR_SETUP_TOKENS; i++)
8848     fprintf(file, "%s\n", getSetupLine(editor_setup_tokens, "", i));
8849
8850   /* shortcut setup */
8851   ssi = setup.shortcut;
8852   fprintf(file, "\n");
8853   for (i = 0; i < NUM_SHORTCUT_SETUP_TOKENS; i++)
8854     fprintf(file, "%s\n", getSetupLine(shortcut_setup_tokens, "", i));
8855
8856   /* player setup */
8857   for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
8858   {
8859     char prefix[30];
8860
8861     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
8862     fprintf(file, "\n");
8863
8864     sii = setup.input[pnr];
8865     for (i = 0; i < NUM_PLAYER_SETUP_TOKENS; i++)
8866       fprintf(file, "%s\n", getSetupLine(player_setup_tokens, prefix, i));
8867   }
8868
8869   /* system setup */
8870   syi = setup.system;
8871   fprintf(file, "\n");
8872   for (i = 0; i < NUM_SYSTEM_SETUP_TOKENS; i++)
8873     fprintf(file, "%s\n", getSetupLine(system_setup_tokens, "", i));
8874
8875   /* internal setup */
8876   /* (internal setup values not saved to user setup file) */
8877
8878   /* debug setup */
8879   sdi = setup.debug;
8880   fprintf(file, "\n");
8881   for (i = 0; i < NUM_DEBUG_SETUP_TOKENS; i++)
8882     fprintf(file, "%s\n", getSetupLine(debug_setup_tokens, "", i));
8883
8884   /* options setup */
8885   soi = setup.options;
8886   fprintf(file, "\n");
8887   for (i = 0; i < NUM_OPTIONS_SETUP_TOKENS; i++)
8888     fprintf(file, "%s\n", getSetupLine(options_setup_tokens, "", i));
8889
8890   fclose(file);
8891
8892   SetFilePermissions(filename, PERMS_PRIVATE);
8893 }
8894
8895 void SaveSetup_EditorCascade()
8896 {
8897   char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
8898   FILE *file;
8899   int i;
8900
8901   InitUserDataDirectory();
8902
8903   if (!(file = fopen(filename, MODE_WRITE)))
8904   {
8905     Error(ERR_WARN, "cannot write editor cascade state file '%s'", filename);
8906     free(filename);
8907     return;
8908   }
8909
8910   fprintFileHeader(file, EDITORCASCADE_FILENAME);
8911
8912   seci = setup.editor_cascade;
8913   for (i = 0; i < NUM_EDITOR_CASCADE_SETUP_TOKENS; i++)
8914     fprintf(file, "%s\n", getSetupLine(editor_cascade_setup_tokens, "", i));
8915
8916   fclose(file);
8917
8918   SetFilePermissions(filename, PERMS_PRIVATE);
8919
8920   free(filename);
8921 }
8922
8923 static void SaveSetup_WriteGameControllerMappings(SetupFileHash *mappings_hash,
8924                                                   char *filename)
8925 {
8926   FILE *file;
8927
8928   if (!(file = fopen(filename, MODE_WRITE)))
8929   {
8930     Error(ERR_WARN, "cannot write game controller mappings file '%s'",filename);
8931
8932     return;
8933   }
8934
8935   BEGIN_HASH_ITERATION(mappings_hash, itr)
8936   {
8937     fprintf(file, "%s\n", HASH_ITERATION_VALUE(itr));
8938   }
8939   END_HASH_ITERATION(mappings_hash, itr)
8940
8941   fclose(file);
8942 }
8943
8944 void SaveSetup_AddGameControllerMapping(char *mapping)
8945 {
8946   char *filename = getPath2(getSetupDir(), GAMECONTROLLER_BASENAME);
8947   SetupFileHash *mappings_hash = newSetupFileHash();
8948
8949   InitUserDataDirectory();
8950
8951   // load existing personal game controller mappings
8952   LoadSetup_ReadGameControllerMappings(mappings_hash, filename);
8953
8954   // add new mapping to personal game controller mappings
8955   addGameControllerMappingToHash(mappings_hash, mapping);
8956
8957   // save updated personal game controller mappings
8958   SaveSetup_WriteGameControllerMappings(mappings_hash, filename);
8959
8960   freeSetupFileHash(mappings_hash);
8961   free(filename);
8962 }
8963
8964 void LoadCustomElementDescriptions()
8965 {
8966   char *filename = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
8967   SetupFileHash *setup_file_hash;
8968   int i;
8969
8970   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
8971   {
8972     if (element_info[i].custom_description != NULL)
8973     {
8974       free(element_info[i].custom_description);
8975       element_info[i].custom_description = NULL;
8976     }
8977   }
8978
8979   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
8980     return;
8981
8982   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
8983   {
8984     char *token = getStringCat2(element_info[i].token_name, ".name");
8985     char *value = getHashEntry(setup_file_hash, token);
8986
8987     if (value != NULL)
8988       element_info[i].custom_description = getStringCopy(value);
8989
8990     free(token);
8991   }
8992
8993   freeSetupFileHash(setup_file_hash);
8994 }
8995
8996 static int getElementFromToken(char *token)
8997 {
8998   char *value = getHashEntry(element_token_hash, token);
8999
9000   if (value != NULL)
9001     return atoi(value);
9002
9003   Error(ERR_WARN, "unknown element token '%s'", token);
9004
9005   return EL_UNDEFINED;
9006 }
9007
9008 static int get_token_parameter_value(char *token, char *value_raw)
9009 {
9010   char *suffix;
9011
9012   if (token == NULL || value_raw == NULL)
9013     return ARG_UNDEFINED_VALUE;
9014
9015   suffix = strrchr(token, '.');
9016   if (suffix == NULL)
9017     suffix = token;
9018
9019   if (strEqual(suffix, ".element"))
9020     return getElementFromToken(value_raw);
9021
9022   /* !!! USE CORRECT VALUE TYPE (currently works also for TYPE_BOOLEAN) !!! */
9023   return get_parameter_value(value_raw, suffix, TYPE_INTEGER);
9024 }
9025
9026 void InitMenuDesignSettings_Static()
9027 {
9028   int i;
9029
9030   /* always start with reliable default values from static default config */
9031   for (i = 0; image_config_vars[i].token != NULL; i++)
9032   {
9033     char *value = getHashEntry(image_config_hash, image_config_vars[i].token);
9034
9035     if (value != NULL)
9036       *image_config_vars[i].value =
9037         get_token_parameter_value(image_config_vars[i].token, value);
9038   }
9039 }
9040
9041 static void InitMenuDesignSettings_SpecialPreProcessing()
9042 {
9043   int i;
9044
9045   /* the following initializes hierarchical values from static configuration */
9046
9047   /* special case: initialize "ARG_DEFAULT" values in static default config */
9048   /* (e.g., initialize "[titlemessage].fade_mode" from "[title].fade_mode") */
9049   titlescreen_initial_first_default.fade_mode  =
9050     title_initial_first_default.fade_mode;
9051   titlescreen_initial_first_default.fade_delay =
9052     title_initial_first_default.fade_delay;
9053   titlescreen_initial_first_default.post_delay =
9054     title_initial_first_default.post_delay;
9055   titlescreen_initial_first_default.auto_delay =
9056     title_initial_first_default.auto_delay;
9057   titlescreen_first_default.fade_mode  = title_first_default.fade_mode;
9058   titlescreen_first_default.fade_delay = title_first_default.fade_delay;
9059   titlescreen_first_default.post_delay = title_first_default.post_delay;
9060   titlescreen_first_default.auto_delay = title_first_default.auto_delay;
9061   titlemessage_initial_first_default.fade_mode  =
9062     title_initial_first_default.fade_mode;
9063   titlemessage_initial_first_default.fade_delay =
9064     title_initial_first_default.fade_delay;
9065   titlemessage_initial_first_default.post_delay =
9066     title_initial_first_default.post_delay;
9067   titlemessage_initial_first_default.auto_delay =
9068     title_initial_first_default.auto_delay;
9069   titlemessage_first_default.fade_mode  = title_first_default.fade_mode;
9070   titlemessage_first_default.fade_delay = title_first_default.fade_delay;
9071   titlemessage_first_default.post_delay = title_first_default.post_delay;
9072   titlemessage_first_default.auto_delay = title_first_default.auto_delay;
9073
9074   titlescreen_initial_default.fade_mode  = title_initial_default.fade_mode;
9075   titlescreen_initial_default.fade_delay = title_initial_default.fade_delay;
9076   titlescreen_initial_default.post_delay = title_initial_default.post_delay;
9077   titlescreen_initial_default.auto_delay = title_initial_default.auto_delay;
9078   titlescreen_default.fade_mode  = title_default.fade_mode;
9079   titlescreen_default.fade_delay = title_default.fade_delay;
9080   titlescreen_default.post_delay = title_default.post_delay;
9081   titlescreen_default.auto_delay = title_default.auto_delay;
9082   titlemessage_initial_default.fade_mode  = title_initial_default.fade_mode;
9083   titlemessage_initial_default.fade_delay = title_initial_default.fade_delay;
9084   titlemessage_initial_default.post_delay = title_initial_default.post_delay;
9085   titlemessage_initial_default.auto_delay = title_initial_default.auto_delay;
9086   titlemessage_default.fade_mode  = title_default.fade_mode;
9087   titlemessage_default.fade_delay = title_default.fade_delay;
9088   titlemessage_default.post_delay = title_default.post_delay;
9089   titlemessage_default.auto_delay = title_default.auto_delay;
9090
9091   /* special case: initialize "ARG_DEFAULT" values in static default config */
9092   /* (e.g., init "titlemessage_1.fade_mode" from "[titlemessage].fade_mode") */
9093   for (i = 0; i < MAX_NUM_TITLE_MESSAGES; i++)
9094   {
9095     titlescreen_initial_first[i] = titlescreen_initial_first_default;
9096     titlescreen_first[i] = titlescreen_first_default;
9097     titlemessage_initial_first[i] = titlemessage_initial_first_default;
9098     titlemessage_first[i] = titlemessage_first_default;
9099
9100     titlescreen_initial[i] = titlescreen_initial_default;
9101     titlescreen[i] = titlescreen_default;
9102     titlemessage_initial[i] = titlemessage_initial_default;
9103     titlemessage[i] = titlemessage_default;
9104   }
9105
9106   /* special case: initialize "ARG_DEFAULT" values in static default config */
9107   /* (eg, init "menu.enter_screen.SCORES.xyz" from "menu.enter_screen.xyz") */
9108   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9109   {
9110     if (i == GFX_SPECIAL_ARG_TITLE)     /* title values already initialized */
9111       continue;
9112
9113     menu.enter_screen[i] = menu.enter_screen[GFX_SPECIAL_ARG_DEFAULT];
9114     menu.leave_screen[i] = menu.leave_screen[GFX_SPECIAL_ARG_DEFAULT];
9115     menu.next_screen[i]  = menu.next_screen[GFX_SPECIAL_ARG_DEFAULT];
9116   }
9117
9118   /* special case: initialize "ARG_DEFAULT" values in static default config */
9119   /* (eg, init "viewport.door_1.MAIN.xyz" from "viewport.door_1.xyz") */
9120   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9121   {
9122     viewport.window[i]    = viewport.window[GFX_SPECIAL_ARG_DEFAULT];
9123     viewport.playfield[i] = viewport.playfield[GFX_SPECIAL_ARG_DEFAULT];
9124     viewport.door_1[i]    = viewport.door_1[GFX_SPECIAL_ARG_DEFAULT];
9125
9126     if (i == GFX_SPECIAL_ARG_EDITOR)    /* editor values already initialized */
9127       continue;
9128
9129     viewport.door_2[i] = viewport.door_2[GFX_SPECIAL_ARG_DEFAULT];
9130   }
9131 }
9132
9133 static void InitMenuDesignSettings_SpecialPostProcessing()
9134 {
9135   static struct
9136   {
9137     struct XY *dst, *src;
9138   }
9139   game_buttons_xy[] =
9140   {
9141     { &game.button.save,        &game.button.stop       },
9142     { &game.button.pause2,      &game.button.pause      },
9143     { &game.button.load,        &game.button.play       },
9144     { &game.button.undo,        &game.button.stop       },
9145     { &game.button.redo,        &game.button.play       },
9146
9147     { NULL,                     NULL                    }
9148   };
9149   int i;
9150
9151   /* special case: initialize later added SETUP list size from LEVELS value */
9152   if (menu.list_size[GAME_MODE_SETUP] == -1)
9153     menu.list_size[GAME_MODE_SETUP] = menu.list_size[GAME_MODE_LEVELS];
9154
9155   /* set default position for snapshot buttons to stop/pause/play buttons */
9156   for (i = 0; game_buttons_xy[i].dst != NULL; i++)
9157     if ((*game_buttons_xy[i].dst).x == -1 &&
9158         (*game_buttons_xy[i].dst).y == -1)
9159       *game_buttons_xy[i].dst = *game_buttons_xy[i].src;
9160 }
9161
9162 static void InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics()
9163 {
9164   static struct
9165   {
9166     struct XYTileSize *dst, *src;
9167     int graphic;
9168   }
9169   editor_buttons_xy[] =
9170   {
9171     {
9172       &editor.button.element_left,      &editor.palette.element_left,
9173       IMG_GFX_EDITOR_BUTTON_ELEMENT_LEFT
9174     },
9175     {
9176       &editor.button.element_middle,    &editor.palette.element_middle,
9177       IMG_GFX_EDITOR_BUTTON_ELEMENT_MIDDLE
9178     },
9179     {
9180       &editor.button.element_right,     &editor.palette.element_right,
9181       IMG_GFX_EDITOR_BUTTON_ELEMENT_RIGHT
9182     },
9183
9184     { NULL,                     NULL                    }
9185   };
9186   int i;
9187
9188   /* set default position for element buttons to element graphics */
9189   for (i = 0; editor_buttons_xy[i].dst != NULL; i++)
9190   {
9191     if ((*editor_buttons_xy[i].dst).x == -1 &&
9192         (*editor_buttons_xy[i].dst).y == -1)
9193     {
9194       struct GraphicInfo *gd = &graphic_info[editor_buttons_xy[i].graphic];
9195
9196       gd->width = gd->height = editor_buttons_xy[i].src->tile_size;
9197
9198       *editor_buttons_xy[i].dst = *editor_buttons_xy[i].src;
9199     }
9200   }
9201 }
9202
9203 static void LoadMenuDesignSettingsFromFilename(char *filename)
9204 {
9205   static struct TitleFadingInfo tfi;
9206   static struct TitleMessageInfo tmi;
9207   static struct TokenInfo title_tokens[] =
9208   {
9209     { TYPE_INTEGER,     &tfi.fade_mode,         ".fade_mode"            },
9210     { TYPE_INTEGER,     &tfi.fade_delay,        ".fade_delay"           },
9211     { TYPE_INTEGER,     &tfi.post_delay,        ".post_delay"           },
9212     { TYPE_INTEGER,     &tfi.auto_delay,        ".auto_delay"           },
9213
9214     { -1,               NULL,                   NULL                    }
9215   };
9216   static struct TokenInfo titlemessage_tokens[] =
9217   {
9218     { TYPE_INTEGER,     &tmi.x,                 ".x"                    },
9219     { TYPE_INTEGER,     &tmi.y,                 ".y"                    },
9220     { TYPE_INTEGER,     &tmi.width,             ".width"                },
9221     { TYPE_INTEGER,     &tmi.height,            ".height"               },
9222     { TYPE_INTEGER,     &tmi.chars,             ".chars"                },
9223     { TYPE_INTEGER,     &tmi.lines,             ".lines"                },
9224     { TYPE_INTEGER,     &tmi.align,             ".align"                },
9225     { TYPE_INTEGER,     &tmi.valign,            ".valign"               },
9226     { TYPE_INTEGER,     &tmi.font,              ".font"                 },
9227     { TYPE_BOOLEAN,     &tmi.autowrap,          ".autowrap"             },
9228     { TYPE_BOOLEAN,     &tmi.centered,          ".centered"             },
9229     { TYPE_BOOLEAN,     &tmi.parse_comments,    ".parse_comments"       },
9230     { TYPE_INTEGER,     &tmi.sort_priority,     ".sort_priority"        },
9231     { TYPE_INTEGER,     &tmi.fade_mode,         ".fade_mode"            },
9232     { TYPE_INTEGER,     &tmi.fade_delay,        ".fade_delay"           },
9233     { TYPE_INTEGER,     &tmi.post_delay,        ".post_delay"           },
9234     { TYPE_INTEGER,     &tmi.auto_delay,        ".auto_delay"           },
9235
9236     { -1,               NULL,                   NULL                    }
9237   };
9238   static struct
9239   {
9240     struct TitleFadingInfo *info;
9241     char *text;
9242   }
9243   title_info[] =
9244   {
9245     /* initialize first titles from "enter screen" definitions, if defined */
9246     { &title_initial_first_default,     "menu.enter_screen.TITLE"       },
9247     { &title_first_default,             "menu.enter_screen.TITLE"       },
9248
9249     /* initialize title screens from "next screen" definitions, if defined */
9250     { &title_initial_default,           "menu.next_screen.TITLE"        },
9251     { &title_default,                   "menu.next_screen.TITLE"        },
9252
9253     { NULL,                             NULL                            }
9254   };
9255   static struct
9256   {
9257     struct TitleMessageInfo *array;
9258     char *text;
9259   }
9260   titlemessage_arrays[] =
9261   {
9262     /* initialize first titles from "enter screen" definitions, if defined */
9263     { titlescreen_initial_first,        "menu.enter_screen.TITLE"       },
9264     { titlescreen_first,                "menu.enter_screen.TITLE"       },
9265     { titlemessage_initial_first,       "menu.enter_screen.TITLE"       },
9266     { titlemessage_first,               "menu.enter_screen.TITLE"       },
9267
9268     /* initialize titles from "next screen" definitions, if defined */
9269     { titlescreen_initial,              "menu.next_screen.TITLE"        },
9270     { titlescreen,                      "menu.next_screen.TITLE"        },
9271     { titlemessage_initial,             "menu.next_screen.TITLE"        },
9272     { titlemessage,                     "menu.next_screen.TITLE"        },
9273
9274     /* overwrite titles with title definitions, if defined */
9275     { titlescreen_initial_first,        "[title_initial]"               },
9276     { titlescreen_first,                "[title]"                       },
9277     { titlemessage_initial_first,       "[title_initial]"               },
9278     { titlemessage_first,               "[title]"                       },
9279
9280     { titlescreen_initial,              "[title_initial]"               },
9281     { titlescreen,                      "[title]"                       },
9282     { titlemessage_initial,             "[title_initial]"               },
9283     { titlemessage,                     "[title]"                       },
9284
9285     /* overwrite titles with title screen/message definitions, if defined */
9286     { titlescreen_initial_first,        "[titlescreen_initial]"         },
9287     { titlescreen_first,                "[titlescreen]"                 },
9288     { titlemessage_initial_first,       "[titlemessage_initial]"        },
9289     { titlemessage_first,               "[titlemessage]"                },
9290
9291     { titlescreen_initial,              "[titlescreen_initial]"         },
9292     { titlescreen,                      "[titlescreen]"                 },
9293     { titlemessage_initial,             "[titlemessage_initial]"        },
9294     { titlemessage,                     "[titlemessage]"                },
9295
9296     { NULL,                             NULL                            }
9297   };
9298   SetupFileHash *setup_file_hash;
9299   int i, j, k;
9300
9301   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
9302     return;
9303
9304   /* the following initializes hierarchical values from dynamic configuration */
9305
9306   /* special case: initialize with default values that may be overwritten */
9307   /* (e.g., init "menu.draw_xoffset.INFO" from "menu.draw_xoffset") */
9308   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9309   {
9310     char *value_1 = getHashEntry(setup_file_hash, "menu.draw_xoffset");
9311     char *value_2 = getHashEntry(setup_file_hash, "menu.draw_yoffset");
9312     char *value_3 = getHashEntry(setup_file_hash, "menu.list_size");
9313
9314     if (value_1 != NULL)
9315       menu.draw_xoffset[i] = get_integer_from_string(value_1);
9316     if (value_2 != NULL)
9317       menu.draw_yoffset[i] = get_integer_from_string(value_2);
9318     if (value_3 != NULL)
9319       menu.list_size[i] = get_integer_from_string(value_3);
9320   }
9321
9322   /* special case: initialize with default values that may be overwritten */
9323   /* (eg, init "menu.draw_xoffset.INFO[XXX]" from "menu.draw_xoffset.INFO") */
9324   for (i = 0; i < NUM_SPECIAL_GFX_INFO_ARGS; i++)
9325   {
9326     char *value_1 = getHashEntry(setup_file_hash, "menu.draw_xoffset.INFO");
9327     char *value_2 = getHashEntry(setup_file_hash, "menu.draw_yoffset.INFO");
9328
9329     if (value_1 != NULL)
9330       menu.draw_xoffset_info[i] = get_integer_from_string(value_1);
9331     if (value_2 != NULL)
9332       menu.draw_yoffset_info[i] = get_integer_from_string(value_2);
9333
9334     if (i == GFX_SPECIAL_ARG_INFO_ELEMENTS)
9335     {
9336       char *value_1 = getHashEntry(setup_file_hash, "menu.list_size.INFO");
9337
9338       if (value_1 != NULL)
9339         menu.list_size_info[i] = get_integer_from_string(value_1);
9340     }
9341   }
9342
9343   /* special case: initialize with default values that may be overwritten */
9344   /* (eg, init "menu.draw_xoffset.SETUP[XXX]" from "menu.draw_xoffset.SETUP") */
9345   for (i = 0; i < NUM_SPECIAL_GFX_SETUP_ARGS; i++)
9346   {
9347     char *value_1 = getHashEntry(setup_file_hash, "menu.draw_xoffset.SETUP");
9348     char *value_2 = getHashEntry(setup_file_hash, "menu.draw_yoffset.SETUP");
9349
9350     if (value_1 != NULL)
9351       menu.draw_xoffset_setup[i] = get_integer_from_string(value_1);
9352     if (value_2 != NULL)
9353       menu.draw_yoffset_setup[i] = get_integer_from_string(value_2);
9354   }
9355
9356   /* special case: initialize with default values that may be overwritten */
9357   /* (eg, init "menu.enter_screen.SCORES.xyz" from "menu.enter_screen.xyz") */
9358   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9359   {
9360     char *token_1 = "menu.enter_screen.fade_mode";
9361     char *token_2 = "menu.enter_screen.fade_delay";
9362     char *token_3 = "menu.enter_screen.post_delay";
9363     char *token_4 = "menu.leave_screen.fade_mode";
9364     char *token_5 = "menu.leave_screen.fade_delay";
9365     char *token_6 = "menu.leave_screen.post_delay";
9366     char *token_7 = "menu.next_screen.fade_mode";
9367     char *token_8 = "menu.next_screen.fade_delay";
9368     char *token_9 = "menu.next_screen.post_delay";
9369     char *value_1 = getHashEntry(setup_file_hash, token_1);
9370     char *value_2 = getHashEntry(setup_file_hash, token_2);
9371     char *value_3 = getHashEntry(setup_file_hash, token_3);
9372     char *value_4 = getHashEntry(setup_file_hash, token_4);
9373     char *value_5 = getHashEntry(setup_file_hash, token_5);
9374     char *value_6 = getHashEntry(setup_file_hash, token_6);
9375     char *value_7 = getHashEntry(setup_file_hash, token_7);
9376     char *value_8 = getHashEntry(setup_file_hash, token_8);
9377     char *value_9 = getHashEntry(setup_file_hash, token_9);
9378
9379     if (value_1 != NULL)
9380       menu.enter_screen[i].fade_mode = get_token_parameter_value(token_1,
9381                                                                  value_1);
9382     if (value_2 != NULL)
9383       menu.enter_screen[i].fade_delay = get_token_parameter_value(token_2,
9384                                                                   value_2);
9385     if (value_3 != NULL)
9386       menu.enter_screen[i].post_delay = get_token_parameter_value(token_3,
9387                                                                   value_3);
9388     if (value_4 != NULL)
9389       menu.leave_screen[i].fade_mode = get_token_parameter_value(token_4,
9390                                                                  value_4);
9391     if (value_5 != NULL)
9392       menu.leave_screen[i].fade_delay = get_token_parameter_value(token_5,
9393                                                                   value_5);
9394     if (value_6 != NULL)
9395       menu.leave_screen[i].post_delay = get_token_parameter_value(token_6,
9396                                                                   value_6);
9397     if (value_7 != NULL)
9398       menu.next_screen[i].fade_mode = get_token_parameter_value(token_7,
9399                                                                 value_7);
9400     if (value_8 != NULL)
9401       menu.next_screen[i].fade_delay = get_token_parameter_value(token_8,
9402                                                                  value_8);
9403     if (value_9 != NULL)
9404       menu.next_screen[i].post_delay = get_token_parameter_value(token_9,
9405                                                                  value_9);
9406   }
9407
9408   /* special case: initialize with default values that may be overwritten */
9409   /* (eg, init "viewport.door_1.MAIN.xyz" from "viewport.door_1.xyz") */
9410   for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
9411   {
9412     char *token_w1 = "viewport.window.width";
9413     char *token_w2 = "viewport.window.height";
9414     char *token_01 = "viewport.playfield.x";
9415     char *token_02 = "viewport.playfield.y";
9416     char *token_03 = "viewport.playfield.width";
9417     char *token_04 = "viewport.playfield.height";
9418     char *token_05 = "viewport.playfield.border_size";
9419     char *token_06 = "viewport.door_1.x";
9420     char *token_07 = "viewport.door_1.y";
9421     char *token_08 = "viewport.door_1.width";
9422     char *token_09 = "viewport.door_1.height";
9423     char *token_10 = "viewport.door_1.border_size";
9424     char *token_11 = "viewport.door_2.x";
9425     char *token_12 = "viewport.door_2.y";
9426     char *token_13 = "viewport.door_2.width";
9427     char *token_14 = "viewport.door_2.height";
9428     char *token_15 = "viewport.door_2.border_size";
9429     char *value_w1 = getHashEntry(setup_file_hash, token_w1);
9430     char *value_w2 = getHashEntry(setup_file_hash, token_w2);
9431     char *value_01 = getHashEntry(setup_file_hash, token_01);
9432     char *value_02 = getHashEntry(setup_file_hash, token_02);
9433     char *value_03 = getHashEntry(setup_file_hash, token_03);
9434     char *value_04 = getHashEntry(setup_file_hash, token_04);
9435     char *value_05 = getHashEntry(setup_file_hash, token_05);
9436     char *value_06 = getHashEntry(setup_file_hash, token_06);
9437     char *value_07 = getHashEntry(setup_file_hash, token_07);
9438     char *value_08 = getHashEntry(setup_file_hash, token_08);
9439     char *value_09 = getHashEntry(setup_file_hash, token_09);
9440     char *value_10 = getHashEntry(setup_file_hash, token_10);
9441     char *value_11 = getHashEntry(setup_file_hash, token_11);
9442     char *value_12 = getHashEntry(setup_file_hash, token_12);
9443     char *value_13 = getHashEntry(setup_file_hash, token_13);
9444     char *value_14 = getHashEntry(setup_file_hash, token_14);
9445     char *value_15 = getHashEntry(setup_file_hash, token_15);
9446
9447     if (value_w1 != NULL)
9448       viewport.window[i].width = get_token_parameter_value(token_w1, value_w1);
9449     if (value_w2 != NULL)
9450       viewport.window[i].height = get_token_parameter_value(token_w2, value_w2);
9451     if (value_01 != NULL)
9452       viewport.playfield[i].x = get_token_parameter_value(token_01, value_01);
9453     if (value_02 != NULL)
9454       viewport.playfield[i].y = get_token_parameter_value(token_02, value_02);
9455     if (value_03 != NULL)
9456       viewport.playfield[i].width = get_token_parameter_value(token_03,
9457                                                               value_03);
9458     if (value_04 != NULL)
9459       viewport.playfield[i].height = get_token_parameter_value(token_04,
9460                                                                value_04);
9461     if (value_05 != NULL)
9462       viewport.playfield[i].border_size = get_token_parameter_value(token_05,
9463                                                                     value_05);
9464     if (value_06 != NULL)
9465       viewport.door_1[i].x = get_token_parameter_value(token_06, value_06);
9466     if (value_07 != NULL)
9467       viewport.door_1[i].y = get_token_parameter_value(token_07, value_07);
9468     if (value_08 != NULL)
9469       viewport.door_1[i].width = get_token_parameter_value(token_08, value_08);
9470     if (value_09 != NULL)
9471       viewport.door_1[i].height = get_token_parameter_value(token_09, value_09);
9472     if (value_10 != NULL)
9473       viewport.door_1[i].border_size = get_token_parameter_value(token_10,
9474                                                                  value_10);
9475     if (value_11 != NULL)
9476       viewport.door_2[i].x = get_token_parameter_value(token_11, value_11);
9477     if (value_12 != NULL)
9478       viewport.door_2[i].y = get_token_parameter_value(token_12, value_12);
9479     if (value_13 != NULL)
9480       viewport.door_2[i].width = get_token_parameter_value(token_13, value_13);
9481     if (value_14 != NULL)
9482       viewport.door_2[i].height = get_token_parameter_value(token_14, value_14);
9483     if (value_15 != NULL)
9484       viewport.door_1[i].border_size = get_token_parameter_value(token_15,
9485                                                                  value_15);
9486   }
9487
9488   /* special case: initialize with default values that may be overwritten */
9489   /* (e.g., init "[title].fade_mode" from "menu.next_screen.TITLE.fade_mode") */
9490   for (i = 0; title_info[i].info != NULL; i++)
9491   {
9492     struct TitleFadingInfo *info = title_info[i].info;
9493     char *base_token = title_info[i].text;
9494
9495     for (j = 0; title_tokens[j].type != -1; j++)
9496     {
9497       char *token = getStringCat2(base_token, title_tokens[j].text);
9498       char *value = getHashEntry(setup_file_hash, token);
9499
9500       if (value != NULL)
9501       {
9502         int parameter_value = get_token_parameter_value(token, value);
9503
9504         tfi = *info;
9505
9506         *(int *)title_tokens[j].value = (int)parameter_value;
9507
9508         *info = tfi;
9509       }
9510
9511       free(token);
9512     }
9513   }
9514
9515   /* special case: initialize with default values that may be overwritten */
9516   /* (e.g., init "titlemessage_1.fade_mode" from "[titlemessage].fade_mode") */
9517   for (i = 0; titlemessage_arrays[i].array != NULL; i++)
9518   {
9519     struct TitleMessageInfo *array = titlemessage_arrays[i].array;
9520     char *base_token = titlemessage_arrays[i].text;
9521
9522     for (j = 0; titlemessage_tokens[j].type != -1; j++)
9523     {
9524       char *token = getStringCat2(base_token, titlemessage_tokens[j].text);
9525       char *value = getHashEntry(setup_file_hash, token);
9526
9527       if (value != NULL)
9528       {
9529         int parameter_value = get_token_parameter_value(token, value);
9530
9531         for (k = 0; k < MAX_NUM_TITLE_MESSAGES; k++)
9532         {
9533           tmi = array[k];
9534
9535           if (titlemessage_tokens[j].type == TYPE_INTEGER)
9536             *(int     *)titlemessage_tokens[j].value = (int)parameter_value;
9537           else
9538             *(boolean *)titlemessage_tokens[j].value = (boolean)parameter_value;
9539
9540           array[k] = tmi;
9541         }
9542       }
9543
9544       free(token);
9545     }
9546   }
9547
9548   /* read (and overwrite with) values that may be specified in config file */
9549   for (i = 0; image_config_vars[i].token != NULL; i++)
9550   {
9551     char *value = getHashEntry(setup_file_hash, image_config_vars[i].token);
9552
9553     /* (ignore definitions set to "[DEFAULT]" which are already initialized) */
9554     if (value != NULL && !strEqual(value, ARG_DEFAULT))
9555       *image_config_vars[i].value =
9556         get_token_parameter_value(image_config_vars[i].token, value);
9557   }
9558
9559   freeSetupFileHash(setup_file_hash);
9560 }
9561
9562 void LoadMenuDesignSettings()
9563 {
9564   char *filename_base = UNDEFINED_FILENAME, *filename_local;
9565
9566   InitMenuDesignSettings_Static();
9567   InitMenuDesignSettings_SpecialPreProcessing();
9568
9569   if (!GFX_OVERRIDE_ARTWORK(ARTWORK_TYPE_GRAPHICS))
9570   {
9571     /* first look for special settings configured in level series config */
9572     filename_base = getCustomArtworkLevelConfigFilename(ARTWORK_TYPE_GRAPHICS);
9573
9574     if (fileExists(filename_base))
9575       LoadMenuDesignSettingsFromFilename(filename_base);
9576   }
9577
9578   filename_local = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
9579
9580   if (filename_local != NULL && !strEqual(filename_base, filename_local))
9581     LoadMenuDesignSettingsFromFilename(filename_local);
9582
9583   InitMenuDesignSettings_SpecialPostProcessing();
9584 }
9585
9586 void LoadMenuDesignSettings_AfterGraphics()
9587 {
9588   InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics();
9589 }
9590
9591 void LoadUserDefinedEditorElementList(int **elements, int *num_elements)
9592 {
9593   char *filename = getEditorSetupFilename();
9594   SetupFileList *setup_file_list, *list;
9595   SetupFileHash *element_hash;
9596   int num_unknown_tokens = 0;
9597   int i;
9598
9599   if ((setup_file_list = loadSetupFileList(filename)) == NULL)
9600     return;
9601
9602   element_hash = newSetupFileHash();
9603
9604   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
9605     setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
9606
9607   /* determined size may be larger than needed (due to unknown elements) */
9608   *num_elements = 0;
9609   for (list = setup_file_list; list != NULL; list = list->next)
9610     (*num_elements)++;
9611
9612   /* add space for up to 3 more elements for padding that may be needed */
9613   *num_elements += 3;
9614
9615   /* free memory for old list of elements, if needed */
9616   checked_free(*elements);
9617
9618   /* allocate memory for new list of elements */
9619   *elements = checked_malloc(*num_elements * sizeof(int));
9620
9621   *num_elements = 0;
9622   for (list = setup_file_list; list != NULL; list = list->next)
9623   {
9624     char *value = getHashEntry(element_hash, list->token);
9625
9626     if (value == NULL)          /* try to find obsolete token mapping */
9627     {
9628       char *mapped_token = get_mapped_token(list->token);
9629
9630       if (mapped_token != NULL)
9631       {
9632         value = getHashEntry(element_hash, mapped_token);
9633
9634         free(mapped_token);
9635       }
9636     }
9637
9638     if (value != NULL)
9639     {
9640       (*elements)[(*num_elements)++] = atoi(value);
9641     }
9642     else
9643     {
9644       if (num_unknown_tokens == 0)
9645       {
9646         Error(ERR_INFO_LINE, "-");
9647         Error(ERR_INFO, "warning: unknown token(s) found in config file:");
9648         Error(ERR_INFO, "- config file: '%s'", filename);
9649
9650         num_unknown_tokens++;
9651       }
9652
9653       Error(ERR_INFO, "- token: '%s'", list->token);
9654     }
9655   }
9656
9657   if (num_unknown_tokens > 0)
9658     Error(ERR_INFO_LINE, "-");
9659
9660   while (*num_elements % 4)     /* pad with empty elements, if needed */
9661     (*elements)[(*num_elements)++] = EL_EMPTY;
9662
9663   freeSetupFileList(setup_file_list);
9664   freeSetupFileHash(element_hash);
9665
9666 #if 0
9667   for (i = 0; i < *num_elements; i++)
9668     printf("editor: element '%s' [%d]\n",
9669            element_info[(*elements)[i]].token_name, (*elements)[i]);
9670 #endif
9671 }
9672
9673 static struct MusicFileInfo *get_music_file_info_ext(char *basename, int music,
9674                                                      boolean is_sound)
9675 {
9676   SetupFileHash *setup_file_hash = NULL;
9677   struct MusicFileInfo tmp_music_file_info, *new_music_file_info;
9678   char *filename_music, *filename_prefix, *filename_info;
9679   struct
9680   {
9681     char *token;
9682     char **value_ptr;
9683   }
9684   token_to_value_ptr[] =
9685   {
9686     { "title_header",   &tmp_music_file_info.title_header       },
9687     { "artist_header",  &tmp_music_file_info.artist_header      },
9688     { "album_header",   &tmp_music_file_info.album_header       },
9689     { "year_header",    &tmp_music_file_info.year_header        },
9690
9691     { "title",          &tmp_music_file_info.title              },
9692     { "artist",         &tmp_music_file_info.artist             },
9693     { "album",          &tmp_music_file_info.album              },
9694     { "year",           &tmp_music_file_info.year               },
9695
9696     { NULL,             NULL                                    },
9697   };
9698   int i;
9699
9700   filename_music = (is_sound ? getCustomSoundFilename(basename) :
9701                     getCustomMusicFilename(basename));
9702
9703   if (filename_music == NULL)
9704     return NULL;
9705
9706   /* ---------- try to replace file extension ---------- */
9707
9708   filename_prefix = getStringCopy(filename_music);
9709   if (strrchr(filename_prefix, '.') != NULL)
9710     *strrchr(filename_prefix, '.') = '\0';
9711   filename_info = getStringCat2(filename_prefix, ".txt");
9712
9713   if (fileExists(filename_info))
9714     setup_file_hash = loadSetupFileHash(filename_info);
9715
9716   free(filename_prefix);
9717   free(filename_info);
9718
9719   if (setup_file_hash == NULL)
9720   {
9721     /* ---------- try to add file extension ---------- */
9722
9723     filename_prefix = getStringCopy(filename_music);
9724     filename_info = getStringCat2(filename_prefix, ".txt");
9725
9726     if (fileExists(filename_info))
9727       setup_file_hash = loadSetupFileHash(filename_info);
9728
9729     free(filename_prefix);
9730     free(filename_info);
9731   }
9732
9733   if (setup_file_hash == NULL)
9734     return NULL;
9735
9736   /* ---------- music file info found ---------- */
9737
9738   clear_mem(&tmp_music_file_info, sizeof(struct MusicFileInfo));
9739
9740   for (i = 0; token_to_value_ptr[i].token != NULL; i++)
9741   {
9742     char *value = getHashEntry(setup_file_hash, token_to_value_ptr[i].token);
9743
9744     *token_to_value_ptr[i].value_ptr =
9745       getStringCopy(value != NULL && *value != '\0' ? value : UNKNOWN_NAME);
9746   }
9747
9748   tmp_music_file_info.basename = getStringCopy(basename);
9749   tmp_music_file_info.music = music;
9750   tmp_music_file_info.is_sound = is_sound;
9751
9752   new_music_file_info = checked_malloc(sizeof(struct MusicFileInfo));
9753   *new_music_file_info = tmp_music_file_info;
9754
9755   return new_music_file_info;
9756 }
9757
9758 static struct MusicFileInfo *get_music_file_info(char *basename, int music)
9759 {
9760   return get_music_file_info_ext(basename, music, FALSE);
9761 }
9762
9763 static struct MusicFileInfo *get_sound_file_info(char *basename, int sound)
9764 {
9765   return get_music_file_info_ext(basename, sound, TRUE);
9766 }
9767
9768 static boolean music_info_listed_ext(struct MusicFileInfo *list,
9769                                      char *basename, boolean is_sound)
9770 {
9771   for (; list != NULL; list = list->next)
9772     if (list->is_sound == is_sound && strEqual(list->basename, basename))
9773       return TRUE;
9774
9775   return FALSE;
9776 }
9777
9778 static boolean music_info_listed(struct MusicFileInfo *list, char *basename)
9779 {
9780   return music_info_listed_ext(list, basename, FALSE);
9781 }
9782
9783 static boolean sound_info_listed(struct MusicFileInfo *list, char *basename)
9784 {
9785   return music_info_listed_ext(list, basename, TRUE);
9786 }
9787
9788 void LoadMusicInfo()
9789 {
9790   char *music_directory = getCustomMusicDirectory();
9791   int num_music = getMusicListSize();
9792   int num_music_noconf = 0;
9793   int num_sounds = getSoundListSize();
9794   Directory *dir;
9795   DirectoryEntry *dir_entry;
9796   struct FileInfo *music, *sound;
9797   struct MusicFileInfo *next, **new;
9798   int i;
9799
9800   while (music_file_info != NULL)
9801   {
9802     next = music_file_info->next;
9803
9804     checked_free(music_file_info->basename);
9805
9806     checked_free(music_file_info->title_header);
9807     checked_free(music_file_info->artist_header);
9808     checked_free(music_file_info->album_header);
9809     checked_free(music_file_info->year_header);
9810
9811     checked_free(music_file_info->title);
9812     checked_free(music_file_info->artist);
9813     checked_free(music_file_info->album);
9814     checked_free(music_file_info->year);
9815
9816     free(music_file_info);
9817
9818     music_file_info = next;
9819   }
9820
9821   new = &music_file_info;
9822
9823   for (i = 0; i < num_music; i++)
9824   {
9825     music = getMusicListEntry(i);
9826
9827     if (music->filename == NULL)
9828       continue;
9829
9830     if (strEqual(music->filename, UNDEFINED_FILENAME))
9831       continue;
9832
9833     /* a configured file may be not recognized as music */
9834     if (!FileIsMusic(music->filename))
9835       continue;
9836
9837     if (!music_info_listed(music_file_info, music->filename))
9838     {
9839       *new = get_music_file_info(music->filename, i);
9840
9841       if (*new != NULL)
9842         new = &(*new)->next;
9843     }
9844   }
9845
9846   if ((dir = openDirectory(music_directory)) == NULL)
9847   {
9848     Error(ERR_WARN, "cannot read music directory '%s'", music_directory);
9849     return;
9850   }
9851
9852   while ((dir_entry = readDirectory(dir)) != NULL)      /* loop all entries */
9853   {
9854     char *basename = dir_entry->basename;
9855     boolean music_already_used = FALSE;
9856     int i;
9857
9858     /* skip all music files that are configured in music config file */
9859     for (i = 0; i < num_music; i++)
9860     {
9861       music = getMusicListEntry(i);
9862
9863       if (music->filename == NULL)
9864         continue;
9865
9866       if (strEqual(basename, music->filename))
9867       {
9868         music_already_used = TRUE;
9869         break;
9870       }
9871     }
9872
9873     if (music_already_used)
9874       continue;
9875
9876     if (!FileIsMusic(dir_entry->filename))
9877       continue;
9878
9879     if (!music_info_listed(music_file_info, basename))
9880     {
9881       *new = get_music_file_info(basename, MAP_NOCONF_MUSIC(num_music_noconf));
9882
9883       if (*new != NULL)
9884         new = &(*new)->next;
9885     }
9886
9887     num_music_noconf++;
9888   }
9889
9890   closeDirectory(dir);
9891
9892   for (i = 0; i < num_sounds; i++)
9893   {
9894     sound = getSoundListEntry(i);
9895
9896     if (sound->filename == NULL)
9897       continue;
9898
9899     if (strEqual(sound->filename, UNDEFINED_FILENAME))
9900       continue;
9901
9902     /* a configured file may be not recognized as sound */
9903     if (!FileIsSound(sound->filename))
9904       continue;
9905
9906     if (!sound_info_listed(music_file_info, sound->filename))
9907     {
9908       *new = get_sound_file_info(sound->filename, i);
9909       if (*new != NULL)
9910         new = &(*new)->next;
9911     }
9912   }
9913 }
9914
9915 void add_helpanim_entry(int element, int action, int direction, int delay,
9916                         int *num_list_entries)
9917 {
9918   struct HelpAnimInfo *new_list_entry;
9919   (*num_list_entries)++;
9920
9921   helpanim_info =
9922     checked_realloc(helpanim_info,
9923                     *num_list_entries * sizeof(struct HelpAnimInfo));
9924   new_list_entry = &helpanim_info[*num_list_entries - 1];
9925
9926   new_list_entry->element = element;
9927   new_list_entry->action = action;
9928   new_list_entry->direction = direction;
9929   new_list_entry->delay = delay;
9930 }
9931
9932 void print_unknown_token(char *filename, char *token, int token_nr)
9933 {
9934   if (token_nr == 0)
9935   {
9936     Error(ERR_INFO_LINE, "-");
9937     Error(ERR_INFO, "warning: unknown token(s) found in config file:");
9938     Error(ERR_INFO, "- config file: '%s'", filename);
9939   }
9940
9941   Error(ERR_INFO, "- token: '%s'", token);
9942 }
9943
9944 void print_unknown_token_end(int token_nr)
9945 {
9946   if (token_nr > 0)
9947     Error(ERR_INFO_LINE, "-");
9948 }
9949
9950 void LoadHelpAnimInfo()
9951 {
9952   char *filename = getHelpAnimFilename();
9953   SetupFileList *setup_file_list = NULL, *list;
9954   SetupFileHash *element_hash, *action_hash, *direction_hash;
9955   int num_list_entries = 0;
9956   int num_unknown_tokens = 0;
9957   int i;
9958
9959   if (fileExists(filename))
9960     setup_file_list = loadSetupFileList(filename);
9961
9962   if (setup_file_list == NULL)
9963   {
9964     /* use reliable default values from static configuration */
9965     SetupFileList *insert_ptr;
9966
9967     insert_ptr = setup_file_list =
9968       newSetupFileList(helpanim_config[0].token,
9969                        helpanim_config[0].value);
9970
9971     for (i = 1; helpanim_config[i].token; i++)
9972       insert_ptr = addListEntry(insert_ptr,
9973                                 helpanim_config[i].token,
9974                                 helpanim_config[i].value);
9975   }
9976
9977   element_hash   = newSetupFileHash();
9978   action_hash    = newSetupFileHash();
9979   direction_hash = newSetupFileHash();
9980
9981   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
9982     setHashEntry(element_hash, element_info[i].token_name, i_to_a(i));
9983
9984   for (i = 0; i < NUM_ACTIONS; i++)
9985     setHashEntry(action_hash, element_action_info[i].suffix,
9986                  i_to_a(element_action_info[i].value));
9987
9988   /* do not store direction index (bit) here, but direction value! */
9989   for (i = 0; i < NUM_DIRECTIONS_FULL; i++)
9990     setHashEntry(direction_hash, element_direction_info[i].suffix,
9991                  i_to_a(1 << element_direction_info[i].value));
9992
9993   for (list = setup_file_list; list != NULL; list = list->next)
9994   {
9995     char *element_token, *action_token, *direction_token;
9996     char *element_value, *action_value, *direction_value;
9997     int delay = atoi(list->value);
9998
9999     if (strEqual(list->token, "end"))
10000     {
10001       add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
10002
10003       continue;
10004     }
10005
10006     /* first try to break element into element/action/direction parts;
10007        if this does not work, also accept combined "element[.act][.dir]"
10008        elements (like "dynamite.active"), which are unique elements */
10009
10010     if (strchr(list->token, '.') == NULL)       /* token contains no '.' */
10011     {
10012       element_value = getHashEntry(element_hash, list->token);
10013       if (element_value != NULL)        /* element found */
10014         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10015                            &num_list_entries);
10016       else
10017       {
10018         /* no further suffixes found -- this is not an element */
10019         print_unknown_token(filename, list->token, num_unknown_tokens++);
10020       }
10021
10022       continue;
10023     }
10024
10025     /* token has format "<prefix>.<something>" */
10026
10027     action_token = strchr(list->token, '.');    /* suffix may be action ... */
10028     direction_token = action_token;             /* ... or direction */
10029
10030     element_token = getStringCopy(list->token);
10031     *strchr(element_token, '.') = '\0';
10032
10033     element_value = getHashEntry(element_hash, element_token);
10034
10035     if (element_value == NULL)          /* this is no element */
10036     {
10037       element_value = getHashEntry(element_hash, list->token);
10038       if (element_value != NULL)        /* combined element found */
10039         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10040                            &num_list_entries);
10041       else
10042         print_unknown_token(filename, list->token, num_unknown_tokens++);
10043
10044       free(element_token);
10045
10046       continue;
10047     }
10048
10049     action_value = getHashEntry(action_hash, action_token);
10050
10051     if (action_value != NULL)           /* action found */
10052     {
10053       add_helpanim_entry(atoi(element_value), atoi(action_value), -1, delay,
10054                     &num_list_entries);
10055
10056       free(element_token);
10057
10058       continue;
10059     }
10060
10061     direction_value = getHashEntry(direction_hash, direction_token);
10062
10063     if (direction_value != NULL)        /* direction found */
10064     {
10065       add_helpanim_entry(atoi(element_value), -1, atoi(direction_value), delay,
10066                          &num_list_entries);
10067
10068       free(element_token);
10069
10070       continue;
10071     }
10072
10073     if (strchr(action_token + 1, '.') == NULL)
10074     {
10075       /* no further suffixes found -- this is not an action nor direction */
10076
10077       element_value = getHashEntry(element_hash, list->token);
10078       if (element_value != NULL)        /* combined element found */
10079         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10080                            &num_list_entries);
10081       else
10082         print_unknown_token(filename, list->token, num_unknown_tokens++);
10083
10084       free(element_token);
10085
10086       continue;
10087     }
10088
10089     /* token has format "<prefix>.<suffix>.<something>" */
10090
10091     direction_token = strchr(action_token + 1, '.');
10092
10093     action_token = getStringCopy(action_token);
10094     *strchr(action_token + 1, '.') = '\0';
10095
10096     action_value = getHashEntry(action_hash, action_token);
10097
10098     if (action_value == NULL)           /* this is no action */
10099     {
10100       element_value = getHashEntry(element_hash, list->token);
10101       if (element_value != NULL)        /* combined element found */
10102         add_helpanim_entry(atoi(element_value), -1, -1, delay,
10103                            &num_list_entries);
10104       else
10105         print_unknown_token(filename, list->token, num_unknown_tokens++);
10106
10107       free(element_token);
10108       free(action_token);
10109
10110       continue;
10111     }
10112
10113     direction_value = getHashEntry(direction_hash, direction_token);
10114
10115     if (direction_value != NULL)        /* direction found */
10116     {
10117       add_helpanim_entry(atoi(element_value), atoi(action_value),
10118                          atoi(direction_value), delay, &num_list_entries);
10119
10120       free(element_token);
10121       free(action_token);
10122
10123       continue;
10124     }
10125
10126     /* this is no direction */
10127
10128     element_value = getHashEntry(element_hash, list->token);
10129     if (element_value != NULL)          /* combined element found */
10130       add_helpanim_entry(atoi(element_value), -1, -1, delay,
10131                          &num_list_entries);
10132     else
10133       print_unknown_token(filename, list->token, num_unknown_tokens++);
10134
10135     free(element_token);
10136     free(action_token);
10137   }
10138
10139   print_unknown_token_end(num_unknown_tokens);
10140
10141   add_helpanim_entry(HELPANIM_LIST_NEXT, -1, -1, -1, &num_list_entries);
10142   add_helpanim_entry(HELPANIM_LIST_END,  -1, -1, -1, &num_list_entries);
10143
10144   freeSetupFileList(setup_file_list);
10145   freeSetupFileHash(element_hash);
10146   freeSetupFileHash(action_hash);
10147   freeSetupFileHash(direction_hash);
10148
10149 #if 0
10150   for (i = 0; i < num_list_entries; i++)
10151     printf("::: '%s': %d, %d, %d => %d\n",
10152            EL_NAME(helpanim_info[i].element),
10153            helpanim_info[i].element,
10154            helpanim_info[i].action,
10155            helpanim_info[i].direction,
10156            helpanim_info[i].delay);
10157 #endif
10158 }
10159
10160 void LoadHelpTextInfo()
10161 {
10162   char *filename = getHelpTextFilename();
10163   int i;
10164
10165   if (helptext_info != NULL)
10166   {
10167     freeSetupFileHash(helptext_info);
10168     helptext_info = NULL;
10169   }
10170
10171   if (fileExists(filename))
10172     helptext_info = loadSetupFileHash(filename);
10173
10174   if (helptext_info == NULL)
10175   {
10176     /* use reliable default values from static configuration */
10177     helptext_info = newSetupFileHash();
10178
10179     for (i = 0; helptext_config[i].token; i++)
10180       setHashEntry(helptext_info,
10181                    helptext_config[i].token,
10182                    helptext_config[i].value);
10183   }
10184
10185 #if 0
10186   BEGIN_HASH_ITERATION(helptext_info, itr)
10187   {
10188     printf("::: '%s' => '%s'\n",
10189            HASH_ITERATION_TOKEN(itr), HASH_ITERATION_VALUE(itr));
10190   }
10191   END_HASH_ITERATION(hash, itr)
10192 #endif
10193 }
10194
10195
10196 /* ------------------------------------------------------------------------- */
10197 /* convert levels                                                            */
10198 /* ------------------------------------------------------------------------- */
10199
10200 #define MAX_NUM_CONVERT_LEVELS          1000
10201
10202 void ConvertLevels()
10203 {
10204   static LevelDirTree *convert_leveldir = NULL;
10205   static int convert_level_nr = -1;
10206   static int num_levels_handled = 0;
10207   static int num_levels_converted = 0;
10208   static boolean levels_failed[MAX_NUM_CONVERT_LEVELS];
10209   int i;
10210
10211   convert_leveldir = getTreeInfoFromIdentifier(leveldir_first,
10212                                                global.convert_leveldir);
10213
10214   if (convert_leveldir == NULL)
10215     Error(ERR_EXIT, "no such level identifier: '%s'",
10216           global.convert_leveldir);
10217
10218   leveldir_current = convert_leveldir;
10219
10220   if (global.convert_level_nr != -1)
10221   {
10222     convert_leveldir->first_level = global.convert_level_nr;
10223     convert_leveldir->last_level  = global.convert_level_nr;
10224   }
10225
10226   convert_level_nr = convert_leveldir->first_level;
10227
10228   PrintLine("=", 79);
10229   Print("Converting levels\n");
10230   PrintLine("-", 79);
10231   Print("Level series identifier: '%s'\n", convert_leveldir->identifier);
10232   Print("Level series name:       '%s'\n", convert_leveldir->name);
10233   Print("Level series author:     '%s'\n", convert_leveldir->author);
10234   Print("Number of levels:        %d\n",   convert_leveldir->levels);
10235   PrintLine("=", 79);
10236   Print("\n");
10237
10238   for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
10239     levels_failed[i] = FALSE;
10240
10241   while (convert_level_nr <= convert_leveldir->last_level)
10242   {
10243     char *level_filename;
10244     boolean new_level;
10245
10246     level_nr = convert_level_nr++;
10247
10248     Print("Level %03d: ", level_nr);
10249
10250     LoadLevel(level_nr);
10251     if (level.no_level_file || level.no_valid_file)
10252     {
10253       Print("(no level)\n");
10254       continue;
10255     }
10256
10257     Print("converting level ... ");
10258
10259     level_filename = getDefaultLevelFilename(level_nr);
10260     new_level = !fileExists(level_filename);
10261
10262     if (new_level)
10263     {
10264       SaveLevel(level_nr);
10265
10266       num_levels_converted++;
10267
10268       Print("converted.\n");
10269     }
10270     else
10271     {
10272       if (level_nr >= 0 && level_nr < MAX_NUM_CONVERT_LEVELS)
10273         levels_failed[level_nr] = TRUE;
10274
10275       Print("NOT CONVERTED -- LEVEL ALREADY EXISTS.\n");
10276     }
10277
10278     num_levels_handled++;
10279   }
10280
10281   Print("\n");
10282   PrintLine("=", 79);
10283   Print("Number of levels handled: %d\n", num_levels_handled);
10284   Print("Number of levels converted: %d (%d%%)\n", num_levels_converted,
10285          (num_levels_handled ?
10286           num_levels_converted * 100 / num_levels_handled : 0));
10287   PrintLine("-", 79);
10288   Print("Summary (for automatic parsing by scripts):\n");
10289   Print("LEVELDIR '%s', CONVERTED %d/%d (%d%%)",
10290          convert_leveldir->identifier, num_levels_converted,
10291          num_levels_handled,
10292          (num_levels_handled ?
10293           num_levels_converted * 100 / num_levels_handled : 0));
10294
10295   if (num_levels_handled != num_levels_converted)
10296   {
10297     Print(", FAILED:");
10298     for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
10299       if (levels_failed[i])
10300         Print(" %03d", i);
10301   }
10302
10303   Print("\n");
10304   PrintLine("=", 79);
10305
10306   CloseAllAndExit(0);
10307 }
10308
10309
10310 /* ------------------------------------------------------------------------- */
10311 /* create and save images for use in level sketches (raw BMP format)         */
10312 /* ------------------------------------------------------------------------- */
10313
10314 void CreateLevelSketchImages()
10315 {
10316 #if defined(TARGET_SDL)
10317   Bitmap *bitmap1;
10318   Bitmap *bitmap2;
10319   int i;
10320
10321   InitElementPropertiesGfxElement();
10322
10323   bitmap1 = CreateBitmap(TILEX, TILEY, DEFAULT_DEPTH);
10324   bitmap2 = CreateBitmap(MINI_TILEX, MINI_TILEY, DEFAULT_DEPTH);
10325
10326   for (i = 0; i < NUM_FILE_ELEMENTS; i++)
10327   {
10328     Bitmap *src_bitmap;
10329     int src_x, src_y;
10330     int element = getMappedElement(i);
10331     int graphic = el2edimg(element);
10332     char basename1[16];
10333     char basename2[16];
10334     char *filename1;
10335     char *filename2;
10336
10337     sprintf(basename1, "%03d.bmp", i);
10338     sprintf(basename2, "%03ds.bmp", i);
10339
10340     filename1 = getPath2(global.create_images_dir, basename1);
10341     filename2 = getPath2(global.create_images_dir, basename2);
10342
10343     getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
10344     BlitBitmap(src_bitmap, bitmap1, src_x, src_y, TILEX, TILEY,
10345                0, 0);
10346
10347     if (SDL_SaveBMP(bitmap1->surface, filename1) != 0)
10348       Error(ERR_EXIT, "cannot save level sketch image file '%s'", filename1);
10349
10350     getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
10351     BlitBitmap(src_bitmap, bitmap2, src_x, src_y, MINI_TILEX, MINI_TILEY, 0, 0);
10352
10353     if (SDL_SaveBMP(bitmap2->surface, filename2) != 0)
10354       Error(ERR_EXIT, "cannot save level sketch image file '%s'", filename2);
10355
10356     free(filename1);
10357     free(filename2);
10358
10359     if (options.debug)
10360       printf("%03d `%03d%c", i, i, (i % 10 < 9 ? ' ' : '\n'));
10361   }
10362
10363   FreeBitmap(bitmap1);
10364   FreeBitmap(bitmap2);
10365
10366   if (options.debug)
10367     printf("\n");
10368
10369   Error(ERR_INFO, "%d normal and small images created", NUM_FILE_ELEMENTS);
10370
10371   CloseAllAndExit(0);
10372 #endif
10373 }
10374
10375
10376 /* ------------------------------------------------------------------------- */
10377 /* create and save images for custom and group elements (raw BMP format)     */
10378 /* ------------------------------------------------------------------------- */
10379
10380 void CreateCustomElementImages(char *directory)
10381 {
10382 #if defined(TARGET_SDL)
10383   char *src_basename = "RocksCE-template.ilbm";
10384   char *dst_basename = "RocksCE.bmp";
10385   char *src_filename = getPath2(directory, src_basename);
10386   char *dst_filename = getPath2(directory, dst_basename);
10387   Bitmap *src_bitmap;
10388   Bitmap *bitmap;
10389   int yoffset_ce = 0;
10390   int yoffset_ge = (TILEY * NUM_CUSTOM_ELEMENTS / 16);
10391   int i;
10392
10393   SDLInitVideoDisplay();
10394
10395   ReCreateBitmap(&backbuffer, video.width, video.height);
10396
10397   src_bitmap = LoadImage(src_filename);
10398
10399   bitmap = CreateBitmap(TILEX * 16 * 2,
10400                         TILEY * (NUM_CUSTOM_ELEMENTS + NUM_GROUP_ELEMENTS) / 16,
10401                         DEFAULT_DEPTH);
10402
10403   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10404   {
10405     int x = i % 16;
10406     int y = i / 16;
10407     int ii = i + 1;
10408     int j;
10409
10410     BlitBitmap(src_bitmap, bitmap, 0, 0, TILEX, TILEY,
10411                TILEX * x, TILEY * y + yoffset_ce);
10412
10413     BlitBitmap(src_bitmap, bitmap, 0, TILEY,
10414                TILEX, TILEY,
10415                TILEX * x + TILEX * 16,
10416                TILEY * y + yoffset_ce);
10417
10418     for (j = 2; j >= 0; j--)
10419     {
10420       int c = ii % 10;
10421
10422       BlitBitmap(src_bitmap, bitmap,
10423                  TILEX + c * 7, 0, 6, 10,
10424                  TILEX * x + 6 + j * 7,
10425                  TILEY * y + 11 + yoffset_ce);
10426
10427       BlitBitmap(src_bitmap, bitmap,
10428                  TILEX + c * 8, TILEY, 6, 10,
10429                  TILEX * 16 + TILEX * x + 6 + j * 8,
10430                  TILEY * y + 10 + yoffset_ce);
10431
10432       ii /= 10;
10433     }
10434   }
10435
10436   for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
10437   {
10438     int x = i % 16;
10439     int y = i / 16;
10440     int ii = i + 1;
10441     int j;
10442
10443     BlitBitmap(src_bitmap, bitmap, 0, 0, TILEX, TILEY,
10444                TILEX * x, TILEY * y + yoffset_ge);
10445
10446     BlitBitmap(src_bitmap, bitmap, 0, TILEY,
10447                TILEX, TILEY,
10448                TILEX * x + TILEX * 16,
10449                TILEY * y + yoffset_ge);
10450
10451     for (j = 1; j >= 0; j--)
10452     {
10453       int c = ii % 10;
10454
10455       BlitBitmap(src_bitmap, bitmap, TILEX + c * 10, 11, 10, 10,
10456                  TILEX * x + 6 + j * 10,
10457                  TILEY * y + 11 + yoffset_ge);
10458
10459       BlitBitmap(src_bitmap, bitmap,
10460                  TILEX + c * 8, TILEY + 12, 6, 10,
10461                  TILEX * 16 + TILEX * x + 10 + j * 8,
10462                  TILEY * y + 10 + yoffset_ge);
10463
10464       ii /= 10;
10465     }
10466   }
10467
10468   if (SDL_SaveBMP(bitmap->surface, dst_filename) != 0)
10469     Error(ERR_EXIT, "cannot save CE graphics file '%s'", dst_filename);
10470
10471   FreeBitmap(bitmap);
10472
10473   CloseAllAndExit(0);
10474 #endif
10475 }