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