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