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