src/files.c

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