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