rnd-20140307-1-src
[rocksndiamonds.git] / src / game_em / graphics.c
1 /* 2000-08-13T14:36:17Z
2  *
3  * graphics manipulation crap
4  */
5
6 #include "main_em.h"
7
8 #define MIN_SCREEN_XPOS         1
9 #define MIN_SCREEN_YPOS         1
10 #define MAX_SCREEN_XPOS         MAX(1, lev.width  - (SCR_FIELDX - 1))
11 #define MAX_SCREEN_YPOS         MAX(1, lev.height - (SCR_FIELDY - 1))
12
13 #define MIN_SCREEN_X            (MIN_SCREEN_XPOS * TILEX)
14 #define MIN_SCREEN_Y            (MIN_SCREEN_YPOS * TILEY)
15 #define MAX_SCREEN_X            (MAX_SCREEN_XPOS * TILEX)
16 #define MAX_SCREEN_Y            (MAX_SCREEN_YPOS * TILEY)
17
18 #define VALID_SCREEN_X(x)       ((x) < MIN_SCREEN_X ? MIN_SCREEN_X :    \
19                                  (x) > MAX_SCREEN_X ? MAX_SCREEN_X : (x))
20 #define VALID_SCREEN_Y(y)       ((y) < MIN_SCREEN_Y ? MIN_SCREEN_Y :    \
21                                  (y) > MAX_SCREEN_Y ? MAX_SCREEN_Y : (y))
22
23 #define PLAYER_SCREEN_X(p)      (((    frame) * ply[p].oldx +           \
24                                   (8 - frame) * ply[p].x) * TILEX / 8   \
25                                  - ((SCR_FIELDX - 1) * TILEX) / 2)
26 #define PLAYER_SCREEN_Y(p)      (((    frame) * ply[p].oldy +           \
27                                   (8 - frame) * ply[p].y) * TILEY / 8   \
28                                  - ((SCR_FIELDY - 1) * TILEY) / 2)
29
30 #define USE_EXTENDED_GRAPHICS_ENGINE            1
31
32
33 #if 0
34 int TILEX = ORIG_TILEX * ZOOM_FACTOR;
35 int TILEY = ORIG_TILEY * ZOOM_FACTOR;
36 #endif
37
38 int frame;                              /* current screen frame */
39 int screen_x, screen_y;                 /* current scroll position */
40
41 /* tiles currently on screen */
42 #if 1
43 static int screentiles[MAX_PLAYFIELD_HEIGHT + 2][MAX_PLAYFIELD_WIDTH + 2];
44 static int crumbled_state[MAX_PLAYFIELD_HEIGHT + 2][MAX_PLAYFIELD_WIDTH + 2];
45
46 static boolean redraw[MAX_PLAYFIELD_WIDTH + 2][MAX_PLAYFIELD_HEIGHT + 2];
47 #else
48 static int screentiles[MAX_BUF_YSIZE][MAX_BUF_XSIZE];
49 static int crumbled_state[MAX_BUF_YSIZE][MAX_BUF_XSIZE];
50
51 static boolean redraw[MAX_BUF_XSIZE][MAX_BUF_YSIZE];
52 #endif
53
54 #if 0
55 #if 1
56 int centered_player_nr;
57 #else
58 static int centered_player_nr;
59 #endif
60 #endif
61
62 /* copy the entire screen to the window at the scroll position */
63
64 void BlitScreenToBitmap_EM(Bitmap *target_bitmap)
65 {
66   int x = screen_x % (MAX_BUF_XSIZE * TILEX);
67   int y = screen_y % (MAX_BUF_YSIZE * TILEY);
68   int sx, sy, sxsize, sysize;
69   int xsize = SXSIZE;
70   int ysize = SYSIZE;
71   int full_xsize = lev.width  * TILEX;
72   int full_ysize = lev.height * TILEY;
73
74   sxsize = (full_xsize < xsize ? full_xsize : xsize);
75   sysize = (full_ysize < ysize ? full_ysize : ysize);
76   sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
77   sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
78
79 #if 0
80   printf("::: %d, %d\n", screenBitmap->width, screenBitmap->height);
81   BlitBitmap(screenBitmap, target_bitmap, 0, 0, 544, 544, SX, SY);
82   return;
83 #endif
84
85 #if 1
86   if (x < 2 * TILEX && y < 2 * TILEY)
87   {
88     BlitBitmap(screenBitmap, target_bitmap, x, y,
89                sxsize, sysize, sx, sy);
90   }
91   else if (x < 2 * TILEX && y >= 2 * TILEY)
92   {
93     BlitBitmap(screenBitmap, target_bitmap, x, y,
94                sxsize, MAX_BUF_YSIZE * TILEY - y,
95                sx, sy);
96     BlitBitmap(screenBitmap, target_bitmap, x, 0,
97                sxsize, y - 2 * TILEY,
98                sx, sy + MAX_BUF_YSIZE * TILEY - y);
99   }
100   else if (x >= 2 * TILEX && y < 2 * TILEY)
101   {
102     BlitBitmap(screenBitmap, target_bitmap, x, y,
103                MAX_BUF_XSIZE * TILEX - x, sysize,
104                sx, sy);
105     BlitBitmap(screenBitmap, target_bitmap, 0, y,
106                x - 2 * TILEX, sysize,
107                sx + MAX_BUF_XSIZE * TILEX - x, sy);
108   }
109   else
110   {
111     BlitBitmap(screenBitmap, target_bitmap, x, y,
112                MAX_BUF_XSIZE * TILEX - x, MAX_BUF_YSIZE * TILEY - y,
113                sx, sy);
114     BlitBitmap(screenBitmap, target_bitmap, 0, y,
115                x - 2 * TILEX, MAX_BUF_YSIZE * TILEY - y,
116                sx + MAX_BUF_XSIZE * TILEX - x, sy);
117     BlitBitmap(screenBitmap, target_bitmap, x, 0,
118                MAX_BUF_XSIZE * TILEX - x, y - 2 * TILEY,
119                sx, sy + MAX_BUF_YSIZE * TILEY - y);
120     BlitBitmap(screenBitmap, target_bitmap, 0, 0,
121                x - 2 * TILEX, y - 2 * TILEY,
122                sx + MAX_BUF_XSIZE * TILEX - x, sy + MAX_BUF_YSIZE * TILEY - y);
123   }
124 #else
125   if (x < 2 * TILEX && y < 2 * TILEY)
126   {
127     BlitBitmap(screenBitmap, target_bitmap, x, y,
128                SCR_FIELDX * TILEX, SCR_FIELDY * TILEY, SX, SY);
129   }
130   else if (x < 2 * TILEX && y >= 2 * TILEY)
131   {
132     BlitBitmap(screenBitmap, target_bitmap, x, y,
133                SCR_FIELDX * TILEX, MAX_BUF_YSIZE * TILEY - y,
134                SX, SY);
135     BlitBitmap(screenBitmap, target_bitmap, x, 0,
136                SCR_FIELDX * TILEX, y - 2 * TILEY,
137                SX, SY + MAX_BUF_YSIZE * TILEY - y);
138   }
139   else if (x >= 2 * TILEX && y < 2 * TILEY)
140   {
141     BlitBitmap(screenBitmap, target_bitmap, x, y,
142                MAX_BUF_XSIZE * TILEX - x, SCR_FIELDY * TILEY,
143                SX, SY);
144     BlitBitmap(screenBitmap, target_bitmap, 0, y,
145                x - 2 * TILEX, SCR_FIELDY * TILEY,
146                SX + MAX_BUF_XSIZE * TILEX - x, SY);
147   }
148   else
149   {
150     BlitBitmap(screenBitmap, target_bitmap, x, y,
151                MAX_BUF_XSIZE * TILEX - x, MAX_BUF_YSIZE * TILEY - y,
152                SX, SY);
153     BlitBitmap(screenBitmap, target_bitmap, 0, y,
154                x - 2 * TILEX, MAX_BUF_YSIZE * TILEY - y,
155                SX + MAX_BUF_XSIZE * TILEX - x, SY);
156     BlitBitmap(screenBitmap, target_bitmap, x, 0,
157                MAX_BUF_XSIZE * TILEX - x, y - 2 * TILEY,
158                SX, SY + MAX_BUF_YSIZE * TILEY - y);
159     BlitBitmap(screenBitmap, target_bitmap, 0, 0,
160                x - 2 * TILEX, y - 2 * TILEY,
161                SX + MAX_BUF_XSIZE * TILEX - x, SY + MAX_BUF_YSIZE * TILEY - y);
162   }
163 #endif
164 }
165
166 void BackToFront_EM(void)
167 {
168   static int screen_x_last = -1, screen_y_last = -1;
169   static boolean scrolling_last = FALSE;
170   int left = screen_x / TILEX;
171   int top  = screen_y / TILEY;
172 #if 1
173   boolean scrolling = (screen_x != screen_x_last || screen_y != screen_y_last);
174 #else
175   boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
176 #endif
177   int x, y;
178
179 #if 0
180   printf("::: %d, %d\n", screen_x, screen_y);
181 #endif
182
183   SyncDisplay();
184
185   if (redraw_tiles > REDRAWTILES_THRESHOLD || scrolling || scrolling_last)
186   {
187     /* blit all (up to four) parts of the scroll buffer to the backbuffer */
188     BlitScreenToBitmap_EM(backbuffer);
189
190     /* blit the completely updated backbuffer to the window (in one blit) */
191     BlitBitmap(backbuffer, window, SX, SY, SXSIZE, SYSIZE, SX, SY);
192   }
193   else
194   {
195 #if 1
196 #if 1
197     boolean half_shifted_x = (screen_x % TILEX != 0);
198     boolean half_shifted_y = (screen_y % TILEY != 0);
199 #else
200     boolean half_shifted_x = (EVEN(SCR_FIELDX) && screen_x % TILEX != 0);
201     boolean half_shifted_y = (EVEN(SCR_FIELDY) && screen_y % TILEY != 0);
202 #endif
203
204     int sx, sy;
205 #if 0
206     int sxsize, sysize;
207 #endif
208     int xsize = SXSIZE;
209     int ysize = SYSIZE;
210     int full_xsize = lev.width  * TILEX;
211     int full_ysize = lev.height * TILEY;
212
213 #if 0
214     sxsize = (full_xsize < xsize ? full_xsize : xsize);
215     sysize = (full_ysize < ysize ? full_ysize : ysize);
216 #endif
217     sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
218     sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
219
220 #if 0
221 #if 1
222     printf("::: %d, %d\n", EVEN(SCR_FIELDX), screen_x);
223 #else
224     half_shifted_x = TRUE;
225     half_shifted_y = FALSE;
226 #endif
227 #endif
228
229     int x1 = 0, x2 = SCR_FIELDX - (half_shifted_x ? 0 : 1);
230     int y1 = 0, y2 = SCR_FIELDY - (half_shifted_y ? 0 : 1);
231     int scroll_xoffset = (half_shifted_x ? TILEX / 2 : 0);
232     int scroll_yoffset = (half_shifted_y ? TILEY / 2 : 0);
233
234     InitGfxClipRegion(TRUE, SX, SY, SXSIZE, SYSIZE);
235
236     for (x = x1; x <= x2; x++)
237     {
238       for (y = y1; y <= y2; y++)
239       {
240         int xx = (left + x) % MAX_BUF_XSIZE;
241         int yy = (top  + y) % MAX_BUF_YSIZE;
242
243         if (redraw[xx][yy])
244           BlitBitmap(screenBitmap, window,
245                      xx * TILEX, yy * TILEY, TILEX, TILEY,
246                      sx + x * TILEX - scroll_xoffset,
247                      sy + y * TILEY - scroll_yoffset);
248       }
249     }
250
251     InitGfxClipRegion(FALSE, -1, -1, -1, -1);
252
253 #else
254
255     for (x = 0; x < SCR_FIELDX; x++)
256     {
257       for (y = 0; y < SCR_FIELDY; y++)
258       {
259         int xx = (left + x) % MAX_BUF_XSIZE;
260         int yy = (top  + y) % MAX_BUF_YSIZE;
261
262         if (redraw[xx][yy])
263           BlitBitmap(screenBitmap, window,
264                      xx * TILEX, yy * TILEY, TILEX, TILEY,
265                      SX + x * TILEX, SY + y * TILEY);
266       }
267     }
268 #endif
269   }
270
271   FlushDisplay();
272
273   for (x = 0; x < MAX_BUF_XSIZE; x++)
274     for (y = 0; y < MAX_BUF_YSIZE; y++)
275       redraw[x][y] = FALSE;
276   redraw_tiles = 0;
277
278   screen_x_last = screen_x;
279   screen_y_last = screen_y;
280   scrolling_last = scrolling;
281 }
282
283 void blitscreen(void)
284 {
285   BackToFront_EM();
286 }
287
288 static struct GraphicInfo_EM *getObjectGraphic(int x, int y)
289 {
290   int tile = Draw[y][x];
291   struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
292
293   if (!game.use_native_emc_graphics_engine)
294     getGraphicSourceObjectExt_EM(g, tile, 7 - frame, x - 2, y - 2);
295
296   return g;
297 }
298
299 static struct GraphicInfo_EM *getPlayerGraphic(int player_nr, int anim)
300 {
301   struct GraphicInfo_EM *g = &graphic_info_em_player[player_nr][anim][frame];
302
303   if (!game.use_native_emc_graphics_engine)
304     getGraphicSourcePlayerExt_EM(g, player_nr, anim, 7 - frame);
305
306   return g;
307 }
308
309 static void DrawLevelField_EM(int x, int y, int sx, int sy,
310                               boolean draw_masked)
311 {
312   struct GraphicInfo_EM *g = getObjectGraphic(x, y);
313 #if NEW_TILESIZE
314   int src_x = g->src_x + g->src_offset_x * TILESIZE_VAR / TILESIZE;
315   int src_y = g->src_y + g->src_offset_y * TILESIZE_VAR / TILESIZE;
316   int dst_x = sx * TILEX + g->dst_offset_x * TILESIZE_VAR / TILESIZE;
317   int dst_y = sy * TILEY + g->dst_offset_y * TILESIZE_VAR / TILESIZE;
318   int width = g->width * TILESIZE_VAR / TILESIZE;
319   int height = g->height * TILESIZE_VAR / TILESIZE;
320 #else
321   int src_x = g->src_x + g->src_offset_x;
322   int src_y = g->src_y + g->src_offset_y;
323   int dst_x = sx * TILEX + g->dst_offset_x;
324   int dst_y = sy * TILEY + g->dst_offset_y;
325   int width = g->width;
326   int height = g->height;
327 #endif
328   int left = screen_x / TILEX;
329   int top  = screen_y / TILEY;
330
331   /* do not draw fields that are outside the visible screen area */
332   if (x < left || x >= left + MAX_BUF_XSIZE ||
333       y < top  || y >= top  + MAX_BUF_YSIZE)
334     return;
335
336   if (draw_masked)
337   {
338     if (width > 0 && height > 0)
339     {
340       SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
341                     dst_x - src_x, dst_y - src_y);
342       BlitBitmapMasked(g->bitmap, screenBitmap,
343                        src_x, src_y, width, height, dst_x, dst_y);
344     }
345   }
346   else
347   {
348     if ((width != TILEX || height != TILEY) && !g->preserve_background)
349       ClearRectangle(screenBitmap, sx * TILEX, sy * TILEY, TILEX, TILEY);
350
351     if (width > 0 && height > 0)
352       BlitBitmap(g->bitmap, screenBitmap,
353                  src_x, src_y, width, height, dst_x, dst_y);
354   }
355 }
356
357 static void DrawLevelFieldCrumbled_EM(int x, int y, int sx, int sy,
358                                       int crm, boolean draw_masked)
359 {
360 #if 1
361   struct GraphicInfo_EM *g;
362 #else
363   struct GraphicInfo_EM *g = getObjectGraphic(x, y);
364 #endif
365   int crumbled_border_size;
366   int left = screen_x / TILEX;
367   int top  = screen_y / TILEY;
368   int i;
369
370   /* do not draw fields that are outside the visible screen area */
371   if (x < left || x >= left + MAX_BUF_XSIZE ||
372       y < top  || y >= top  + MAX_BUF_YSIZE)
373     return;
374
375   if (crm == 0)         /* no crumbled edges for this tile */
376     return;
377
378 #if 1
379   g = getObjectGraphic(x, y);
380 #endif
381
382   crumbled_border_size = g->crumbled_border_size;
383
384 #if NEW_TILESIZE
385   crumbled_border_size = crumbled_border_size * TILESIZE_VAR / TILESIZE;
386 #endif
387
388 #if 0
389   if (x == 3 && y == 3 && frame == 0)
390     printf("::: %d, %d\n",
391            graphic_info_em_object[207][0].crumbled_src_x,
392            graphic_info_em_object[207][0].crumbled_src_y);
393 #endif
394
395   for (i = 0; i < 4; i++)
396   {
397     if (crm & (1 << i))
398     {
399       int width, height, cx, cy;
400
401       if (i == 1 || i == 2)
402       {
403         width = crumbled_border_size;
404         height = TILEY;
405         cx = (i == 2 ? TILEX - crumbled_border_size : 0);
406         cy = 0;
407       }
408       else
409       {
410         width = TILEX;
411         height = crumbled_border_size;
412         cx = 0;
413         cy = (i == 3 ? TILEY - crumbled_border_size : 0);
414       }
415
416       if (width > 0 && height > 0)
417       {
418         int src_x = g->crumbled_src_x + cx;
419         int src_y = g->crumbled_src_y + cy;
420         int dst_x = sx * TILEX + cx;
421         int dst_y = sy * TILEY + cy;
422
423         if (draw_masked)
424         {
425           SetClipOrigin(g->crumbled_bitmap, g->crumbled_bitmap->stored_clip_gc,
426                         dst_x - src_x, dst_y - src_y);
427           BlitBitmapMasked(g->crumbled_bitmap, screenBitmap,
428                            src_x, src_y, width, height, dst_x, dst_y);
429         }
430         else
431           BlitBitmap(g->crumbled_bitmap, screenBitmap,
432                      src_x, src_y, width, height, dst_x, dst_y);
433       }
434     }
435   }
436 }
437
438 static void DrawLevelPlayer_EM(int x1, int y1, int player_nr, int anim,
439                                boolean draw_masked)
440 {
441   struct GraphicInfo_EM *g = getPlayerGraphic(player_nr, anim);
442   int src_x = g->src_x, src_y = g->src_y;
443   int dst_x, dst_y;
444
445   /* do not draw fields that are outside the visible screen area */
446   if (x1 < screen_x - TILEX || x1 >= screen_x + MAX_BUF_XSIZE * TILEX ||
447       y1 < screen_y - TILEY || y1 >= screen_y + MAX_BUF_YSIZE * TILEY)
448     return;
449
450   x1 %= MAX_BUF_XSIZE * TILEX;
451   y1 %= MAX_BUF_YSIZE * TILEY;
452
453   if (draw_masked)
454   {
455     /* draw the player to current location */
456     dst_x = x1;
457     dst_y = y1;
458     SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
459                   dst_x - src_x, dst_y - src_y);
460     BlitBitmapMasked(g->bitmap, screenBitmap,
461                      src_x, src_y, TILEX, TILEY, dst_x, dst_y);
462
463     /* draw the player to opposite wrap-around column */
464     dst_x = x1 - MAX_BUF_XSIZE * TILEX;
465     dst_y = y1;
466     SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
467                   dst_x - src_x, dst_y - src_y);
468     BlitBitmapMasked(g->bitmap, screenBitmap,
469                      g->src_x, g->src_y, TILEX, TILEY, dst_x, dst_y);
470
471     /* draw the player to opposite wrap-around row */
472     dst_x = x1;
473     dst_y = y1 - MAX_BUF_YSIZE * TILEY;
474     SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
475                   dst_x - src_x, dst_y - src_y);
476     BlitBitmapMasked(g->bitmap, screenBitmap,
477                      g->src_x, g->src_y, TILEX, TILEY, dst_x, dst_y);
478   }
479   else
480   {
481     /* draw the player to current location */
482     dst_x = x1;
483     dst_y = y1;
484     BlitBitmap(g->bitmap, screenBitmap,
485                g->src_x, g->src_y, TILEX, TILEY, dst_x, dst_y);
486
487     /* draw the player to opposite wrap-around column */
488     dst_x = x1 - MAX_BUF_XSIZE * TILEX;
489     dst_y = y1;
490     BlitBitmap(g->bitmap, screenBitmap,
491                g->src_x, g->src_y, TILEX, TILEY, dst_x, dst_y);
492
493     /* draw the player to opposite wrap-around row */
494     dst_x = x1;
495     dst_y = y1 - MAX_BUF_YSIZE * TILEY;
496     BlitBitmap(g->bitmap, screenBitmap,
497                g->src_x, g->src_y, TILEX, TILEY, dst_x, dst_y);
498   }
499 }
500
501 /* draw differences between game tiles and screen tiles
502  *
503  * implicitly handles scrolling and restoring background under the sprites
504  */
505
506 static void animscreen(void)
507 {
508   int x, y, i;
509   int left = screen_x / TILEX;
510   int top  = screen_y / TILEY;
511   static int xy[4][2] =
512   {
513     { 0, -1 },
514     { -1, 0 },
515     { +1, 0 },
516     { 0, +1 }
517   };
518
519   if (!game.use_native_emc_graphics_engine)
520     for (y = 2; y < EM_MAX_CAVE_HEIGHT - 2; y++)
521       for (x = 2; x < EM_MAX_CAVE_WIDTH - 2; x++)
522         SetGfxAnimation_EM(&graphic_info_em_object[Draw[y][x]][frame],
523                            Draw[y][x], 7 - frame, x - 2, y - 2);
524
525   for (y = top; y < top + MAX_BUF_YSIZE; y++)
526   {
527     for (x = left; x < left + MAX_BUF_XSIZE; x++)
528     {
529       int sx = x % MAX_BUF_XSIZE;
530       int sy = y % MAX_BUF_YSIZE;    
531       int tile = Draw[y][x];
532       struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
533       int obj = g->unique_identifier;
534       int crm = 0;
535       boolean redraw_screen_tile = FALSE;
536
537       /* re-calculate crumbled state of this tile */
538       if (g->has_crumbled_graphics)
539       {
540         for (i = 0; i < 4; i++)
541         {
542           int xx = x + xy[i][0];
543           int yy = y + xy[i][1];
544           int tile_next;
545
546           if (xx < 0 || xx >= EM_MAX_CAVE_WIDTH ||
547               yy < 0 || yy >= EM_MAX_CAVE_HEIGHT)
548             continue;
549
550           tile_next = Draw[yy][xx];
551
552           if (!graphic_info_em_object[tile_next][frame].has_crumbled_graphics)
553             crm |= (1 << i);
554         }
555       }
556
557       redraw_screen_tile = (screentiles[sy][sx]    != obj ||
558                             crumbled_state[sy][sx] != crm);
559
560 #if 0
561       /* !!! TEST ONLY -- CHANGE THIS !!! */
562       if (!game.use_native_emc_graphics_engine)
563         redraw_screen_tile = TRUE;
564 #endif
565
566       /* only redraw screen tiles if they (or their crumbled state) changed */
567       if (redraw_screen_tile)
568       {
569         DrawLevelField_EM(x, y, sx, sy, FALSE);
570         DrawLevelFieldCrumbled_EM(x, y, sx, sy, crm, FALSE);
571
572         screentiles[sy][sx] = obj;
573         crumbled_state[sy][sx] = crm;
574
575         redraw[sx][sy] = TRUE;
576         redraw_tiles++;
577       }
578     }
579   }
580 }
581
582
583 /* blit players to the screen
584  *
585  * handles transparency and movement
586  */
587
588 static void blitplayer(struct PLAYER *ply)
589 {
590   int x1, y1, x2, y2;
591
592   if (!ply->alive)
593     return;
594
595   /* x1/y1 are left/top and x2/y2 are right/down part of the player movement */
596   x1 = (frame * ply->oldx + (8 - frame) * ply->x) * TILEX / 8;
597   y1 = (frame * ply->oldy + (8 - frame) * ply->y) * TILEY / 8;
598   x2 = x1 + TILEX - 1;
599   y2 = y1 + TILEY - 1;
600
601 #if 0
602   printf("::: %d, %d\n", x1, y1);
603 #endif
604
605   if ((int)(x2 - screen_x) < ((MAX_BUF_XSIZE - 1) * TILEX - 1) &&
606       (int)(y2 - screen_y) < ((MAX_BUF_YSIZE - 1) * TILEY - 1))
607   {
608     /* some casts to "int" are needed because of negative calculation values */
609     int dx = (int)ply->x - (int)ply->oldx;
610     int dy = (int)ply->y - (int)ply->oldy;
611     int old_x = (int)ply->oldx + (7 - (int)frame) * dx / 8;
612     int old_y = (int)ply->oldy + (7 - (int)frame) * dy / 8;
613     int new_x = old_x + SIGN(dx);
614     int new_y = old_y + SIGN(dy);
615     int old_sx = old_x % MAX_BUF_XSIZE;
616     int old_sy = old_y % MAX_BUF_XSIZE;
617     int new_sx = new_x % MAX_BUF_XSIZE;
618     int new_sy = new_y % MAX_BUF_XSIZE;
619 #if 0
620     int old_crm = crumbled_state[old_sy][old_sx];
621 #endif
622     int new_crm = crumbled_state[new_sy][new_sx];
623
624     /* only diggable elements can be crumbled in the classic EM engine */
625     boolean player_is_digging = (new_crm != 0);
626
627 #if 0
628     x1 %= MAX_BUF_XSIZE * TILEX;
629     y1 %= MAX_BUF_YSIZE * TILEY;
630     x2 %= MAX_BUF_XSIZE * TILEX;
631     y2 %= MAX_BUF_YSIZE * TILEY;
632 #endif
633
634     if (player_is_digging)
635     {
636 #if 0
637       /* draw the field the player is moving from (under the player) */
638       DrawLevelField_EM(old_x, old_y, old_sx, old_sy, FALSE);
639       DrawLevelFieldCrumbled_EM(old_x, old_y, old_sx, old_sy, old_crm, FALSE);
640 #endif
641
642       /* draw the field the player is moving to (under the player) */
643       DrawLevelField_EM(new_x, new_y, new_sx, new_sy, FALSE);
644       DrawLevelFieldCrumbled_EM(new_x, new_y, new_sx, new_sy, new_crm, FALSE);
645
646       /* draw the player (masked) over the element he is just digging away */
647       DrawLevelPlayer_EM(x1, y1, ply->num, ply->anim, TRUE);
648
649 #if 1
650       /* draw the field the player is moving from (masked over the player) */
651       DrawLevelField_EM(old_x, old_y, old_sx, old_sy, TRUE);
652 #endif
653     }
654     else
655     {
656       /* draw the player under the element which is on the same field */
657       DrawLevelPlayer_EM(x1, y1, ply->num, ply->anim, FALSE);
658
659       /* draw the field the player is moving from (masked over the player) */
660       DrawLevelField_EM(old_x, old_y, old_sx, old_sy, TRUE);
661
662       /* draw the field the player is moving to (masked over the player) */
663       DrawLevelField_EM(new_x, new_y, new_sx, new_sy, TRUE);
664     }
665
666     /* redraw screen tiles in the next frame (player may have left the tiles) */
667     screentiles[old_sy][old_sx] = -1;
668     screentiles[new_sy][new_sx] = -1;
669
670     /* mark screen tiles as dirty (force screen refresh with changed content) */
671     redraw[old_sx][old_sy] = TRUE;
672     redraw[new_sx][new_sy] = TRUE;
673     redraw_tiles += 2;
674   }
675 }
676
677 void game_initscreen(void)
678 {
679   int x,y;
680   int dynamite_state = ply[0].dynamite;         /* !!! ONLY PLAYER 1 !!! */
681   int all_keys_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
682   int player_nr;
683
684   frame = 6;
685
686 #if 0
687   game.centered_player_nr = getCenteredPlayerNr_EM();
688 #endif
689
690   player_nr = (game.centered_player_nr != -1 ? game.centered_player_nr : 0);
691
692   screen_x = VALID_SCREEN_X(PLAYER_SCREEN_X(player_nr));
693   screen_y = VALID_SCREEN_Y(PLAYER_SCREEN_Y(player_nr));
694
695   for (y = 0; y < MAX_BUF_YSIZE; y++)
696   {
697     for (x = 0; x < MAX_BUF_XSIZE; x++)
698     {
699       screentiles[y][x] = -1;
700       crumbled_state[y][x] = 0;
701     }
702   }
703
704   DrawAllGameValues(lev.required, dynamite_state, lev.score,
705                     lev.time, all_keys_state);
706 }
707
708 #if 0
709 void DrawRelocatePlayer(struct PlayerInfo *player, boolean quick_relocation)
710 {
711   boolean ffwd_delay = (tape.playing && tape.fast_forward);
712   boolean no_delay = (tape.warp_forward);
713   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
714   int wait_delay_value = (no_delay ? 0 : frame_delay_value);
715   int jx = player->jx;
716   int jy = player->jy;
717
718   if (quick_relocation)
719   {
720     int offset = game.scroll_delay_value;
721
722     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
723     {
724       scroll_x = (player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
725                   player->jx > SBX_Right + MIDPOSX ? SBX_Right :
726                   player->jx - MIDPOSX);
727
728       scroll_y = (player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
729                   player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
730                   player->jy - MIDPOSY);
731     }
732     else
733     {
734       if ((player->MovDir == MV_LEFT  && scroll_x > jx - MIDPOSX + offset) ||
735           (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
736         scroll_x = jx - MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
737
738       if ((player->MovDir == MV_UP  && scroll_y > jy - MIDPOSY + offset) ||
739           (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
740         scroll_y = jy - MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
741
742       /* don't scroll over playfield boundaries */
743       if (scroll_x < SBX_Left || scroll_x > SBX_Right)
744         scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
745
746       /* don't scroll over playfield boundaries */
747       if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
748         scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
749     }
750
751     RedrawPlayfield(TRUE, 0,0,0,0);
752   }
753   else
754   {
755     int scroll_xx = -999, scroll_yy = -999;
756
757     ScrollScreen(NULL, SCROLL_GO_ON);   /* scroll last frame to full tile */
758
759     while (scroll_xx != scroll_x || scroll_yy != scroll_y)
760     {
761       int dx = 0, dy = 0;
762       int fx = FX, fy = FY;
763
764       scroll_xx = (player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
765                    player->jx > SBX_Right + MIDPOSX ? SBX_Right :
766                    player->jx - MIDPOSX);
767
768       scroll_yy = (player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
769                    player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
770                    player->jy - MIDPOSY);
771
772       dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
773       dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
774
775       if (dx == 0 && dy == 0)           /* no scrolling needed at all */
776         break;
777
778       scroll_x -= dx;
779       scroll_y -= dy;
780
781       fx += dx * TILEX / 2;
782       fy += dy * TILEY / 2;
783
784       ScrollLevel(dx, dy);
785       DrawAllPlayers();
786
787       /* scroll in two steps of half tile size to make things smoother */
788       BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
789       FlushDisplay();
790       Delay(wait_delay_value);
791
792       /* scroll second step to align at full tile size */
793       BackToFront();
794       Delay(wait_delay_value);
795     }
796
797     DrawPlayer(player);
798     BackToFront();
799     Delay(wait_delay_value);
800   }
801 }
802 #endif
803
804 static int getMaxCenterDistancePlayerNr(int center_x, int center_y)
805 {
806   int max_dx = 0, max_dy = 0;
807   int player_nr = game_em.last_moving_player;
808   int i;
809
810   for (i = 0; i < MAX_PLAYERS; i++)
811   {
812     if (ply[i].alive)
813     {
814       int sx = PLAYER_SCREEN_X(i);
815       int sy = PLAYER_SCREEN_Y(i);
816
817       if (game_em.last_player_direction[i] != MV_NONE &&
818           (ABS(sx - center_x) > max_dx ||
819            ABS(sy - center_y) > max_dy))
820       {
821         max_dx = MAX(max_dx, ABS(sx - center_x));
822         max_dy = MAX(max_dy, ABS(sy - center_y));
823
824         player_nr = i;
825       }
826     }
827   }
828
829   return player_nr;
830 }
831
832 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
833 {
834   boolean num_checked_players = 0;
835   int i;
836
837   for (i = 0; i < MAX_PLAYERS; i++)
838   {
839     if (ply[i].alive)
840     {
841       int sx = PLAYER_SCREEN_X(i);
842       int sy = PLAYER_SCREEN_Y(i);
843
844       if (num_checked_players == 0)
845       {
846         *sx1 = *sx2 = sx;
847         *sy1 = *sy2 = sy;
848       }
849       else
850       {
851         *sx1 = MIN(*sx1, sx);
852         *sy1 = MIN(*sy1, sy);
853         *sx2 = MAX(*sx2, sx);
854         *sy2 = MAX(*sy2, sy);
855       }
856
857       num_checked_players++;
858     }
859   }
860 }
861
862 boolean checkIfAllPlayersFitToScreen()
863 {
864   int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
865
866   setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
867
868   return (sx2 - sx1 <= SCR_FIELDX * TILEX &&
869           sy2 - sy1 <= SCR_FIELDY * TILEY);
870 }
871
872 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
873 {
874   int sx1 = screen_x, sy1 = screen_y, sx2 = screen_x, sy2 = screen_y;
875
876   setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
877
878   *sx = (sx1 + sx2) / 2;
879   *sy = (sy1 + sy2) / 2;
880 }
881
882 static void setMaxCenterDistanceForAllPlayers(int *max_dx, int *max_dy,
883                                               int center_x, int center_y)
884 {
885   int sx1 = center_x, sy1 = center_y, sx2 = center_x, sy2 = center_y;
886
887   setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
888
889   *max_dx = MAX(ABS(sx1 - center_x), ABS(sx2 - center_x));
890   *max_dy = MAX(ABS(sy1 - center_y), ABS(sy2 - center_y));
891 }
892
893 static boolean checkIfAllPlayersAreVisible(int center_x, int center_y)
894 {
895   int max_dx, max_dy;
896
897   setMaxCenterDistanceForAllPlayers(&max_dx, &max_dy, center_x, center_y);
898
899   return (max_dx <= SCR_FIELDX * TILEX / 2 &&
900           max_dy <= SCR_FIELDY * TILEY / 2);
901 }
902
903 void RedrawPlayfield_EM(boolean force_redraw)
904 {
905 #if 0
906   boolean all_players_visible = checkIfAllPlayersAreVisible();
907 #endif
908   boolean draw_new_player_location = FALSE;
909   boolean quick_relocation = setup.quick_switch;
910 #if 0
911   boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
912 #endif
913 #if 0
914   boolean game.set_centered_player = getSetCenteredPlayer_EM();
915   int game.centered_player_nr_next = getCenteredPlayerNr_EM();
916 #endif
917 #if 1
918   int max_center_distance_player_nr =
919     getMaxCenterDistancePlayerNr(screen_x, screen_y);
920 #else
921   int player_nr = game_em.last_moving_player;
922 #endif
923   int stepsize = TILEX / 8;
924   int offset = game.scroll_delay_value * TILEX;
925   int offset_x = offset;
926   int offset_y = offset;
927   int screen_x_old = screen_x;
928   int screen_y_old = screen_y;
929   int x, y, sx, sy;
930   int i;
931
932   if (game.set_centered_player)
933   {
934     boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen();
935
936     /* switching to "all players" only possible if all players fit to screen */
937     if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
938     {
939       game.centered_player_nr_next = game.centered_player_nr;
940       game.set_centered_player = FALSE;
941     }
942
943     /* do not switch focus to non-existing (or non-active) player */
944     if (game.centered_player_nr_next >= 0 &&
945         !ply[game.centered_player_nr_next].alive)
946     {
947       game.centered_player_nr_next = game.centered_player_nr;
948       game.set_centered_player = FALSE;
949     }
950   }
951
952 #if 1
953   /* also allow focus switching when screen is scrolled to half tile */
954 #else
955   if (!scrolling)       /* screen currently aligned at tile position */
956 #endif
957   {
958 #if 1
959     if (game.set_centered_player)
960 #else
961     if (game.centered_player_nr != game.centered_player_nr_next)
962 #endif
963     {
964       game.centered_player_nr = game.centered_player_nr_next;
965
966       draw_new_player_location = TRUE;
967       force_redraw = TRUE;
968
969       game.set_centered_player = FALSE;
970     }
971   }
972
973   if (game.centered_player_nr == -1)
974   {
975 #if 1
976     if (draw_new_player_location || offset == 0)
977 #else
978     if (draw_new_player_location)
979 #endif
980     {
981       setScreenCenteredToAllPlayers(&sx, &sy);
982     }
983     else
984     {
985 #if 1
986       sx = PLAYER_SCREEN_X(max_center_distance_player_nr);
987       sy = PLAYER_SCREEN_Y(max_center_distance_player_nr);
988 #else
989       sx = PLAYER_SCREEN_X(game_em.last_moving_player);
990       sy = PLAYER_SCREEN_Y(game_em.last_moving_player);
991 #endif
992     }
993   }
994   else
995   {
996     sx = PLAYER_SCREEN_X(game.centered_player_nr);
997     sy = PLAYER_SCREEN_Y(game.centered_player_nr);
998   }
999
1000   if (draw_new_player_location && quick_relocation)
1001   {
1002     screen_x = VALID_SCREEN_X(sx);
1003     screen_y = VALID_SCREEN_Y(sy);
1004     screen_x_old = screen_x;
1005     screen_y_old = screen_y;
1006
1007 #if 0
1008     offset_x = 0;
1009     offset_y = 0;
1010 #endif
1011   }
1012
1013   if (draw_new_player_location && !quick_relocation)
1014   {
1015 #if 1
1016     unsigned int game_frame_delay_value = getGameFrameDelay_EM(20);
1017 #else
1018     unsigned int game_frame_delay_value = getGameFrameDelay_EM(25);
1019 #endif
1020     int wait_delay_value = game_frame_delay_value;
1021     int screen_xx = VALID_SCREEN_X(sx);
1022     int screen_yy = VALID_SCREEN_Y(sy);
1023
1024     while (screen_x != screen_xx || screen_y != screen_yy)
1025     {
1026       int dx = (screen_xx < screen_x ? +1 : screen_xx > screen_x ? -1 : 0);
1027       int dy = (screen_yy < screen_y ? +1 : screen_yy > screen_y ? -1 : 0);
1028       int dxx = 0, dyy = 0;
1029
1030       if (dx == 0 && dy == 0)           /* no scrolling needed at all */
1031         break;
1032
1033 #if 1
1034
1035       if (ABS(screen_xx - screen_x) >= TILEX)
1036       {
1037         screen_x -= dx * TILEX;
1038         dxx = dx * TILEX / 2;
1039       }
1040       else
1041       {
1042         screen_x = screen_xx;
1043         dxx = 0;
1044       }
1045
1046       if (ABS(screen_yy - screen_y) >= TILEY)
1047       {
1048         screen_y -= dy * TILEY;
1049         dyy = dy * TILEY / 2;
1050       }
1051       else
1052       {
1053         screen_y = screen_yy;
1054         dyy = 0;
1055       }
1056
1057 #else
1058
1059 #if 1
1060       if (ABS(screen_xx - screen_x) >= TILEX ||
1061           ABS(screen_yy - screen_y) >= TILEY)
1062       {
1063         screen_x -= dx * TILEX;
1064         screen_y -= dy * TILEY;
1065
1066         dxx = dx * TILEX / 2;
1067         dyy = dy * TILEY / 2;
1068       }
1069       else
1070       {
1071         screen_x = screen_xx;
1072         screen_y = screen_yy;
1073
1074         dxx = 0;
1075         dyy = 0;
1076       }
1077 #else
1078       screen_x -= dx * TILEX;
1079       screen_y -= dy * TILEY;
1080
1081       dxx += dx * TILEX / 2;
1082       dyy += dy * TILEY / 2;
1083 #endif
1084
1085 #endif
1086
1087       /* scroll in two steps of half tile size to make things smoother */
1088       screen_x += dxx;
1089       screen_y += dyy;
1090
1091       animscreen();
1092
1093       for (i = 0; i < MAX_PLAYERS; i++)
1094         blitplayer(&ply[i]);
1095
1096       blitscreen();
1097
1098       Delay(wait_delay_value);
1099
1100       /* scroll second step to align at full tile size */
1101       screen_x -= dxx;
1102       screen_y -= dyy;
1103
1104 #if 0
1105       SyncDisplay();
1106 #endif
1107
1108       animscreen();
1109
1110       for (i = 0; i < MAX_PLAYERS; i++)
1111         blitplayer(&ply[i]);
1112
1113       blitscreen();
1114
1115       Delay(wait_delay_value);
1116     }
1117
1118     screen_x_old = screen_x;
1119     screen_y_old = screen_y;
1120   }
1121
1122   if (force_redraw)
1123   {
1124     for (y = 0; y < MAX_BUF_YSIZE; y++)
1125     {
1126       for (x = 0; x < MAX_BUF_XSIZE; x++)
1127       {
1128         screentiles[y][x] = -1;
1129         crumbled_state[y][x] = 0;
1130       }
1131     }
1132   }
1133
1134   /* calculate new screen scrolling position, with regard to scroll delay */
1135   screen_x = VALID_SCREEN_X(sx + offset_x < screen_x ? sx + offset_x :
1136                             sx - offset_x > screen_x ? sx - offset_x :
1137                             screen_x);
1138   screen_y = VALID_SCREEN_Y(sy + offset_y < screen_y ? sy + offset_y :
1139                             sy - offset_y > screen_y ? sy - offset_y :
1140                             screen_y);
1141
1142 #if 0
1143   printf("::: (%d, %d) => (%d, %d) [(%d, %d), (%d, %d)] [%d, %d] [%d / %d]\n",
1144          screen_x_old, screen_y_old,
1145          screen_x, screen_y,
1146          ply[max_center_distance_player_nr].oldx,
1147          ply[max_center_distance_player_nr].x,
1148          ply[max_center_distance_player_nr].oldy,
1149          ply[max_center_distance_player_nr].y,
1150          sx, sy,
1151          ABS(screen_x - screen_x_old),
1152          ABS(screen_y - screen_y_old));
1153 #endif
1154
1155 #if 1
1156
1157 #if 1
1158   /* prevent scrolling further than double player step size when scrolling */
1159   if (ABS(screen_x - screen_x_old) > 2 * stepsize)
1160   {
1161     int dx = SIGN(screen_x - screen_x_old);
1162
1163     screen_x = screen_x_old + dx * 2 * stepsize;
1164   }
1165   if (ABS(screen_y - screen_y_old) > 2 * stepsize)
1166   {
1167     int dy = SIGN(screen_y - screen_y_old);
1168
1169     screen_y = screen_y_old + dy * 2 * stepsize;
1170   }
1171 #else
1172   /* prevent scrolling further than double player step size when scrolling */
1173   if (ABS(screen_x - screen_x_old) > 2 * stepsize ||
1174       ABS(screen_y - screen_y_old) > 2 * stepsize)
1175   {
1176     int dx = SIGN(screen_x - screen_x_old);
1177     int dy = SIGN(screen_y - screen_y_old);
1178
1179     screen_x = screen_x_old + dx * 2 * stepsize;
1180     screen_y = screen_y_old + dy * 2 * stepsize;
1181   }
1182 #endif
1183
1184 #else
1185   /* prevent scrolling further than player step size when scrolling */
1186   if (ABS(screen_x - screen_x_old) > stepsize ||
1187       ABS(screen_y - screen_y_old) > stepsize)
1188   {
1189     int dx = SIGN(screen_x - screen_x_old);
1190     int dy = SIGN(screen_y - screen_y_old);
1191
1192     screen_x = screen_x_old + dx * stepsize;
1193     screen_y = screen_y_old + dy * stepsize;
1194   }
1195 #endif
1196
1197   /* prevent scrolling away from the other players when focus on all players */
1198   if (game.centered_player_nr == -1)
1199   {
1200 #if 1
1201     /* check if all players are still visible with new scrolling position */
1202     if (checkIfAllPlayersAreVisible(screen_x_old, screen_y_old) &&
1203         !checkIfAllPlayersAreVisible(screen_x, screen_y))
1204     {
1205       /* reset horizontal scroll position to last value, if needed */
1206       if (!checkIfAllPlayersAreVisible(screen_x, screen_y_old))
1207         screen_x = screen_x_old;
1208
1209       /* reset vertical scroll position to last value, if needed */
1210       if (!checkIfAllPlayersAreVisible(screen_x_old, screen_y))
1211         screen_y = screen_y_old;
1212     }
1213 #else
1214     boolean all_players_visible = checkIfAllPlayersAreVisible();
1215
1216     if (!all_players_visible)
1217     {
1218       printf("::: not all players visible\n");
1219
1220       screen_x = screen_x_old;
1221       screen_y = screen_y_old;
1222     }
1223 #endif
1224   }
1225
1226   /* prevent scrolling (for screen correcting) if no player is moving */
1227   if (!game_em.any_player_moving)
1228   {
1229     screen_x = screen_x_old;
1230     screen_y = screen_y_old;
1231   }
1232   else
1233   {
1234     /* prevent scrolling against the players move direction */
1235 #if 0
1236     int player_nr = game_em.last_moving_player;
1237 #endif
1238     int player_nr = (game.centered_player_nr == -1 ?
1239                      max_center_distance_player_nr : game.centered_player_nr);
1240     int player_move_dir = game_em.last_player_direction[player_nr];
1241     int dx = SIGN(screen_x - screen_x_old);
1242     int dy = SIGN(screen_y - screen_y_old);
1243
1244     if ((dx < 0 && player_move_dir != MV_LEFT) ||
1245         (dx > 0 && player_move_dir != MV_RIGHT))
1246       screen_x = screen_x_old;
1247
1248     if ((dy < 0 && player_move_dir != MV_UP) ||
1249         (dy > 0 && player_move_dir != MV_DOWN))
1250       screen_y = screen_y_old;
1251   }
1252
1253   animscreen();
1254
1255   for (i = 0; i < MAX_PLAYERS; i++)
1256     blitplayer(&ply[i]);
1257
1258 #if 0
1259 #if 0
1260   SyncDisplay();
1261 #endif
1262
1263   blitscreen();
1264 #endif
1265 }
1266
1267 void game_animscreen(void)
1268 {
1269   RedrawPlayfield_EM(FALSE);
1270 }
1271
1272 void DrawGameDoorValues_EM()
1273 {
1274 #if 1
1275   int dynamite_state;
1276   int key_state;
1277 #else
1278   int dynamite_state = ply[0].dynamite;         /* !!! ONLY PLAYER 1 !!! */
1279   int key_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
1280 #endif
1281
1282 #if 1
1283   if (game.centered_player_nr == -1)
1284   {
1285 #if 1
1286     int i;
1287
1288     dynamite_state = 0;
1289     key_state = 0;
1290
1291     for (i = 0; i < MAX_PLAYERS; i++)
1292     {
1293       dynamite_state += ply[i].dynamite;
1294       key_state |= ply[i].keys;
1295     }
1296
1297 #else
1298
1299     dynamite_state = ply[0].dynamite;           /* !!! ONLY PLAYER 1 !!! */
1300     key_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
1301 #endif
1302   }
1303   else
1304   {
1305     int player_nr = game.centered_player_nr;
1306
1307     dynamite_state = ply[player_nr].dynamite;
1308     key_state = ply[player_nr].keys;
1309   }
1310 #endif
1311
1312 #if 1
1313   DrawAllGameValues(lev.required, dynamite_state, lev.score,
1314                     lev.time, key_state);
1315 #else
1316   DrawAllGameValues(lev.required, ply1.dynamite, lev.score,
1317                     DISPLAY_TIME(lev.time), ply1.keys | ply2.keys);
1318 #endif
1319 }