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