fixed handling debug keys to prevent handling keys twice
[rocksndiamonds.git] / 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 0
458   if (options.debug)
459     Error(ERR_DEBUG, "EM level file version: %d", file_version);
460 #endif
461
462   return file_version;
463 }
464
465 /* 2000-07-30T00:26:00Z
466  *
467  * Read emerald mine caves version 6
468  *
469  * v4 and v5 emerald mine caves are converted to v6 (which completely supports
470  * older versions)
471  * 
472  * converting to the internal format loses /significant/ information which can
473  * break lots of caves.
474  * 
475  * major incompatibilities:
476  * - borderless caves behave completely differently, the player no longer
477  *   "warps" to the other side.
478  * - a compile time option for spring can make it behave differently when it
479  *   rolls.
480  * - a compile time option for rolling objects (stone, nut, spring, bomb) only
481  *   in eater.
482  * - acid is always deadly even with no base beneath it (this breaks cave 0 in
483  *   downunder mine 16)
484  *   (*) fixed (see above):
485  *       - downunder mine 16, level 0, works again
486  *       - downunder mine 11, level 71, corrected (only cosmetically)
487  *
488  * so far all below have not broken any caves:
489  *
490  * - active wheel inside an eater will not function, eater explosions will not
491  *   change settings.
492  * - initial collect objects (emerald, diamond, dynamite) don't exist.
493  * - initial rolling objects will be moved manually and made into sitting
494  *   objects.
495  * - drips always appear from dots.
496  * - more than one thing can fall into acid at the same time.
497  * - acid explodes when the player walks into it, rather than splashing.
498  * - simultaneous explosions may be in a slightly different order.
499  * - quicksand states have been reduced.
500  * - acid base is effectively an indestructable wall now which can affect eater
501  *   explosions.
502  * - android can clone forever with a clone pause of 0 (emeralds, diamonds,
503  *   nuts, stones, bombs, springs).
504  *
505  * 2001-03-12T02:46:55Z
506  * - rolling stuff is now allowed in the cave, i didn't like making this
507  *   decision.
508  * - if BAD_ROLL is not defined, initial rolling objects are moved by hand.
509  * - initial collect objects break some cave in elvis mine 5.
510  * - different timing for wonderwall break some cave in exception mine 2.
511  * - i think i'm pretty locked into always using the bad roll. *sigh*
512  * - rolling spring is now turned into regular spring. it appears the emc
513  *   editor only uses the force code for initially moving spring. i will
514  *   follow this in my editor.
515  *
516  * 2006-04-02
517  * - introduced ALLOW_ROLLING_SPRING; if defined, do NOT turn rolling spring
518  *   into regular spring, because this breaks at least E.M.C. Mine 3, level 79
519  *   (see comment directly above)
520  */
521
522 static unsigned short remap_emerald[256] =
523 {
524   Xstone,               Xstone,         Xdiamond,       Xdiamond,
525   Xalien,               Xalien,         Xblank,         Xblank,
526   Xtank_n,              Xtank_e,        Xtank_s,        Xtank_w,
527   Xtank_gon,            Xtank_goe,      Xtank_gos,      Xtank_gow,
528
529   Xbomb,                Xbomb,          Xemerald,       Xemerald,
530   Xbug_n,               Xbug_e,         Xbug_s,         Xbug_w,
531   Xbug_gon,             Xbug_goe,       Xbug_gos,       Xbug_gow,
532   Xdrip_eat,            Xdrip_eat,      Xdrip_eat,      Xdrip_eat,
533
534   Xstone,               Xbomb,          Xdiamond,       Xemerald,
535   Xwonderwall,          Xnut,           Xnut,           Xnut,
536   Xwheel,               Xeater_n,       Xeater_s,       Xeater_w,
537   Xeater_e,             Xsand_stone,    Xblank,         Xblank,
538
539   Xblank,               Xsand,          Xsand,          Xsand,
540   Xsand_stone,          Xsand_stone,    Xsand_stone,    Xsand,
541   Xstone,               Xgrow_ew,       Xgrow_ns,       Xdynamite_1,
542   Xdynamite_2,          Xdynamite_3,    Xdynamite_4,    Xacid_s,
543
544 #ifdef ALLOW_ROLLING_SPRING
545   Xexit_1,              Xexit_2,        Xexit_3,        Xballoon,
546   Xplant,               Xspring,        Xspring_fall,   Xspring_w,
547   Xspring_e,            Xball_1,        Xball_2,        Xandroid,
548   Xblank,               Xandroid,       Xandroid,       Xandroid,
549 #else
550   Xexit_1,              Xexit_2,        Xexit_3,        Xballoon,
551   Xplant,               Xspring,        Xspring,        Xspring,
552   Xspring,              Xball_1,        Xball_2,        Xandroid,
553   Xblank,               Xandroid,       Xandroid,       Xandroid,
554 #endif
555
556   Xandroid,             Xandroid,       Xandroid,       Xandroid,
557   Xandroid,             Xblank,         Xblank,         Xblank,
558   Xblank,               Xblank,         Xblank,         Xblank,
559   Xblank,               Xblank,         Xblank,         Xblank,
560
561 #ifdef BAD_ROLL
562
563   Xblank,               Xblank,         Xblank,         Xspring_force_w,
564   Xspring_force_e,      Xacid_1,        Xacid_2,        Xacid_3,
565   Xacid_4,              Xacid_5,        Xacid_6,        Xacid_7,
566   Xacid_8,              Xblank,         Xblank,         Xblank,
567
568   Xblank,               Xblank,         Xnut_force_w,   Xnut_force_e,
569   Xsteel_1,             Xblank,         Xblank,         Xbomb_force_w,
570   Xbomb_force_e,        Xstone_force_w, Xstone_force_e, Xblank,
571   Xblank,               Xblank,         Xblank,         Xblank,
572
573 #else
574
575   Xblank,               Xblank,         Xblank,         Xspring,
576   Xspring,              Xacid_1,        Xacid_2,        Xacid_3,
577   Xacid_4,              Xacid_5,        Xacid_6,        Xacid_7,
578   Xacid_8,              Xblank,         Xblank,         Xblank,
579
580   Xblank,               Xblank,         Xnut,           Xnut,
581   Xsteel_1,             Xblank,         Xblank,         Xbomb,
582   Xbomb,                Xstone,         Xstone,         Xblank,
583   Xblank,               Xblank,         Xblank,         Xblank,
584
585 #endif
586
587   Xblank,               Xround_wall_1,  Xgrass,         Xsteel_1,
588   Xwall_1,              Xkey_1,         Xkey_2,         Xkey_3,
589   Xkey_4,               Xdoor_1,        Xdoor_2,        Xdoor_3,
590   Xdoor_4,              Xdripper,       Xfake_door_1,   Xfake_door_2,
591
592   Xfake_door_3,         Xfake_door_4,   Xwonderwall,    Xwheel,
593   Xsand,                Xacid_nw,       Xacid_ne,       Xacid_sw,
594   Xacid_se,             Xfake_blank,    Xamoeba_1,      Xamoeba_2,
595   Xamoeba_3,            Xamoeba_4,      Xexit,          Xalpha_arrow_w,
596
597   Xfake_grass,          Xlenses,        Xmagnify,       Xfake_blank,
598   Xfake_grass,          Xswitch,        Xswitch,        Xblank,
599   Xdecor_8,             Xdecor_9,       Xdecor_10,      Xdecor_5,
600   Xalpha_comma,         Xalpha_quote,   Xalpha_minus,   Xdynamite,
601
602   Xsteel_3,             Xdecor_6,       Xdecor_7,       Xsteel_2,
603   Xround_wall_2,        Xdecor_2,       Xdecor_4,       Xdecor_3,
604   Xwind_nesw,           Xwind_e,        Xwind_s,        Xwind_w,
605   Xwind_n,              Xdirt,          Xplant,         Xkey_5,
606
607   Xkey_6,               Xkey_7,         Xkey_8,         Xdoor_5,
608   Xdoor_6,              Xdoor_7,        Xdoor_8,        Xbumper,
609   Xalpha_a,             Xalpha_b,       Xalpha_c,       Xalpha_d,
610   Xalpha_e,             Xalpha_f,       Xalpha_g,       Xalpha_h,
611
612   Xalpha_i,             Xalpha_j,       Xalpha_k,       Xalpha_l,
613   Xalpha_m,             Xalpha_n,       Xalpha_o,       Xalpha_p,
614   Xalpha_q,             Xalpha_r,       Xalpha_s,       Xalpha_t,
615   Xalpha_u,             Xalpha_v,       Xalpha_w,       Xalpha_x,
616
617   Xalpha_y,             Xalpha_z,       Xalpha_0,       Xalpha_1,
618   Xalpha_2,             Xalpha_3,       Xalpha_4,       Xalpha_5,
619   Xalpha_6,             Xalpha_7,       Xalpha_8,       Xalpha_9,
620   Xalpha_perio,         Xalpha_excla,   Xalpha_colon,   Xalpha_quest,
621
622   Xalpha_arrow_e,       Xdecor_1,       Xfake_door_5,   Xfake_door_6,
623   Xfake_door_7,         Xfake_door_8,   Xblank,         Xblank,
624   Xblank,               Xblank,         Xblank,         Xblank,
625 #if 0
626   Xblank,               Xblank,         Xblank,         Xblank,
627 #else
628   /* special elements added to solve compatibility problems */
629   Xblank,               Xblank,         Xalpha_copyr,   Xfake_acid_1
630 #endif
631 };
632
633 static int get_em_element(unsigned short em_element_raw, int file_version)
634 {
635   int em_element = remap_emerald[em_element_raw];
636
637   if (file_version < FILE_VERSION_EM_V5)
638   {
639     /* versions below V5 had no grass, but only sand/dirt */
640     if (em_element == Xgrass)
641       em_element = Xdirt;
642   }
643
644   return em_element;
645 }
646
647 void convert_em_level(unsigned char *src, int file_version)
648 {
649   static int eater_offset[8] =
650   {
651     0x800, 0x809, 0x812, 0x81B, 0x840, 0x849, 0x852, 0x85B
652   };
653   int i, x, y, temp;
654
655 #if 1
656   lev.time_seconds = src[0x83E] << 8 | src[0x83F];
657   if (lev.time_seconds > 9999)
658     lev.time_seconds = 9999;
659 #else
660   temp = ((src[0x83E] << 8 | src[0x83F]) * 25 + 3) / 4;
661   if (temp == 0 || temp > 9999)
662     temp = 9999;
663   lev.time_initial = temp;
664 #endif
665
666   lev.required_initial = src[0x82F];
667
668   for (i = 0; i < 2; i++)
669   {
670     temp = src[0x830 + i * 2] << 8 | src[0x831 + i * 2];
671     ply[i].x_initial = (temp & 63) + 1;
672     ply[i].y_initial = (temp >> 6 & 31) + 1;
673   }
674
675   temp = (src[0x834] << 8 | src[0x835]) * 28;
676   if (temp > 9999)
677     temp = 9999;
678   lev.amoeba_time = temp;
679
680   lev.android_move_time = src[0x874] << 8 | src[0x875];
681   lev.android_clone_time = src[0x876] << 8 | src[0x877];
682
683   lev.ball_random = src[0x872] & 1 ? 1 : 0;
684   lev.ball_state_initial = src[0x872] & 128 ? 1 : 0;
685   lev.ball_time = src[0x870] << 8 | src[0x871];
686
687   lev.emerald_score = src[0x824];
688   lev.diamond_score = src[0x825];
689   lev.alien_score = src[0x826];
690   lev.tank_score = src[0x827];
691   lev.bug_score = src[0x828];
692   lev.eater_score = src[0x829];
693   lev.nut_score = src[0x82A];
694   lev.dynamite_score = src[0x82B];
695   lev.key_score = src[0x82C];
696   lev.exit_score = src[0x82D] * 8 / 5;
697   lev.lenses_score = src[0x867];
698   lev.magnify_score = src[0x868];
699   lev.slurp_score = src[0x869];
700
701   lev.lenses_time = src[0x86A] << 8 | src[0x86B];
702   lev.magnify_time = src[0x86C] << 8 | src[0x86D];
703   lev.wheel_time = src[0x838] << 8 | src[0x839];
704
705   lev.wind_cnt_initial = src[0x865] & 15 ? lev.wind_time : 0;
706   temp = src[0x865];
707   lev.wind_direction_initial = (temp & 8 ? 0 :
708                                 temp & 1 ? 1 :
709                                 temp & 2 ? 2 :
710                                 temp & 4 ? 3 : 0);
711
712   lev.wonderwall_time_initial = src[0x836] << 8 | src[0x837];
713
714   for (i = 0; i < 8; i++)
715     for (x = 0; x < 9; x++)
716       lev.eater_array[i][x] =
717         get_em_element(src[eater_offset[i] + x], file_version);
718
719   temp = get_em_element(src[0x86F], file_version);
720   for (y = 0; y < 8; y++)
721   {
722     if (src[0x872] & 1)
723     {
724       for (x = 0; x < 8; x++)
725         lev.ball_array[y][x] = temp;
726     }
727     else
728     {
729       lev.ball_array[y][1] = (src[0x873] & 1)  ? temp : Xblank; /* north */
730       lev.ball_array[y][6] = (src[0x873] & 2)  ? temp : Xblank; /* south */
731       lev.ball_array[y][3] = (src[0x873] & 4)  ? temp : Xblank; /* west */
732       lev.ball_array[y][4] = (src[0x873] & 8)  ? temp : Xblank; /* east */
733       lev.ball_array[y][7] = (src[0x873] & 16) ? temp : Xblank; /* southeast */
734       lev.ball_array[y][5] = (src[0x873] & 32) ? temp : Xblank; /* southwest */
735       lev.ball_array[y][2] = (src[0x873] & 64) ? temp : Xblank; /* northeast */
736       lev.ball_array[y][0] = (src[0x873] & 128)? temp : Xblank; /* northwest */
737     }
738   }
739
740   temp = src[0x878] << 8 | src[0x879];
741
742   if (temp & 1)
743   {
744     lev.android_array[Xemerald]         = Xemerald;
745     lev.android_array[Xemerald_pause]   = Xemerald;
746     lev.android_array[Xemerald_fall]    = Xemerald;
747     lev.android_array[Yemerald_sB]      = Xemerald;
748     lev.android_array[Yemerald_eB]      = Xemerald;
749     lev.android_array[Yemerald_wB]      = Xemerald;
750   }
751
752   if (temp & 2)
753   {
754     lev.android_array[Xdiamond]         = Xdiamond;
755     lev.android_array[Xdiamond_pause]   = Xdiamond;
756     lev.android_array[Xdiamond_fall]    = Xdiamond;
757     lev.android_array[Ydiamond_sB]      = Xdiamond;
758     lev.android_array[Ydiamond_eB]      = Xdiamond;
759     lev.android_array[Ydiamond_wB]      = Xdiamond;
760   }
761
762   if (temp & 4)
763   {
764     lev.android_array[Xstone]           = Xstone;
765     lev.android_array[Xstone_pause]     = Xstone;
766     lev.android_array[Xstone_fall]      = Xstone;
767     lev.android_array[Ystone_sB]        = Xstone;
768     lev.android_array[Ystone_eB]        = Xstone;
769     lev.android_array[Ystone_wB]        = Xstone;
770   }
771
772   if (temp & 8)
773   {
774     lev.android_array[Xbomb]            = Xbomb;
775     lev.android_array[Xbomb_pause]      = Xbomb;
776     lev.android_array[Xbomb_fall]       = Xbomb;
777     lev.android_array[Ybomb_sB]         = Xbomb;
778     lev.android_array[Ybomb_eB]         = Xbomb;
779     lev.android_array[Ybomb_wB]         = Xbomb;
780   }
781
782   if (temp & 16)
783   {
784     lev.android_array[Xnut]             = Xnut;
785     lev.android_array[Xnut_pause]       = Xnut;
786     lev.android_array[Xnut_fall]        = Xnut;
787     lev.android_array[Ynut_sB]          = Xnut;
788     lev.android_array[Ynut_eB]          = Xnut;
789     lev.android_array[Ynut_wB]          = Xnut;
790   }
791
792   if (temp & 32)
793   {
794     lev.android_array[Xtank_n]          = Xtank_n;
795     lev.android_array[Xtank_gon]        = Xtank_n;
796     lev.android_array[Ytank_nB]         = Xtank_n;
797     lev.android_array[Ytank_n_e]        = Xtank_n;
798     lev.android_array[Ytank_n_w]        = Xtank_n;
799
800     lev.android_array[Xtank_e]          = Xtank_e;
801     lev.android_array[Xtank_goe]        = Xtank_e;
802     lev.android_array[Ytank_eB]         = Xtank_e;
803     lev.android_array[Ytank_e_s]        = Xtank_e;
804     lev.android_array[Ytank_e_n]        = Xtank_e;
805
806     lev.android_array[Xtank_s]          = Xtank_s;
807     lev.android_array[Xtank_gos]        = Xtank_s;
808     lev.android_array[Ytank_sB]         = Xtank_s;
809     lev.android_array[Ytank_s_w]        = Xtank_s;
810     lev.android_array[Ytank_s_e]        = Xtank_s;
811
812     lev.android_array[Xtank_w]          = Xtank_w;
813     lev.android_array[Xtank_gow]        = Xtank_w;
814     lev.android_array[Ytank_wB]         = Xtank_w;
815     lev.android_array[Ytank_w_n]        = Xtank_w;
816     lev.android_array[Ytank_w_s]        = Xtank_w;
817   }
818
819   if (temp & 64)
820   {
821     lev.android_array[Xeater_n]         = Xeater_n;
822     lev.android_array[Yeater_nB]        = Xeater_n;
823
824     lev.android_array[Xeater_e]         = Xeater_e;
825     lev.android_array[Yeater_eB]        = Xeater_e;
826
827     lev.android_array[Xeater_s]         = Xeater_s;
828     lev.android_array[Yeater_sB]        = Xeater_s;
829
830     lev.android_array[Xeater_w]         = Xeater_w;
831     lev.android_array[Yeater_wB]        = Xeater_w;
832   }
833
834   if (temp & 128)
835   {
836     lev.android_array[Xbug_n]           = Xbug_gon;
837     lev.android_array[Xbug_gon]         = Xbug_gon;
838     lev.android_array[Ybug_nB]          = Xbug_gon;
839     lev.android_array[Ybug_n_e]         = Xbug_gon;
840     lev.android_array[Ybug_n_w]         = Xbug_gon;
841
842     lev.android_array[Xbug_e]           = Xbug_goe;
843     lev.android_array[Xbug_goe]         = Xbug_goe;
844     lev.android_array[Ybug_eB]          = Xbug_goe;
845     lev.android_array[Ybug_e_s]         = Xbug_goe;
846     lev.android_array[Ybug_e_n]         = Xbug_goe;
847
848     lev.android_array[Xbug_s]           = Xbug_gos;
849     lev.android_array[Xbug_gos]         = Xbug_gos;
850     lev.android_array[Ybug_sB]          = Xbug_gos;
851     lev.android_array[Ybug_s_w]         = Xbug_gos;
852     lev.android_array[Ybug_s_e]         = Xbug_gos;
853
854     lev.android_array[Xbug_w]           = Xbug_gow;
855     lev.android_array[Xbug_gow]         = Xbug_gow;
856     lev.android_array[Ybug_wB]          = Xbug_gow;
857     lev.android_array[Ybug_w_n]         = Xbug_gow;
858     lev.android_array[Ybug_w_s]         = Xbug_gow;
859   }
860
861   if (temp & 256)
862   {
863     lev.android_array[Xalien]           = Xalien;
864     lev.android_array[Xalien_pause]     = Xalien;
865     lev.android_array[Yalien_nB]        = Xalien;
866     lev.android_array[Yalien_eB]        = Xalien;
867     lev.android_array[Yalien_sB]        = Xalien;
868     lev.android_array[Yalien_wB]        = Xalien;
869   }
870
871   if (temp & 512)
872   {
873     lev.android_array[Xspring]          = Xspring;
874     lev.android_array[Xspring_pause]    = Xspring;
875     lev.android_array[Xspring_e]        = Xspring;
876     lev.android_array[Yspring_eB]       = Xspring;
877     lev.android_array[Yspring_kill_eB]  = Xspring;
878     lev.android_array[Xspring_w]        = Xspring;
879     lev.android_array[Yspring_wB]       = Xspring;
880     lev.android_array[Yspring_kill_wB]  = Xspring;
881     lev.android_array[Xspring_fall]     = Xspring;
882     lev.android_array[Yspring_sB]       = Xspring;
883   }
884
885   if (temp & 1024)
886   {
887     lev.android_array[Yballoon_nB]      = Xballoon;
888     lev.android_array[Yballoon_eB]      = Xballoon;
889     lev.android_array[Yballoon_sB]      = Xballoon;
890     lev.android_array[Yballoon_wB]      = Xballoon;
891     lev.android_array[Xballoon]         = Xballoon;
892   }
893
894   if (temp & 2048)
895   {
896     lev.android_array[Xdripper]         = Xdrip_eat;
897     lev.android_array[XdripperB]        = Xdrip_eat;
898     lev.android_array[Xamoeba_1]        = Xdrip_eat;
899     lev.android_array[Xamoeba_2]        = Xdrip_eat;
900     lev.android_array[Xamoeba_3]        = Xdrip_eat;
901     lev.android_array[Xamoeba_4]        = Xdrip_eat;
902     lev.android_array[Xamoeba_5]        = Xdrip_eat;
903     lev.android_array[Xamoeba_6]        = Xdrip_eat;
904     lev.android_array[Xamoeba_7]        = Xdrip_eat;
905     lev.android_array[Xamoeba_8]        = Xdrip_eat;
906   }
907
908   if (temp & 4096)
909   {
910     lev.android_array[Xdynamite]        = Xdynamite;
911   }
912
913   for (temp = 1; temp < 2047; temp++)
914   {
915     switch (src[temp])
916     {
917       case 0x24:                                /* wonderwall */
918         lev.wonderwall_state_initial = 1;
919         lev.wonderwall_time_initial = 9999;
920         break;
921
922       case 0x28:                                /* wheel */
923         lev.wheel_x_initial = temp & 63;
924         lev.wheel_y_initial = temp >> 6;
925         lev.wheel_cnt_initial = lev.wheel_time;
926         break;
927
928 #ifndef BAD_ROLL
929       case 0x63:                                /* spring roll left */
930         src[temp - 1] = 0x45;
931         src[temp] = 0x80;
932         break;
933
934       case 0x64:                                /* spring roll right */
935         src[temp + 1] = 0x45;
936         src[temp] = 0x80;
937         break;
938
939       case 0x72:                                /* nut roll left */
940         src[temp - 1] = 0x25;
941         src[temp] = 0x80;
942         break;
943
944       case 0x73:                                /* nut roll right */
945         src[temp + 1] = 0x25;
946         src[temp] = 0x80;
947         break;
948
949       case 0x77:                                /* bomb roll left */
950         src[temp - 1] = 0x10;
951         src[temp] = 0x80;
952         break;
953
954       case 0x78:                                /* bomb roll right */
955         src[temp + 1] = 0x10;
956         src[temp] = 0x80;
957         break;
958
959       case 0x79:                                /* stone roll left */
960         src[temp - 1] = 0x00;
961         src[temp] = 0x80;
962         break;
963
964       case 0x7A:                                /* stone roll right */
965         src[temp + 1] = 0x00;
966         src[temp] = 0x80;
967         break;
968 #endif
969
970       case 0xA3:                                /* fake blank */
971         lev.lenses_cnt_initial = 9999;
972         break;
973
974       case 0xA4:                                /* fake grass */
975         lev.magnify_cnt_initial = 9999;
976         break;
977     }
978   }
979
980   /* first fill the complete playfield with the default border element */
981   for (y = 0; y < HEIGHT; y++)
982     for (x = 0; x < WIDTH; x++)
983       native_em_level.cave[x][y] = ZBORDER;
984
985   /* then copy the real level contents from level file into the playfield */
986   temp = 0;
987   for (y = 0; y < lev.height; y++)
988     for (x = 0; x < lev.width; x++)
989       native_em_level.cave[x + 1][y + 1] =
990         get_em_element(src[temp++], file_version);
991
992   /* at last, set the two players at their positions in the playfield */
993   /* (native EM[C] levels always have exactly two players in a level) */
994   for (i = 0; i < 2; i++)
995     native_em_level.cave[ply[i].x_initial][ply[i].y_initial] = Zplayer;
996
997   native_em_level.file_version = file_version;
998 }
999
1000 void prepare_em_level(void)
1001 {
1002   int i, x, y;
1003   int players_left;
1004   boolean team_mode;
1005
1006   /* reset all runtime variables to their initial values */
1007
1008   for (y = 0; y < HEIGHT; y++)
1009     for (x = 0; x < WIDTH; x++)
1010       Cave[y][x] = native_em_level.cave[x][y];
1011
1012   for (y = 0; y < HEIGHT; y++)
1013     for (x = 0; x < WIDTH; x++)
1014       Next[y][x] = Cave[y][x];
1015
1016   for (y = 0; y < HEIGHT; y++)
1017     for (x = 0; x < WIDTH; x++)
1018       Draw[y][x] = Cave[y][x];
1019
1020   lev.time_initial = lev.time_seconds;
1021   lev.time = lev.time_initial;
1022
1023   lev.required = lev.required_initial;
1024   lev.score = 0;
1025
1026   lev.android_move_cnt  = lev.android_move_time;
1027   lev.android_clone_cnt = lev.android_clone_time;
1028
1029   lev.ball_pos = 0;
1030   lev.ball_state = lev.ball_state_initial;
1031   lev.ball_cnt = lev.ball_time;
1032
1033   lev.eater_pos = 0;
1034   lev.shine_cnt = 0;
1035
1036   lev.lenses_cnt = lev.lenses_cnt_initial;
1037   lev.magnify_cnt = lev.magnify_cnt_initial;
1038
1039   lev.wheel_cnt = lev.wheel_cnt_initial;
1040   lev.wheel_x   = lev.wheel_x_initial;
1041   lev.wheel_y   = lev.wheel_y_initial;
1042
1043   lev.wind_direction = lev.wind_direction_initial;
1044   lev.wind_cnt       = lev.wind_cnt_initial;
1045
1046   lev.wonderwall_state = lev.wonderwall_state_initial;
1047   lev.wonderwall_time  = lev.wonderwall_time_initial;
1048
1049   lev.killed_out_of_time = FALSE;
1050
1051   /* determine number of players in this level */
1052   lev.home_initial = 0;
1053
1054   for (i = 0; i < MAX_PLAYERS; i++)
1055   {
1056     ply[i].exists = 0;
1057     ply[i].alive_initial = FALSE;
1058
1059     if (ply[i].x_initial > 0 && ply[i].y_initial > 0)
1060     {
1061       ply[i].exists = 1;
1062
1063       lev.home_initial++;
1064     }
1065   }
1066
1067   team_mode = getTeamMode_EM();
1068
1069   if (!team_mode)
1070     lev.home_initial = 1;
1071
1072   lev.home = lev.home_initial;
1073   players_left = lev.home_initial;
1074
1075   for (i = 0; i < MAX_PLAYERS; i++)
1076   {
1077     if (ply[i].exists)
1078     {
1079       if (players_left)
1080       {
1081         ply[i].alive_initial = TRUE;
1082         players_left--;
1083       }
1084       else
1085       {
1086         int x = ply[i].x_initial;
1087         int y = ply[i].y_initial;
1088
1089         native_em_level.cave[x][y] = Xblank;
1090
1091         Cave[y][x] = Next[y][x] = Draw[y][x] = Xblank;
1092       }
1093     }
1094   }
1095
1096   for (i = 0; i < MAX_PLAYERS; i++)
1097   {
1098     ply[i].num = i;
1099     ply[i].alive = ply[i].alive_initial;
1100     ply[i].dynamite = 0;
1101     ply[i].dynamite_cnt = 0;
1102     ply[i].keys = 0;
1103     ply[i].anim = 0;
1104     ply[i].oldx = ply[i].x = ply[i].x_initial;
1105     ply[i].oldy = ply[i].y = ply[i].y_initial;
1106     ply[i].last_move_dir = MV_NONE;
1107     ply[i].joy_n = ply[i].joy_e = ply[i].joy_s = ply[i].joy_w = 0;
1108     ply[i].joy_snap  = ply[i].joy_drop = 0;
1109     ply[i].joy_stick = ply[i].joy_spin = 0;
1110   }
1111
1112   // the following engine variables are initialized to version-specific values
1113   // in function InitGameEngine() (src/game.c):
1114   //
1115   // - game_em.use_single_button (default: TRUE)
1116   // - game_em.use_snap_key_bug (default: FALSE)
1117
1118   game_em.level_solved = FALSE;
1119   game_em.game_over = FALSE;
1120
1121   game_em.any_player_moving = FALSE;
1122   game_em.any_player_snapping = FALSE;
1123
1124   game_em.last_moving_player = 0;       /* default: first player */
1125
1126   for (i = 0; i < MAX_PLAYERS; i++)
1127     game_em.last_player_direction[i] = MV_NONE;
1128
1129   lev.exit_x = lev.exit_y = -1; /* kludge for playing player exit sound */
1130 }