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