src/game_em/convert.c

   1 /* 2000-08-20T09:41:18Z
   2  *
   3  * identify all emerald mine caves and turn them into v6 format.
   4  * fixes illegal tiles, acid, wheel, limits times, cleans flags.
   5  *
   6  * these tables weed out bad tiles for older caves (eg. wheel on -> wheel off)
   7  * and clean up v6 caves (acid, number limits) which should(!) be
   8  * inconsequential, but no doubt it will break some caves.
   9  */
  10
  11 #include "main_em.h"
  12
  13
  14 #define ALLOW_ROLLING_SPRING
  15
  16 static unsigned char remap_v6[256] =
  17 {
  18   /* filter crap for v6 */
  19
  20   0,0,2,2,         4,4,118,118,     8,9,10,11,       12,13,14,15,
  21   16,16,18,18,     20,21,22,23,     24,25,26,27,     28,28,118,28,
  22   0,16,2,18,       36,37,37,37,     40,41,42,43,     44,45,128,128,
  23   128,148,148,     148,45,45,45,    148,0,57,58,     59,60,61,62,63,
  24
  25 #ifdef ALLOW_ROLLING_SPRING
  26   64,65,66,67,     68,69,69,71,     72,73,74,75,     118,75,75,75,
  27 #else
  28   64,65,66,67,     68,69,69,69,     69,73,74,75,     118,75,75,75,
  29 #endif
  30   75,75,75,75,     75,153,153,153,  153,153,153,153, 153,153,153,153,
  31   153,153,153,99,  100,68,68,68,    68,68,68,68,     68,118,118,118,
  32   118,118,114,115, 131,118,118,119, 120,121,122,118, 118,118,118,118,
  33
  34   128,129,130,131, 132,133,134,135, 136,137,138,139, 140,141,142,143,
  35   144,145,146,147, 148,149,150,151, 152,153,154,155, 156,157,158,159,
  36   160,161,162,163, 164,165,165,118, 168,169,170,171, 172,173,174,175,
  37   176,177,178,179, 180,181,182,183, 184,185,186,187, 188,189,68,191,
  38
  39   192,193,194,195, 196,197,198,199, 200,201,202,203, 204,205,206,207,
  40   208,209,210,211, 212,213,214,215, 216,217,218,219, 220,221,222,223,
  41   224,225,226,227, 228,229,230,231, 232,233,234,235, 236,237,238,239,
  42   240,241,242,243, 244,245,153,153, 153,153,153,153, 153,153,153,153
  43 };
  44
  45 static unsigned char remap_v5[256] =
  46 {
  47   /* filter crap for v5 */
  48
  49   0,0,2,2,         4,4,118,118,     8,9,10,11,       12,13,14,15,
  50   16,16,18,18,     20,21,22,23,     24,25,26,27,     28,28,118,28,
  51   0,16,2,18,       36,37,37,37,     147,41,42,43,    44,45,128,128,
  52   128,148,148,148, 45,45,45,148,    0,57,58,59,      60,61,62,63,
  53
  54   64,65,66,67,     68,153,153,153,  153,153,153,153, 153,153,153,153,
  55   153,153,153,153, 153,153,153,153, 153,153,153,153, 153,153,153,153,
  56   153,153,153,153, 153,68,68,68,68, 68,68,68,68,118, 118,118,
  57   118,118,114,115, 131,118,118,119, 120,121,122,118, 118,118,118,118,
  58
  59   128,129,130,131, 132,133,134,135, 136,137,138,139, 140,141,142,143,
  60   144,145,146,147, 148,149,150,151, 152,153,154,155, 156,157,158,159,
  61   160,153,153,153, 153,153,153,118, 168,169,170,171, 172,173,174,175,
  62   176,177,178,179, 180,181,182,183, 184,185,186,187, 188,189,68,153,
  63
  64   153,153,153,153, 153,153,153,153, 200,201,202,203, 204,205,206,207,
  65   208,209,210,211, 212,213,214,215, 216,217,218,219, 220,221,222,223,
  66   224,225,226,227, 228,229,230,231, 232,233,234,235, 236,237,238,239,
  67   240,241,153,153, 153,153,153,153, 153,153,153,153, 153,153,153,153
  68 };
  69
  70 static unsigned char remap_v4[256] =
  71 {
  72   /* filter crap for v4 */
  73
  74   0,0,2,2,         4,4,118,118,     8,9,10,11,       12,13,14,15,
  75   16,16,18,18,     20,21,22,23,     24,25,26,27,     28,28,118,28,
  76   0,16,2,18,       36,37,37,37,     147,41,42,43,    44,45,128,128,
  77   128,148,148,148, 45,45,45,148,    0,153,153,59,    60,61,62,63,
  78
  79   64,65,66,153,    153,153,153,153, 153,153,153,153, 153,153,153,153,
  80   153,153,153,153, 153,153,153,153, 153,153,153,153, 153,153,153,153,
  81   153,153,153,153, 153,153,153,153, 153,153,153,153, 153,153,153,153,
  82   153,118,114,115, 131,118,118,119, 120,121,122,118, 118,118,118,118,
  83
  84   128,129,130,131, 132,133,134,135, 136,137,138,139, 140,141,142,143,
  85   144,145,146,147, 148,149,150,151, 152,68,154,155,  156,157,158,160,
  86   160,160,160,160, 160,160,160,160, 160,160,160,160, 160,160,160,175,
  87   153,153,153,153, 153,153,153,153, 153,153,153,153, 153,153,68,153,
  88
  89   153,153,153,153, 153,153,153,153, 200,201,202,203, 204,205,206,207,
  90   208,209,210,211, 212,213,214,215, 216,217,218,219, 220,221,222,223,
  91   224,225,226,227, 228,229,230,231, 232,233,234,235, 236,237,238,239,
  92   240,241,153,153, 153,153,153,153, 153,153,153,153, 153,153,153,153
  93 };
  94
  95 static unsigned char remap_v4eater[28] =
  96 {
  97   /* filter crap for v4 */
  98
  99   128,18,2,0,4,8,16,20,28,37,
 100   41,45,130,129,131,132,133,134,135,136,
 101   146,147,175,65,66,64,2,18
 102 };
 103
 104 static boolean filename_has_v1_format(char *filename)
 105 {
 106   char *basename = getBaseNamePtr(filename);
 107
 108   return (strlen(basename) == 3 &&
 109           basename[0] == 'a' &&
 110           basename[1] >= 'a' && basename[1] <= 'k' &&
 111           basename[2] >= '0' && basename[2] <= '9');
 112 }
 113
 114 int cleanup_em_level(unsigned char *src, int length, char *filename)
 115 {
 116   int file_version = FILE_VERSION_EM_UNKNOWN;
 117   int i;
 118
 119   if (length >= 2172 &&
 120       src[2106] == 255 &&               /* version id: */
 121       src[2107] == 54 &&                /* '6' */
 122       src[2108] == 48 &&                /* '0' */
 123       src[2109] == 48)                  /* '0' */
 124   {
 125     /* ---------- this cave has V6 file format ---------- */
 126     file_version = FILE_VERSION_EM_V6;
 127
 128     /* remap elements to internal EMC level format */
 129     for (i = 0; i < 2048; i++)
 130       src[i] = remap_v6[src[i]];
 131     for (i = 2048; i < 2084; i++)
 132       src[i] = remap_v6[src[i]];
 133     for (i = 2112; i < 2148; i++)
 134       src[i] = remap_v6[src[i]];
 135   }
 136   else if (length >= 2110 &&
 137            src[2106] == 255 &&          /* version id: */
 138            src[2107] == 53 &&           /* '5' */
 139            src[2108] == 48 &&           /* '0' */
 140            src[2109] == 48)             /* '0' */
 141   {
 142     /* ---------- this cave has V5 file format ---------- */
 143     file_version = FILE_VERSION_EM_V5;
 144
 145     /* remap elements to internal EMC level format */
 146     for (i = 0; i < 2048; i++)
 147       src[i] = remap_v5[src[i]];
 148     for (i = 2048; i < 2084; i++)
 149       src[i] = remap_v5[src[i]];
 150     for (i = 2112; i < 2148; i++)
 151       src[i] = src[i - 64];
 152   }
 153   else if (length >= 2106 &&
 154            (src[1983] == 27 ||          /* encrypted (only EM I/II/III) */
 155             src[1983] == 116 ||         /* unencrypted (usual case) */
 156             src[1983] == 131))          /* unencrypted (rare case) */
 157   {
 158     /* ---------- this cave has V1, V2 or V3 file format ---------- */
 159
 160     boolean fix_copyright = FALSE;
 161
 162     /*
 163       byte at position 1983 (0x07bf) is used as "magic byte":
 164       - 27  (0x1b)      => encrypted level (V3 only / Kingsoft original games)
 165       - 116 (0x74)      => unencrypted level (byte is corrected to 131 (0x83))
 166       - 131 (0x83)      => unencrypted level (happens only in very rare cases)
 167     */
 168
 169     if (src[1983] == 27)        /* (0x1b) -- after decryption: 116 (0x74) */
 170     {
 171       /* this is original (encrypted) Emerald Mine I, II or III level file */
 172
 173       int first_byte = src[0];
 174       unsigned char code0 = 0x65;
 175       unsigned char code1 = 0x11;
 176
 177       /* decode encrypted level data */
 178       for (i = 0; i < 2106; i++)
 179       {
 180         src[i] ^= code0;
 181         src[i] -= code1;
 182
 183         code0 = (code0 + 7) & 0xff;
 184       }
 185
 186       src[1] = 131;             /* needed for all Emerald Mine levels */
 187
 188       /* first byte is either 0xf1 (EM I and III) or 0xf5 (EM II) */
 189       if (first_byte == 0xf5)
 190       {
 191         src[0] = 131;           /* only needed for Emerald Mine II levels */
 192
 193         fix_copyright = TRUE;
 194       }
 195
 196       /* ---------- this cave has V3 file format ---------- */
 197       file_version = FILE_VERSION_EM_V3;
 198     }
 199     else if (filename_has_v1_format(filename))
 200     {
 201       /* ---------- this cave has V1 file format ---------- */
 202       file_version = FILE_VERSION_EM_V1;
 203     }
 204     else
 205     {
 206       /* ---------- this cave has V2 file format ---------- */
 207       file_version = FILE_VERSION_EM_V2;
 208     }
 209
 210     /* remap elements to internal EMC level format */
 211     for (i = 0; i < 2048; i++)
 212       src[i] = remap_v4[src[i]];
 213     for (i = 2048; i < 2084; i++)
 214       src[i] = remap_v4eater[src[i] >= 28 ? 0 : src[i]];
 215     for (i = 2112; i < 2148; i++)
 216       src[i] = src[i - 64];
 217
 218     if (fix_copyright)          /* fix "(c)" sign in Emerald Mine II levels */
 219     {
 220       for (i = 0; i < 2048; i++)
 221         if (src[i] == 241)
 222           src[i] = 254;         /* replace 'Xdecor_1' with 'Xalpha_copyr' */
 223     }
 224   }
 225   else
 226   {
 227     /* ---------- this cave has unknown file format ---------- */
 228
 229     /* if file has length of old-style level file, print (wrong) magic byte */
 230     if (length < 2110)
 231       Error(ERR_WARN, "unknown magic byte 0x%02x at position 0x%04x",
 232             src[1983], 1983);
 233
 234     return FILE_VERSION_EM_UNKNOWN;
 235   }
 236
 237   if (file_version < FILE_VERSION_EM_V6)
 238   {
 239     /* id */
 240     src[2106] = 255;            /* version id: */
 241     src[2107] = 54;             /* '6' */
 242     src[2108] = 48;             /* '0' */
 243     src[2109] = 48;             /* '0' */
 244
 245     /* time */
 246     i = src[2094] * 10;
 247     /* stored level time of levels for the V2 player was changed to 50% of the
 248        time for the V1 player (original V3 levels already considered this) */
 249     if (file_version != FILE_VERSION_EM_V1 &&
 250         file_version != FILE_VERSION_EM_V3)
 251       i /= 2;
 252     src[2110] = i >> 8;
 253     src[2111] = i;
 254
 255     for (i = 2148; i < 2172; i++)
 256       src[i] = 0;
 257
 258     /* ball data */
 259     src[2159] = 128;
 260   }
 261
 262   /* ---------- at this stage, the cave data always has V6 format ---------- */
 263
 264   /* fix wheel */
 265   for (i = 0; i < 2048; i++)
 266     if (src[i] == 40)
 267       break;
 268   for (i++; i < 2048; i++)
 269     if (src[i] == 40)
 270       src[i] = 147;
 271
 272 #if 0
 273
 274   /* fix acid */
 275   for (i = 64; i < 2048; i++)
 276     if (src[i] == 63)           /* replace element above 'Xacid_s' ... */
 277       src[i - 64] = 101;        /* ... with 'Xacid_1' */
 278
 279 #else
 280
 281 #if 1
 282   /* fix acid */
 283   for (i = 64; i < 2048; i++)
 284     if (src[i] == 63)           /* replace element above 'Xacid_s' ... */
 285       src[i - 64] = 101;        /* ... with 'Xacid_1' */
 286
 287   /* fix acid with no base beneath it (see below for details (*)) */
 288   for (i = 64; i < 2048 - 1; i++)
 289   {
 290     if (file_version <= FILE_VERSION_EM_V2 &&
 291         src[i - 64] == 101 && src[i] != 63)     /* acid without base */
 292     {
 293       if (src[i - 1] == 101 ||                  /* remove acid over acid row */
 294           src[i + 1] == 101)
 295         src[i - 64] = 6;        /* replace element above with 'Xblank' */
 296       else
 297         src[i - 64] = 255;      /* replace element above with 'Xfake_acid_1' */
 298     }
 299   }
 300
 301 #else
 302
 303   /* fix acid */
 304   for (i = 64; i < 2048; i++)
 305   {
 306     if (src[i] == 63)           /* 'Xacid_s' (acid pool, bottom middle) */
 307     {
 308       if (file_version <= FILE_VERSION_EM_V2 &&
 309           i < 2048 - 64 && src[i + 64] == 63)
 310       {
 311         int obj_left  = remap_emerald[src[i - 1]];
 312         int obj_right = remap_emerald[src[i + 1]];
 313
 314         if (obj_left == Xblank || obj_right == Xblank ||
 315             obj_left == Xplant || obj_right == Xplant)
 316           src[i - 64] = 6;      /* replace element above with 'Xblank' */
 317         else
 318           src[i - 64] = 255;    /* replace element above with 'Xfake_acid_1' */
 319       }
 320       else
 321       {
 322         src[i - 64] = 101;      /* replace element above with 'Xacid_1' */
 323       }
 324     }
 325   }
 326 #endif
 327 #endif
 328
 329   /* fix acid in eater 1 */
 330   for (i = 2051; i < 2057; i++)
 331     if (src[i] == 63)
 332       src[i - 3] = 101;
 333
 334   /* fix acid in eater 2 */
 335   for (i = 2060; i < 2066; i++)
 336     if (src[i] == 63)
 337       src[i - 3] = 101;
 338
 339   /* fix acid in eater 3 */
 340   for (i = 2069; i < 2075; i++)
 341     if (src[i] == 63)
 342       src[i - 3] = 101;
 343
 344   /* fix acid in eater 4 */
 345   for (i = 2078; i < 2084; i++)
 346     if (src[i] == 63)
 347       src[i - 3] = 101;
 348
 349   /* fix acid in eater 5 */
 350   for (i = 2115; i < 2121; i++)
 351     if (src[i] == 63)
 352       src[i - 3] = 101;
 353
 354   /* fix acid in eater 6 */
 355   for (i = 2124; i < 2130; i++)
 356     if (src[i] == 63)
 357       src[i - 3] = 101;
 358
 359   /* fix acid in eater 7 */
 360   for (i = 2133; i < 2139; i++)
 361     if (src[i] == 63)
 362       src[i - 3] = 101;
 363
 364   /* fix acid in eater 8 */
 365   for (i = 2142; i < 2148; i++)
 366     if (src[i] == 63)
 367       src[i - 3] = 101;
 368
 369   /* old style time */
 370   src[2094] = 0;
 371
 372   /* player 1 pos */
 373   src[2096] &= 7;
 374   src[src[2096] << 8 | src[2097]] = 128;
 375
 376   /* player 2 pos */
 377   src[2098] &= 7;
 378   src[src[2098] << 8 | src[2099]] = 128;
 379
 380   /* amoeba speed */
 381   if ((src[2100] << 8 | src[2101]) > 9999)
 382   {
 383     src[2100] = 39;
 384     src[2101] = 15;
 385   }
 386
 387   /* time wonderwall */
 388   if ((src[2102] << 8 | src[2103]) > 9999)
 389   {
 390     src[2102] = 39;
 391     src[2103] = 15;
 392   }
 393
 394   /* time */
 395   if ((src[2110] << 8 | src[2111]) > 9999)
 396   {
 397     src[2110] = 39;
 398     src[2111] = 15;
 399   }
 400
 401   /* wind direction */
 402   i = src[2149];
 403   i &= 15;
 404   i &= -i;
 405   src[2149] = i;
 406
 407   /* time lenses */
 408   if ((src[2154] << 8 | src[2155]) > 9999)
 409   {
 410     src[2154] = 39;
 411     src[2155] = 15;
 412   }
 413
 414   /* time magnify */
 415   if ((src[2156] << 8 | src[2157]) > 9999)
 416   {
 417     src[2156] = 39;
 418     src[2157] = 15;
 419   }
 420
 421   /* ball object */
 422   src[2158] = 0;
 423   src[2159] = remap_v6[src[2159]];
 424
 425   /* ball pause */
 426   if ((src[2160] << 8 | src[2161]) > 9999)
 427   {
 428     src[2160] = 39;
 429     src[2161] = 15;
 430   }
 431
 432   /* ball data */
 433   src[2162] &= 129;
 434   if (src[2162] & 1)
 435     src[2163] = 0;
 436
 437   /* android move pause */
 438   if ((src[2164] << 8 | src[2165]) > 9999)
 439   {
 440     src[2164] = 39;
 441     src[2165] = 15;
 442   }
 443
 444   /* android clone pause */
 445   if ((src[2166] << 8 | src[2167]) > 9999)
 446   {
 447     src[2166] = 39;
 448     src[2167] = 15;
 449   }
 450
 451   /* android data */
 452   src[2168] &= 31;
 453
 454   /* size of v6 cave */
 455   length = 2172;
 456
 457   if (options.debug)
 458     printf("::: EM level file version: %d\n", file_version);
 459
 460   return file_version;
 461 }
 462
 463 /* 2000-07-30T00:26:00Z
 464  *
 465  * Read emerald mine caves version 6
 466  *
 467  * v4 and v5 emerald mine caves are converted to v6 (which completely supports
 468  * older versions)
 469  *
 470  * converting to the internal format loses /significant/ information which can
 471  * break lots of caves.
 472  *
 473  * major incompatibilities:
 474  * - borderless caves behave completely differently, the player no longer
 475  *   "warps" to the other side.
 476  * - a compile time option for spring can make it behave differently when it
 477  *   rolls.
 478  * - a compile time option for rolling objects (stone, nut, spring, bomb) only
 479  *   in eater.
 480  * - acid is always deadly even with no base beneath it (this breaks cave 0 in
 481  *   downunder mine 16)
 482  *   (*) fixed (see above):
 483  *       - downunder mine 16, level 0, works again
 484  *       - downunder mine 11, level 71, corrected (only cosmetically)
 485  *
 486  * so far all below have not broken any caves:
 487  *
 488  * - active wheel inside an eater will not function, eater explosions will not
 489  *   change settings.
 490  * - initial collect objects (emerald, diamond, dynamite) don't exist.
 491  * - initial rolling objects will be moved manually and made into sitting
 492  *   objects.
 493  * - drips always appear from dots.
 494  * - more than one thing can fall into acid at the same time.
 495  * - acid explodes when the player walks into it, rather than splashing.
 496  * - simultaneous explosions may be in a slightly different order.
 497  * - quicksand states have been reduced.
 498  * - acid base is effectively an indestructable wall now which can affect eater
 499  *   explosions.
 500  * - android can clone forever with a clone pause of 0 (emeralds, diamonds,
 501  *   nuts, stones, bombs, springs).
 502  *
 503  * 2001-03-12T02:46:55Z
 504  * - rolling stuff is now allowed in the cave, i didn't like making this
 505  *   decision.
 506  * - if BAD_ROLL is not defined, initial rolling objects are moved by hand.
 507  * - initial collect objects break some cave in elvis mine 5.
 508  * - different timing for wonderwall break some cave in exception mine 2.
 509  * - i think i'm pretty locked into always using the bad roll. *sigh*
 510  * - rolling spring is now turned into regular spring. it appears the emc
 511  *   editor only uses the force code for initially moving spring. i will
 512  *   follow this in my editor.
 513  *
 514  * 2006-04-02
 515  * - introduced ALLOW_ROLLING_SPRING; if defined, do NOT turn rolling spring
 516  *   into regular spring, because this breaks at least E.M.C. Mine 3, level 79
 517  *   (see comment directly above)
 518  */
 519
 520 static unsigned short remap_emerald[256] =
 521 {
 522   Xstone,               Xstone,         Xdiamond,       Xdiamond,
 523   Xalien,               Xalien,         Xblank,         Xblank,
 524   Xtank_n,              Xtank_e,        Xtank_s,        Xtank_w,
 525   Xtank_gon,            Xtank_goe,      Xtank_gos,      Xtank_gow,
 526
 527   Xbomb,                Xbomb,          Xemerald,       Xemerald,
 528   Xbug_n,               Xbug_e,         Xbug_s,         Xbug_w,
 529   Xbug_gon,             Xbug_goe,       Xbug_gos,       Xbug_gow,
 530   Xdrip_eat,            Xdrip_eat,      Xdrip_eat,      Xdrip_eat,
 531
 532   Xstone,               Xbomb,          Xdiamond,       Xemerald,
 533   Xwonderwall,          Xnut,           Xnut,           Xnut,
 534   Xwheel,               Xeater_n,       Xeater_s,       Xeater_w,
 535   Xeater_e,             Xsand_stone,    Xblank,         Xblank,
 536
 537   Xblank,               Xsand,          Xsand,          Xsand,
 538   Xsand_stone,          Xsand_stone,    Xsand_stone,    Xsand,
 539   Xstone,               Xgrow_ew,       Xgrow_ns,       Xdynamite_1,
 540   Xdynamite_2,          Xdynamite_3,    Xdynamite_4,    Xacid_s,
 541
 542 #ifdef ALLOW_ROLLING_SPRING
 543   Xexit_1,              Xexit_2,        Xexit_3,        Xballoon,
 544   Xplant,               Xspring,        Xspring_fall,   Xspring_w,
 545   Xspring_e,            Xball_1,        Xball_2,        Xandroid,
 546   Xblank,               Xandroid,       Xandroid,       Xandroid,
 547 #else
 548   Xexit_1,              Xexit_2,        Xexit_3,        Xballoon,
 549   Xplant,               Xspring,        Xspring,        Xspring,
 550   Xspring,              Xball_1,        Xball_2,        Xandroid,
 551   Xblank,               Xandroid,       Xandroid,       Xandroid,
 552 #endif
 553
 554   Xandroid,             Xandroid,       Xandroid,       Xandroid,
 555   Xandroid,             Xblank,         Xblank,         Xblank,
 556   Xblank,               Xblank,         Xblank,         Xblank,
 557   Xblank,               Xblank,         Xblank,         Xblank,
 558
 559 #ifdef BAD_ROLL
 560
 561   Xblank,               Xblank,         Xblank,         Xspring_force_w,
 562   Xspring_force_e,      Xacid_1,        Xacid_2,        Xacid_3,
 563   Xacid_4,              Xacid_5,        Xacid_6,        Xacid_7,
 564   Xacid_8,              Xblank,         Xblank,         Xblank,
 565
 566   Xblank,               Xblank,         Xnut_force_w,   Xnut_force_e,
 567   Xsteel_1,             Xblank,         Xblank,         Xbomb_force_w,
 568   Xbomb_force_e,        Xstone_force_w, Xstone_force_e, Xblank,
 569   Xblank,               Xblank,         Xblank,         Xblank,
 570
 571 #else
 572
 573   Xblank,               Xblank,         Xblank,         Xspring,
 574   Xspring,              Xacid_1,        Xacid_2,        Xacid_3,
 575   Xacid_4,              Xacid_5,        Xacid_6,        Xacid_7,
 576   Xacid_8,              Xblank,         Xblank,         Xblank,
 577
 578   Xblank,               Xblank,         Xnut,           Xnut,
 579   Xsteel_1,             Xblank,         Xblank,         Xbomb,
 580   Xbomb,                Xstone,         Xstone,         Xblank,
 581   Xblank,               Xblank,         Xblank,         Xblank,
 582
 583 #endif
 584
 585   Xblank,               Xround_wall_1,  Xgrass,         Xsteel_1,
 586   Xwall_1,              Xkey_1,         Xkey_2,         Xkey_3,
 587   Xkey_4,               Xdoor_1,        Xdoor_2,        Xdoor_3,
 588   Xdoor_4,              Xdripper,       Xfake_door_1,   Xfake_door_2,
 589
 590   Xfake_door_3,         Xfake_door_4,   Xwonderwall,    Xwheel,
 591   Xsand,                Xacid_nw,       Xacid_ne,       Xacid_sw,
 592   Xacid_se,             Xfake_blank,    Xamoeba_1,      Xamoeba_2,
 593   Xamoeba_3,            Xamoeba_4,      Xexit,          Xalpha_arrow_w,
 594
 595   Xfake_grass,          Xlenses,        Xmagnify,       Xfake_blank,
 596   Xfake_grass,          Xswitch,        Xswitch,        Xblank,
 597   Xdecor_8,             Xdecor_9,       Xdecor_10,      Xdecor_5,
 598   Xalpha_comma,         Xalpha_quote,   Xalpha_minus,   Xdynamite,
 599
 600   Xsteel_3,             Xdecor_6,       Xdecor_7,       Xsteel_2,
 601   Xround_wall_2,        Xdecor_2,       Xdecor_4,       Xdecor_3,
 602   Xwind_nesw,           Xwind_e,        Xwind_s,        Xwind_w,
 603   Xwind_n,              Xdirt,          Xplant,         Xkey_5,
 604
 605   Xkey_6,               Xkey_7,         Xkey_8,         Xdoor_5,
 606   Xdoor_6,              Xdoor_7,        Xdoor_8,        Xbumper,
 607   Xalpha_a,             Xalpha_b,       Xalpha_c,       Xalpha_d,
 608   Xalpha_e,             Xalpha_f,       Xalpha_g,       Xalpha_h,
 609
 610   Xalpha_i,             Xalpha_j,       Xalpha_k,       Xalpha_l,
 611   Xalpha_m,             Xalpha_n,       Xalpha_o,       Xalpha_p,
 612   Xalpha_q,             Xalpha_r,       Xalpha_s,       Xalpha_t,
 613   Xalpha_u,             Xalpha_v,       Xalpha_w,       Xalpha_x,
 614
 615   Xalpha_y,             Xalpha_z,       Xalpha_0,       Xalpha_1,
 616   Xalpha_2,             Xalpha_3,       Xalpha_4,       Xalpha_5,
 617   Xalpha_6,             Xalpha_7,       Xalpha_8,       Xalpha_9,
 618   Xalpha_perio,         Xalpha_excla,   Xalpha_colon,   Xalpha_quest,
 619
 620   Xalpha_arrow_e,       Xdecor_1,       Xfake_door_5,   Xfake_door_6,
 621   Xfake_door_7,         Xfake_door_8,   Xblank,         Xblank,
 622   Xblank,               Xblank,         Xblank,         Xblank,
 623 #if 0
 624   Xblank,               Xblank,         Xblank,         Xblank,
 625 #else
 626   /* special elements added to solve compatibility problems */
 627   Xblank,               Xblank,         Xalpha_copyr,   Xfake_acid_1
 628 #endif
 629 };
 630
 631 static int get_em_element(unsigned short em_element_raw, int file_version)
 632 {
 633   int em_element = remap_emerald[em_element_raw];
 634
 635   if (file_version < FILE_VERSION_EM_V5)
 636   {
 637     /* versions below V5 had no grass, but only sand/dirt */
 638     if (em_element == Xgrass)
 639       em_element = Xdirt;
 640   }
 641
 642   return em_element;
 643 }
 644
 645 void convert_em_level(unsigned char *src, int file_version)
 646 {
 647   static int eater_offset[8] =
 648   {
 649     0x800, 0x809, 0x812, 0x81B, 0x840, 0x849, 0x852, 0x85B
 650   };
 651   int i, x, y, temp;
 652
 653 #if 1
 654   lev.time_seconds = src[0x83E] << 8 | src[0x83F];
 655   if (lev.time_seconds > 9999)
 656     lev.time_seconds = 9999;
 657 #else
 658   temp = ((src[0x83E] << 8 | src[0x83F]) * 25 + 3) / 4;
 659   if (temp == 0 || temp > 9999)
 660     temp = 9999;
 661   lev.time_initial = temp;
 662 #endif
 663
 664   lev.required_initial = src[0x82F];
 665
 666   for (i = 0; i < 2; i++)
 667   {
 668     temp = src[0x830 + i * 2] << 8 | src[0x831 + i * 2];
 669     ply[i].x_initial = (temp & 63) + 1;
 670     ply[i].y_initial = (temp >> 6 & 31) + 1;
 671   }
 672
 673   temp = (src[0x834] << 8 | src[0x835]) * 28;
 674   if (temp > 9999)
 675     temp = 9999;
 676   lev.amoeba_time = temp;
 677
 678   lev.android_move_time = src[0x874] << 8 | src[0x875];
 679   lev.android_clone_time = src[0x876] << 8 | src[0x877];
 680
 681   lev.ball_random = src[0x872] & 1 ? 1 : 0;
 682   lev.ball_state_initial = src[0x872] & 128 ? 1 : 0;
 683   lev.ball_time = src[0x870] << 8 | src[0x871];
 684
 685   lev.emerald_score = src[0x824];
 686   lev.diamond_score = src[0x825];
 687   lev.alien_score = src[0x826];
 688   lev.tank_score = src[0x827];
 689   lev.bug_score = src[0x828];
 690   lev.eater_score = src[0x829];
 691   lev.nut_score = src[0x82A];
 692   lev.dynamite_score = src[0x82B];
 693   lev.key_score = src[0x82C];
 694   lev.exit_score = src[0x82D] * 8 / 5;
 695   lev.lenses_score = src[0x867];
 696   lev.magnify_score = src[0x868];
 697   lev.slurp_score = src[0x869];
 698
 699   lev.lenses_time = src[0x86A] << 8 | src[0x86B];
 700   lev.magnify_time = src[0x86C] << 8 | src[0x86D];
 701   lev.wheel_time = src[0x838] << 8 | src[0x839];
 702
 703   lev.wind_cnt_initial = src[0x865] & 15 ? lev.wind_time : 0;
 704   temp = src[0x865];
 705   lev.wind_direction_initial = (temp & 8 ? 0 :
 706                                 temp & 1 ? 1 :
 707                                 temp & 2 ? 2 :
 708                                 temp & 4 ? 3 : 0);
 709
 710   lev.wonderwall_time_initial = src[0x836] << 8 | src[0x837];
 711
 712   for (i = 0; i < 8; i++)
 713     for (x = 0; x < 9; x++)
 714       lev.eater_array[i][x] =
 715         get_em_element(src[eater_offset[i] + x], file_version);
 716
 717   temp = get_em_element(src[0x86F], file_version);
 718   for (y = 0; y < 8; y++)
 719   {
 720     if (src[0x872] & 1)
 721     {
 722       for (x = 0; x < 8; x++)
 723         lev.ball_array[y][x] = temp;
 724     }
 725     else
 726     {
 727       lev.ball_array[y][1] = (src[0x873] & 1)  ? temp : Xblank; /* north */
 728       lev.ball_array[y][6] = (src[0x873] & 2)  ? temp : Xblank; /* south */
 729       lev.ball_array[y][3] = (src[0x873] & 4)  ? temp : Xblank; /* west */
 730       lev.ball_array[y][4] = (src[0x873] & 8)  ? temp : Xblank; /* east */
 731       lev.ball_array[y][7] = (src[0x873] & 16) ? temp : Xblank; /* southeast */
 732       lev.ball_array[y][5] = (src[0x873] & 32) ? temp : Xblank; /* southwest */
 733       lev.ball_array[y][2] = (src[0x873] & 64) ? temp : Xblank; /* northeast */
 734       lev.ball_array[y][0] = (src[0x873] & 128)? temp : Xblank; /* northwest */
 735     }
 736   }
 737
 738   temp = src[0x878] << 8 | src[0x879];
 739
 740   if (temp & 1)
 741   {
 742     lev.android_array[Xemerald]         = Xemerald;
 743     lev.android_array[Xemerald_pause]   = Xemerald;
 744     lev.android_array[Xemerald_fall]    = Xemerald;
 745     lev.android_array[Yemerald_sB]      = Xemerald;
 746     lev.android_array[Yemerald_eB]      = Xemerald;
 747     lev.android_array[Yemerald_wB]      = Xemerald;
 748   }
 749
 750   if (temp & 2)
 751   {
 752     lev.android_array[Xdiamond]         = Xdiamond;
 753     lev.android_array[Xdiamond_pause]   = Xdiamond;
 754     lev.android_array[Xdiamond_fall]    = Xdiamond;
 755     lev.android_array[Ydiamond_sB]      = Xdiamond;
 756     lev.android_array[Ydiamond_eB]      = Xdiamond;
 757     lev.android_array[Ydiamond_wB]      = Xdiamond;
 758   }
 759
 760   if (temp & 4)
 761   {
 762     lev.android_array[Xstone]           = Xstone;
 763     lev.android_array[Xstone_pause]     = Xstone;
 764     lev.android_array[Xstone_fall]      = Xstone;
 765     lev.android_array[Ystone_sB]        = Xstone;
 766     lev.android_array[Ystone_eB]        = Xstone;
 767     lev.android_array[Ystone_wB]        = Xstone;
 768   }
 769
 770   if (temp & 8)
 771   {
 772     lev.android_array[Xbomb]            = Xbomb;
 773     lev.android_array[Xbomb_pause]      = Xbomb;
 774     lev.android_array[Xbomb_fall]       = Xbomb;
 775     lev.android_array[Ybomb_sB]         = Xbomb;
 776     lev.android_array[Ybomb_eB]         = Xbomb;
 777     lev.android_array[Ybomb_wB]         = Xbomb;
 778   }
 779
 780   if (temp & 16)
 781   {
 782     lev.android_array[Xnut]             = Xnut;
 783     lev.android_array[Xnut_pause]       = Xnut;
 784     lev.android_array[Xnut_fall]        = Xnut;
 785     lev.android_array[Ynut_sB]          = Xnut;
 786     lev.android_array[Ynut_eB]          = Xnut;
 787     lev.android_array[Ynut_wB]          = Xnut;
 788   }
 789
 790   if (temp & 32)
 791   {
 792     lev.android_array[Xtank_n]          = Xtank_n;
 793     lev.android_array[Xtank_gon]        = Xtank_n;
 794     lev.android_array[Ytank_nB]         = Xtank_n;
 795     lev.android_array[Ytank_n_e]        = Xtank_n;
 796     lev.android_array[Ytank_n_w]        = Xtank_n;
 797
 798     lev.android_array[Xtank_e]          = Xtank_e;
 799     lev.android_array[Xtank_goe]        = Xtank_e;
 800     lev.android_array[Ytank_eB]         = Xtank_e;
 801     lev.android_array[Ytank_e_s]        = Xtank_e;
 802     lev.android_array[Ytank_e_n]        = Xtank_e;
 803
 804     lev.android_array[Xtank_s]          = Xtank_s;
 805     lev.android_array[Xtank_gos]        = Xtank_s;
 806     lev.android_array[Ytank_sB]         = Xtank_s;
 807     lev.android_array[Ytank_s_w]        = Xtank_s;
 808     lev.android_array[Ytank_s_e]        = Xtank_s;
 809
 810     lev.android_array[Xtank_w]          = Xtank_w;
 811     lev.android_array[Xtank_gow]        = Xtank_w;
 812     lev.android_array[Ytank_wB]         = Xtank_w;
 813     lev.android_array[Ytank_w_n]        = Xtank_w;
 814     lev.android_array[Ytank_w_s]        = Xtank_w;
 815   }
 816
 817   if (temp & 64)
 818   {
 819     lev.android_array[Xeater_n]         = Xeater_n;
 820     lev.android_array[Yeater_nB]        = Xeater_n;
 821
 822     lev.android_array[Xeater_e]         = Xeater_e;
 823     lev.android_array[Yeater_eB]        = Xeater_e;
 824
 825     lev.android_array[Xeater_s]         = Xeater_s;
 826     lev.android_array[Yeater_sB]        = Xeater_s;
 827
 828     lev.android_array[Xeater_w]         = Xeater_w;
 829     lev.android_array[Yeater_wB]        = Xeater_w;
 830   }
 831
 832   if (temp & 128)
 833   {
 834     lev.android_array[Xbug_n]           = Xbug_gon;
 835     lev.android_array[Xbug_gon]         = Xbug_gon;
 836     lev.android_array[Ybug_nB]          = Xbug_gon;
 837     lev.android_array[Ybug_n_e]         = Xbug_gon;
 838     lev.android_array[Ybug_n_w]         = Xbug_gon;
 839
 840     lev.android_array[Xbug_e]           = Xbug_goe;
 841     lev.android_array[Xbug_goe]         = Xbug_goe;
 842     lev.android_array[Ybug_eB]          = Xbug_goe;
 843     lev.android_array[Ybug_e_s]         = Xbug_goe;
 844     lev.android_array[Ybug_e_n]         = Xbug_goe;
 845
 846     lev.android_array[Xbug_s]           = Xbug_gos;
 847     lev.android_array[Xbug_gos]         = Xbug_gos;
 848     lev.android_array[Ybug_sB]          = Xbug_gos;
 849     lev.android_array[Ybug_s_w]         = Xbug_gos;
 850     lev.android_array[Ybug_s_e]         = Xbug_gos;
 851
 852     lev.android_array[Xbug_w]           = Xbug_gow;
 853     lev.android_array[Xbug_gow]         = Xbug_gow;
 854     lev.android_array[Ybug_wB]          = Xbug_gow;
 855     lev.android_array[Ybug_w_n]         = Xbug_gow;
 856     lev.android_array[Ybug_w_s]         = Xbug_gow;
 857   }
 858
 859   if (temp & 256)
 860   {
 861     lev.android_array[Xalien]           = Xalien;
 862     lev.android_array[Xalien_pause]     = Xalien;
 863     lev.android_array[Yalien_nB]        = Xalien;
 864     lev.android_array[Yalien_eB]        = Xalien;
 865     lev.android_array[Yalien_sB]        = Xalien;
 866     lev.android_array[Yalien_wB]        = Xalien;
 867   }
 868
 869   if (temp & 512)
 870   {
 871     lev.android_array[Xspring]          = Xspring;
 872     lev.android_array[Xspring_pause]    = Xspring;
 873     lev.android_array[Xspring_e]        = Xspring;
 874     lev.android_array[Yspring_eB]       = Xspring;
 875     lev.android_array[Yspring_kill_eB]  = Xspring;
 876     lev.android_array[Xspring_w]        = Xspring;
 877     lev.android_array[Yspring_wB]       = Xspring;
 878     lev.android_array[Yspring_kill_wB]  = Xspring;
 879     lev.android_array[Xspring_fall]     = Xspring;
 880     lev.android_array[Yspring_sB]       = Xspring;
 881   }
 882
 883   if (temp & 1024)
 884   {
 885     lev.android_array[Yballoon_nB]      = Xballoon;
 886     lev.android_array[Yballoon_eB]      = Xballoon;
 887     lev.android_array[Yballoon_sB]      = Xballoon;
 888     lev.android_array[Yballoon_wB]      = Xballoon;
 889     lev.android_array[Xballoon]         = Xballoon;
 890   }
 891
 892   if (temp & 2048)
 893   {
 894     lev.android_array[Xdripper]         = Xdrip_eat;
 895     lev.android_array[XdripperB]        = Xdrip_eat;
 896     lev.android_array[Xamoeba_1]        = Xdrip_eat;
 897     lev.android_array[Xamoeba_2]        = Xdrip_eat;
 898     lev.android_array[Xamoeba_3]        = Xdrip_eat;
 899     lev.android_array[Xamoeba_4]        = Xdrip_eat;
 900     lev.android_array[Xamoeba_5]        = Xdrip_eat;
 901     lev.android_array[Xamoeba_6]        = Xdrip_eat;
 902     lev.android_array[Xamoeba_7]        = Xdrip_eat;
 903     lev.android_array[Xamoeba_8]        = Xdrip_eat;
 904   }
 905
 906   if (temp & 4096)
 907   {
 908     lev.android_array[Xdynamite]        = Xdynamite;
 909   }
 910
 911   for (temp = 1; temp < 2047; temp++)
 912   {
 913     switch (src[temp])
 914     {
 915       case 0x24:                                /* wonderwall */
 916         lev.wonderwall_state_initial = 1;
 917         lev.wonderwall_time_initial = 9999;
 918         break;
 919
 920       case 0x28:                                /* wheel */
 921         lev.wheel_x_initial = temp & 63;
 922         lev.wheel_y_initial = temp >> 6;
 923         lev.wheel_cnt_initial = lev.wheel_time;
 924         break;
 925
 926 #ifndef BAD_ROLL
 927       case 0x63:                                /* spring roll left */
 928         src[temp - 1] = 0x45;
 929         src[temp] = 0x80;
 930         break;
 931
 932       case 0x64:                                /* spring roll right */
 933         src[temp + 1] = 0x45;
 934         src[temp] = 0x80;
 935         break;
 936
 937       case 0x72:                                /* nut roll left */
 938         src[temp - 1] = 0x25;
 939         src[temp] = 0x80;
 940         break;
 941
 942       case 0x73:                                /* nut roll right */
 943         src[temp + 1] = 0x25;
 944         src[temp] = 0x80;
 945         break;
 946
 947       case 0x77:                                /* bomb roll left */
 948         src[temp - 1] = 0x10;
 949         src[temp] = 0x80;
 950         break;
 951
 952       case 0x78:                                /* bomb roll right */
 953         src[temp + 1] = 0x10;
 954         src[temp] = 0x80;
 955         break;
 956
 957       case 0x79:                                /* stone roll left */
 958         src[temp - 1] = 0x00;
 959         src[temp] = 0x80;
 960         break;
 961
 962       case 0x7A:                                /* stone roll right */
 963         src[temp + 1] = 0x00;
 964         src[temp] = 0x80;
 965         break;
 966 #endif
 967
 968       case 0xA3:                                /* fake blank */
 969         lev.lenses_cnt_initial = 9999;
 970         break;
 971
 972       case 0xA4:                                /* fake grass */
 973         lev.magnify_cnt_initial = 9999;
 974         break;
 975     }
 976   }
 977
 978   /* first fill the complete playfield with the default border element */
 979   for (y = 0; y < HEIGHT; y++)
 980     for (x = 0; x < WIDTH; x++)
 981       native_em_level.cave[x][y] = ZBORDER;
 982
 983   /* then copy the real level contents from level file into the playfield */
 984   temp = 0;
 985   for (y = 0; y < lev.height; y++)
 986     for (x = 0; x < lev.width; x++)
 987       native_em_level.cave[x + 1][y + 1] =
 988         get_em_element(src[temp++], file_version);
 989
 990   /* at last, set the two players at their positions in the playfield */
 991   /* (native EM[C] levels always have exactly two players in a level) */
 992   for (i = 0; i < 2; i++)
 993     native_em_level.cave[ply[i].x_initial][ply[i].y_initial] = Zplayer;
 994
 995   native_em_level.file_version = file_version;
 996 }
 997
 998 void prepare_em_level(void)
 999 {
1000   int i, x, y;
1001   int players_left;
1002   boolean team_mode;
1003
1004   /* reset all runtime variables to their initial values */
1005
1006   for (y = 0; y < HEIGHT; y++)
1007     for (x = 0; x < WIDTH; x++)
1008       Cave[y][x] = native_em_level.cave[x][y];
1009
1010   for (y = 0; y < HEIGHT; y++)
1011     for (x = 0; x < WIDTH; x++)
1012       Next[y][x] = Cave[y][x];
1013
1014   for (y = 0; y < HEIGHT; y++)
1015     for (x = 0; x < WIDTH; x++)
1016       Draw[y][x] = Cave[y][x];
1017
1018   lev.time_initial = lev.time_seconds;
1019   lev.time = lev.time_initial;
1020
1021   lev.required = lev.required_initial;
1022   lev.score = 0;
1023
1024   lev.android_move_cnt  = lev.android_move_time;
1025   lev.android_clone_cnt = lev.android_clone_time;
1026
1027   lev.ball_pos = 0;
1028   lev.ball_state = lev.ball_state_initial;
1029   lev.ball_cnt = lev.ball_time;
1030
1031   lev.eater_pos = 0;
1032   lev.shine_cnt = 0;
1033
1034   lev.lenses_cnt = lev.lenses_cnt_initial;
1035   lev.magnify_cnt = lev.magnify_cnt_initial;
1036
1037   lev.wheel_cnt = lev.wheel_cnt_initial;
1038   lev.wheel_x   = lev.wheel_x_initial;
1039   lev.wheel_y   = lev.wheel_y_initial;
1040
1041   lev.wind_direction = lev.wind_direction_initial;
1042   lev.wind_cnt       = lev.wind_cnt_initial;
1043
1044   lev.wonderwall_state = lev.wonderwall_state_initial;
1045   lev.wonderwall_time  = lev.wonderwall_time_initial;
1046
1047   lev.killed_out_of_time = FALSE;
1048
1049   /* determine number of players in this level */
1050   lev.home_initial = 0;
1051
1052   for (i = 0; i < MAX_PLAYERS; i++)
1053   {
1054     ply[i].exists = 0;
1055     ply[i].alive_initial = FALSE;
1056
1057     if (ply[i].x_initial > 0 && ply[i].y_initial > 0)
1058     {
1059       ply[i].exists = 1;
1060
1061       lev.home_initial++;
1062     }
1063   }
1064
1065   team_mode = getTeamMode_EM();
1066
1067   if (!team_mode)
1068     lev.home_initial = 1;
1069
1070   lev.home = lev.home_initial;
1071   players_left = lev.home_initial;
1072
1073   for (i = 0; i < MAX_PLAYERS; i++)
1074   {
1075     if (ply[i].exists)
1076     {
1077       if (players_left)
1078       {
1079         ply[i].alive_initial = TRUE;
1080         players_left--;
1081       }
1082       else
1083       {
1084         int x = ply[i].x_initial;
1085         int y = ply[i].y_initial;
1086
1087         native_em_level.cave[x][y] = Xblank;
1088
1089         Cave[y][x] = Next[y][x] = Draw[y][x] = Xblank;
1090       }
1091     }
1092   }
1093
1094   for (i = 0; i < MAX_PLAYERS; i++)
1095   {
1096     ply[i].num = i;
1097     ply[i].alive = ply[i].alive_initial;
1098     ply[i].dynamite = 0;
1099     ply[i].dynamite_cnt = 0;
1100     ply[i].keys = 0;
1101     ply[i].anim = 0;
1102     ply[i].oldx = ply[i].x = ply[i].x_initial;
1103     ply[i].oldy = ply[i].y = ply[i].y_initial;
1104     ply[i].last_move_dir = MV_NONE;
1105     ply[i].joy_n = ply[i].joy_e = ply[i].joy_s = ply[i].joy_w = 0;
1106     ply[i].joy_snap  = ply[i].joy_drop = 0;
1107     ply[i].joy_stick = ply[i].joy_spin = 0;
1108   }
1109
1110   game_em.any_player_moving = FALSE;
1111   game_em.any_player_snapping = FALSE;
1112   game_em.last_moving_player = 0;       /* default: first player */
1113
1114   for (i = 0; i < MAX_PLAYERS; i++)
1115     game_em.last_player_direction[i] = MV_NONE;
1116
1117   lev.exit_x = lev.exit_y = -1; /* kludge for playing player exit sound */
1118 }