src/game_sp/DDScrollBuffer.c

   1 // ----------------------------------------------------------------------------
   2 // DDScrollBuffer.c
   3 // ----------------------------------------------------------------------------
   4
   5 #include "DDScrollBuffer.h"
   6
   7 #include <math.h>
   8
   9
  10 long mScrollX, mScrollY;
  11 long mScrollX_last, mScrollY_last;
  12
  13 #if 1
  14 long ScreenBuffer[2 + MAX_PLAYFIELD_WIDTH + 2][2 + MAX_PLAYFIELD_HEIGHT + 2];
  15 boolean redraw[2 + MAX_PLAYFIELD_WIDTH + 2][2 + MAX_PLAYFIELD_HEIGHT + 2];
  16 #else
  17 long ScreenBuffer[MAX_BUF_XSIZE][MAX_BUF_YSIZE];
  18 boolean redraw[MAX_BUF_XSIZE][MAX_BUF_YSIZE];
  19 #endif
  20
  21
  22 void RestorePlayfield()
  23 {
  24   int x1 = mScrollX / TILEX - 2;
  25   int y1 = mScrollY / TILEY - 2;
  26   int x2 = mScrollX / TILEX + (SCR_FIELDX - 1) + 2;
  27   int y2 = mScrollY / TILEY + (SCR_FIELDY - 1) + 2;
  28   int x, y;
  29
  30   DrawFrameIfNeeded();
  31
  32   for (y = DisplayMinY; y <= DisplayMaxY; y++)
  33   {
  34     for (x = DisplayMinX; x <= DisplayMaxX; x++)
  35     {
  36       if (x >= x1 && x <= x2 && y >= y1 && y <= y2)
  37       {
  38         DrawFieldNoAnimated(x, y);
  39         DrawFieldAnimated(x, y);
  40       }
  41     }
  42   }
  43 }
  44
  45 static void ScrollPlayfield(int dx, int dy)
  46 {
  47   int x1 = mScrollX_last / TILEX - 2;
  48   int y1 = mScrollY_last / TILEY - 2;
  49   int x2 = mScrollX_last / TILEX + (SCR_FIELDX - 1) + 2;
  50   int y2 = mScrollY_last / TILEY + (SCR_FIELDY - 1) + 2;
  51   int x, y;
  52
  53   BlitBitmap(bitmap_db_field_sp, bitmap_db_field_sp,
  54              TILEX * (dx == -1),
  55              TILEY * (dy == -1),
  56              (MAX_BUF_XSIZE * TILEX) - TILEX * (dx != 0),
  57              (MAX_BUF_YSIZE * TILEY) - TILEY * (dy != 0),
  58              TILEX * (dx == 1),
  59              TILEY * (dy == 1));
  60
  61   /* when scrolling the whole playfield, do not redraw single tiles */
  62 #if 1
  63   for (x = 0; x < 2 + MAX_PLAYFIELD_WIDTH + 2; x++)
  64     for (y = 0; y < 2 + MAX_PLAYFIELD_HEIGHT + 2; y++)
  65       redraw[x][y] = FALSE;
  66 #else
  67   for (x = 0; x < MAX_BUF_XSIZE; x++)
  68     for (y = 0; y < MAX_BUF_YSIZE; y++)
  69       redraw[x][y] = FALSE;
  70 #endif
  71   redraw_tiles = 0;
  72
  73   DrawFrameIfNeeded();
  74
  75   for (y = DisplayMinY; y <= DisplayMaxY; y++)
  76   {
  77     for (x = DisplayMinX; x <= DisplayMaxX; x++)
  78     {
  79       if (x >= x1 && x <= x2 && y >= y1 && y <= y2)
  80       {
  81         int sx = x - x1;
  82         int sy = y - y1;
  83         int tsi = GetSI(x, y);
  84         long id = ((PlayField16[tsi]) |
  85                    (PlayField8[tsi] << 16) |
  86                    (DisPlayField[tsi] << 24));
  87
  88         if ((dx == -1 && x == x2) ||
  89             (dx == +1 && x == x1) ||
  90             (dy == -1 && y == y2) ||
  91             (dy == +1 && y == y1))
  92         {
  93           DrawFieldNoAnimated(x, y);
  94           DrawFieldAnimated(x, y);
  95         }
  96
  97         ScreenBuffer[sx][sy] = id;
  98       }
  99     }
 100   }
 101 }
 102
 103 static void ScrollPlayfieldIfNeededExt(boolean reset)
 104 {
 105   if (reset)
 106   {
 107     mScrollX_last = -1;
 108     mScrollY_last = -1;
 109
 110     return;
 111   }
 112
 113   if (mScrollX_last == -1 || mScrollY_last == -1)
 114   {
 115 #if 1
 116     mScrollX_last = (mScrollX / TILESIZE) * TILESIZE;
 117     mScrollY_last = (mScrollY / TILESIZE) * TILESIZE;
 118 #else
 119     mScrollX_last = mScrollX;
 120     mScrollY_last = mScrollY;
 121 #endif
 122
 123     return;
 124   }
 125
 126   /* check if scrolling the playfield requires redrawing the viewport bitmap */
 127   if ((mScrollX != mScrollX_last ||
 128        mScrollY != mScrollY_last) &&
 129       (ABS(mScrollX - mScrollX_last) >= TILEX ||
 130        ABS(mScrollY - mScrollY_last) >= TILEY))
 131   {
 132     int dx = (ABS(mScrollX - mScrollX_last) < TILEX ? 0 :
 133               mScrollX < mScrollX_last ? 1 : mScrollX > mScrollX_last ? -1 : 0);
 134     int dy = (ABS(mScrollY - mScrollY_last) < TILEY ? 0 :
 135               mScrollY < mScrollY_last ? 1 : mScrollY > mScrollY_last ? -1 : 0);
 136
 137     mScrollX_last -= dx * TILEX;
 138     mScrollY_last -= dy * TILEY;
 139
 140     ScrollPlayfield(dx, dy);
 141   }
 142 }
 143
 144 static void ScrollPlayfieldIfNeeded()
 145 {
 146   ScrollPlayfieldIfNeededExt(FALSE);
 147 }
 148
 149 void InitScrollPlayfield()
 150 {
 151   ScrollPlayfieldIfNeededExt(TRUE);
 152 }
 153
 154 #define DEBUG_REDRAW    0
 155
 156 void UpdatePlayfield(boolean force_redraw)
 157 {
 158   int x, y;
 159
 160 #if DEBUG_REDRAW
 161   int num_redrawn = 0;
 162 #endif
 163
 164   for (y = DisplayMinY; y <= DisplayMaxY; y++)
 165   {
 166     for (x = DisplayMinX; x <= DisplayMaxX; x++)
 167     {
 168       int element = LowByte(PlayField16[GetSI(x, y)]);
 169       int graphic = GfxGraphic[x][y];
 170       int sync_frame = GfxFrame[x][y];
 171       boolean redraw = force_redraw;
 172
 173 #if DEBUG_REDRAW
 174 #if 0
 175       redraw = TRUE;    // !!! TEST ONLY -- ALWAYS REDRAW !!!
 176 #endif
 177 #endif
 178
 179       if (graphic < 0)
 180       {
 181         GfxGraphicLast[x][y] = GfxGraphic[x][y];
 182
 183         continue;
 184       }
 185
 186       if (element != GfxElementLast[x][y] &&
 187           graphic == GfxGraphicLast[x][y])
 188       {
 189         /* element changed, but not graphic => disable updating graphic */
 190
 191         GfxElementLast[x][y] = element;
 192         GfxGraphicLast[x][y] = GfxGraphic[x][y] = -1;
 193
 194         continue;
 195       }
 196
 197       if (graphic != GfxGraphicLast[x][y])                      // new graphic
 198       {
 199         redraw = TRUE;
 200
 201         GfxElementLast[x][y] = element;
 202         GfxGraphicLast[x][y] = GfxGraphic[x][y];
 203         sync_frame = GfxFrame[x][y] = 0;
 204       }
 205       else if (isNextAnimationFrame_SP(graphic, sync_frame))    // new frame
 206       {
 207         redraw = TRUE;
 208       }
 209
 210       if (redraw)
 211       {
 212         int sx = x * StretchWidth;
 213         int sy = y * StretchWidth;
 214
 215 #if DEBUG_REDRAW
 216 #if 0
 217         printf("::: REDRAW (%d, %d): %d, %d\n", x, y, graphic, sync_frame);
 218 #endif
 219 #endif
 220
 221         DDSpriteBuffer_BltImg(sx, sy, graphic, sync_frame);
 222
 223 #if DEBUG_REDRAW
 224         num_redrawn++;
 225 #endif
 226       }
 227     }
 228   }
 229
 230 #if DEBUG_REDRAW
 231   printf("::: FRAME %d: %d redrawn\n", FrameCounter, num_redrawn);
 232 #endif
 233 }
 234
 235 /* copy the entire screen to the window at the scroll position */
 236
 237 void BlitScreenToBitmap_SP(Bitmap *target_bitmap)
 238 {
 239   int px = 2 * TILEX + (mScrollX - mScrollX_last) % TILEX;
 240   int py = 2 * TILEY + (mScrollY - mScrollY_last) % TILEY;
 241   int sx, sy, sxsize, sysize;
 242
 243 #if 0
 244   printf("::: %d, %d / %d, %d / %ld, %ld (%ld, %ld) / %d, %d\n",
 245          MurphyScreenXPos, MurphyScreenYPos,
 246          ScreenScrollXPos, ScreenScrollYPos,
 247          mScrollX, mScrollY,
 248          mScrollX_last, mScrollY_last,
 249          px, py);
 250 #endif
 251
 252   int xsize = SXSIZE;
 253   int ysize = SYSIZE;
 254   int full_xsize = (FieldWidth  - (menBorder ? 0 : 1)) * TILEX;
 255   int full_ysize = (FieldHeight - (menBorder ? 0 : 1)) * TILEY;
 256
 257   sxsize = (full_xsize < xsize ? full_xsize : xsize);
 258   sysize = (full_ysize < ysize ? full_ysize : ysize);
 259   sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
 260   sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
 261
 262   /* scroll correction for even number of visible tiles (half tile shifted) */
 263   px += game_sp.scroll_xoffset;
 264   py += game_sp.scroll_yoffset;
 265
 266 #if 1
 267   if (ExplosionShakeMurphy != 0)
 268   {
 269     px += TILEX / 2 - GetSimpleRandom(TILEX + 1);
 270     py += TILEY / 2 - GetSimpleRandom(TILEX + 1);
 271   }
 272 #endif
 273
 274   BlitBitmap(bitmap_db_field_sp, target_bitmap, px, py, sxsize, sysize, sx, sy);
 275 }
 276
 277 void BackToFront_SP(void)
 278 {
 279   static int scroll_x_last = -1, scroll_y_last = -1;
 280   static boolean scrolling_last = FALSE;
 281   static boolean ExplosionShakeMurphy_last = -1;
 282 #if 1
 283   boolean scrolling = (mScrollX != scroll_x_last || mScrollY != scroll_y_last);
 284   // boolean scrolling = (mScrollX != mScrollX_last || mScrollY != mScrollY_last);
 285 #else
 286   boolean scrolling = (mScrollX % TILEX != 0 || mScrollY % TILEY != 0);
 287 #endif
 288   int x, y;
 289
 290 #if 0
 291   printf("::: %d, %d / %d, %d [%d, %d]\n",
 292          mScrollX, mScrollY,
 293          mScrollX_last, mScrollY_last,
 294          game_sp.scroll_xoffset, game_sp.scroll_yoffset);
 295 #endif
 296
 297   SyncDisplay();
 298
 299   if (redraw_tiles > REDRAWTILES_THRESHOLD || scrolling || scrolling_last ||
 300       ExplosionShakeMurphy != 0 || ExplosionShakeMurphy_last != 0)
 301   {
 302     BlitScreenToBitmap_SP(window);
 303   }
 304   else
 305   {
 306     int scroll_xoffset = mScrollX - mScrollX_last + game_sp.scroll_xoffset;
 307     int scroll_yoffset = mScrollY - mScrollY_last + game_sp.scroll_yoffset;
 308     int x1 = 0, x2 = SCR_FIELDX - (scroll_xoffset != 0 ? 0 : 1);
 309     int y1 = 0, y2 = SCR_FIELDY - (scroll_yoffset != 0 ? 0 : 1);
 310     int full_xsize = (FieldWidth  - (menBorder ? 0 : 1)) * TILEX;
 311     int full_ysize = (FieldHeight - (menBorder ? 0 : 1)) * TILEY;
 312     int sx = SX + (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
 313     int sy = SY + (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
 314
 315     InitGfxClipRegion(TRUE, SX, SY, SXSIZE, SYSIZE);
 316
 317     for (x = x1; x <= x2; x++)
 318     {
 319       for (y = y1; y <= y2; y++)
 320       {
 321         int xx = 2 + x;
 322         int yy = 2 + y;
 323
 324         if (redraw[xx][yy])
 325           BlitBitmap(bitmap_db_field_sp, window,
 326                      xx * TILEX, yy * TILEY, TILEX, TILEY,
 327                      sx + x * TILEX - scroll_xoffset,
 328                      sy + y * TILEY - scroll_yoffset);
 329       }
 330     }
 331
 332     InitGfxClipRegion(FALSE, -1, -1, -1, -1);
 333   }
 334
 335   FlushDisplay();
 336
 337 #if 1
 338   for (x = 0; x < 2 + MAX_PLAYFIELD_WIDTH + 2; x++)
 339     for (y = 0; y < 2 + MAX_PLAYFIELD_HEIGHT + 2; y++)
 340       redraw[x][y] = FALSE;
 341 #else
 342   for (x = 0; x < MAX_BUF_XSIZE; x++)
 343     for (y = 0; y < MAX_BUF_YSIZE; y++)
 344       redraw[x][y] = FALSE;
 345 #endif
 346   redraw_tiles = 0;
 347
 348   scroll_x_last = mScrollX;
 349   scroll_y_last = mScrollY;
 350   scrolling_last = scrolling;
 351   ExplosionShakeMurphy_last = ExplosionShakeMurphy;
 352 }
 353
 354 void DDScrollBuffer_ScrollTo(int X, int Y)
 355 {
 356   if (NoDisplayFlag)
 357     return;
 358
 359   ScrollX = mScrollX = X;
 360   ScrollY = mScrollY = Y;
 361
 362   ScrollPlayfieldIfNeeded();
 363 }
 364
 365 void DDScrollBuffer_ScrollTowards(int X, int Y, double Step)
 366 {
 367   double dx, dY, r;
 368
 369   if (NoDisplayFlag)
 370     return;
 371
 372   dx = X - mScrollX;
 373   dY = Y - mScrollY;
 374
 375   r = Sqr(dx * dx + dY * dY);
 376   if (r == 0)   // we are there already
 377     return;
 378
 379   if (Step < r)
 380     r = Step / r;
 381   else
 382     r = 1;
 383
 384   ScrollX = mScrollX = mScrollX + dx * r;
 385   ScrollY = mScrollY = mScrollY + dY * r;
 386
 387   ScrollPlayfieldIfNeeded();
 388 }
 389
 390 void DDScrollBuffer_SoftScrollTo(int X, int Y, long TimeMS, int FPS)
 391 {
 392   double dx, dY;
 393   long dT, StepCount;
 394   double T, tStep;
 395   long oldX, oldY, maxD;
 396   static boolean AlreadyRunning = False;
 397
 398   if (NoDisplayFlag)
 399     return;
 400
 401   if (AlreadyRunning)
 402     return;
 403
 404   AlreadyRunning = True;
 405
 406   dx = X - mScrollX;
 407   dY = Y - mScrollY;
 408   maxD = (Abs(dx) < Abs(dY) ? Abs(dY) : Abs(dx));
 409
 410   StepCount = FPS * (TimeMS / (double)1000);
 411   if (StepCount > maxD)
 412     StepCount = maxD;
 413
 414   if (StepCount == 0)
 415     StepCount = 1;
 416
 417   dT = 1000 / FPS;
 418   tStep = (double)1 / StepCount;
 419   oldX = mScrollX;
 420   oldY = mScrollY;
 421
 422   for (T = (double)tStep; T <= (double)1; T += tStep)
 423   {
 424     ScrollX = mScrollX = oldX + T * dx;
 425     ScrollY = mScrollY = oldY + T * dY;
 426   }
 427
 428   ScrollX = mScrollX = X;
 429   ScrollY = mScrollY = Y;
 430
 431   AlreadyRunning = False;
 432
 433   ScrollPlayfieldIfNeeded();
 434 }