X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame_sp%2FDDScrollBuffer.c;h=5a89919c320bc0982be26a0b3d365d535c6f680f;hb=f7b79b71faf7e5fbe38df38d26d1156f3ba2f0ce;hp=859fb35d18e7cc83842101d17ae4790637e22be5;hpb=ed873d89bc59f4e641134f9019ce216234b9f38f;p=rocksndiamonds.git

diff --git a/src/game_sp/DDScrollBuffer.c b/src/game_sp/DDScrollBuffer.c
index 859fb35d..5a89919c 100644
--- a/src/game_sp/DDScrollBuffer.c
+++ b/src/game_sp/DDScrollBuffer.c
@@ -129,6 +129,31 @@ static void ScrollPlayfieldIfNeededExt(boolean reset)
     return;
   }
 
+#if 1
+
+  /* check if scrolling the playfield requires redrawing the viewport bitmap */
+  if ((mScrollX != mScrollX_last ||
+       mScrollY != mScrollY_last) &&
+      (ABS(mScrollX - mScrollX_last) >= TILEX ||
+       ABS(mScrollY - mScrollY_last) >= TILEY))
+  {
+    int dx = (ABS(mScrollX - mScrollX_last) < TILEX ? 0 :
+	      mScrollX < mScrollX_last ? 1 : mScrollX > mScrollX_last ? -1 : 0);
+    int dy = (ABS(mScrollY - mScrollY_last) < TILEY ? 0 :
+	      mScrollY < mScrollY_last ? 1 : mScrollY > mScrollY_last ? -1 : 0);
+
+    mScrollX_last -= dx * TILEX;
+    mScrollY_last -= dy * TILEY;
+
+    ScrollPlayfield(dx, dy);
+
+#if 0
+    printf("::: %ld, %ld\n", mScrollX, mScrollY);
+#endif
+  }
+
+#else
+
   /* check if scrolling the playfield reached the destination tile position */
   if ((mScrollX != mScrollX_last || mScrollY != mScrollY_last) &&
       mScrollX % TILEX == 0 && mScrollY % TILEY == 0)
@@ -140,7 +165,13 @@ static void ScrollPlayfieldIfNeededExt(boolean reset)
     mScrollY_last = mScrollY;
 
     ScrollPlayfield(dx, dy);
+
+#if 0
+    printf("::: %ld, %ld\n", mScrollX, mScrollY);
+#endif
   }
+
+#endif
 }
 
 static void ScrollPlayfieldIfNeeded()
@@ -154,6 +185,76 @@ void InitScrollPlayfield()
 }
 
 void UpdatePlayfield()
+{
+  int x, y;
+#if 1
+  int num_redrawn = 0;
+#endif
+
+  for (y = DisplayMinY; y <= DisplayMaxY; y++)
+  {
+    for (x = DisplayMinX; x <= DisplayMaxX; x++)
+    {
+      int element = LowByte(PlayField16[GetSI(x, y)]);
+      int graphic = GfxGraphic[x][y];
+      int sync_frame = GfxFrame[x][y];
+#if 1
+      boolean redraw = FALSE;
+#else
+      boolean redraw = TRUE;	// !!! TEST ONLY -- ALWAYS REDRAW !!!
+#endif
+
+      if (graphic < 0)
+	continue;
+
+      if (element != GfxElementLast[x][y] &&
+	  graphic == GfxGraphicLast[x][y])
+      {
+	/* element changed, but not graphic => disable updating graphic */
+
+	GfxElementLast[x][y] = element;
+	GfxGraphicLast[x][y] = GfxGraphic[x][y] = -1;
+
+	continue;
+      }
+
+      if (graphic != GfxGraphicLast[x][y])			// new graphic
+      {
+	redraw = TRUE;
+
+	GfxElementLast[x][y] = element;
+	GfxGraphicLast[x][y] = GfxGraphic[x][y];
+	sync_frame = GfxFrame[x][y] = 0;
+      }
+      else if (isNextAnimationFrame_SP(graphic, sync_frame))	// new frame
+      {
+	redraw = TRUE;
+      }
+
+      if (redraw)
+      {
+	int sx = x * StretchWidth;
+	int sy = y * StretchWidth;
+
+#if 0
+	printf("::: REDRAW (%d, %d): %d, %d\n", x, y, graphic, sync_frame);
+#endif
+
+	StretchedSprites.BltImg(sx, sy, graphic, sync_frame);
+
+#if 1
+	num_redrawn++;
+#endif
+      }
+    }
+  }
+
+#if 0
+  printf("::: FRAME %d: %d redrawn\n", FrameCounter, num_redrawn);
+#endif
+}
+
+void UpdatePlayfield_TMP()
 {
   int x1 = mScrollX_last / TILEX - 2;
   int y1 = mScrollY_last / TILEY - 2;
@@ -284,6 +385,8 @@ int DDScrollBuffer_Get_Height()
   return Height;
 }
 
+#if 0
+
 long DDScrollBuffer_CreateAtSize(long Width, long Height, long hWndViewPort)
 {
   long CreateAtSize;
@@ -327,15 +430,28 @@ void DDScrollBuffer_Cls(int BackColor)
   Buffer.BltColorFill(EmptyRect, BackColor);
 }
 
+#endif
 
 /* copy the entire screen to the window at the scroll position */
 
 void BlitScreenToBitmap_SP(Bitmap *target_bitmap)
 {
+#if 0
+  int px = 2 * TILEX + mScrollX % TILEX;
+  int py = 2 * TILEY + mScrollY % TILEY;
+#else
   int px = 2 * TILEX + (mScrollX - mScrollX_last) % TILEX;
   int py = 2 * TILEY + (mScrollY - mScrollY_last) % TILEY;
+#endif
   int sx, sy, sxsize, sysize;
 
+#if 0
+  if (mScrollX % TILEX != (mScrollX - mScrollX_last) % TILEX ||
+      mScrollY % TILEY != (mScrollY - mScrollY_last) % TILEY)
+    printf("::: %ld, %ld / %ld, %ld\n",
+	   mScrollX, mScrollY, mScrollX_last, mScrollY_last);
+#endif
+
 #if 1
   int xsize = SXSIZE;
   int ysize = SYSIZE;
@@ -348,6 +464,36 @@ void BlitScreenToBitmap_SP(Bitmap *target_bitmap)
   sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
 #endif
 
+#if 0
+  {
+    static int mScrollX_tmp = -1;
+    static int mScrollY_tmp = -1;
+
+    if (mScrollX != mScrollX_tmp || mScrollY != mScrollY_tmp)
+    {
+      printf("::: %ld, %ld\n", mScrollX, mScrollY);
+
+      mScrollX_tmp = mScrollX;
+      mScrollY_tmp = mScrollY;
+    }
+  }
+#endif
+
+#if 0
+  {
+    static boolean x = 0;
+
+    if (x == 0)
+    {
+      printf("::: %d, %d (%d, %d) (%d, %d) [%ld, %ld] [%ld, %ld] \n",
+	     sx, sy, xsize, ysize, full_xsize, full_ysize,
+	     mScrollX, mScrollY, mScrollX_last, mScrollY_last);
+
+      x = 1;
+    }
+  }
+#endif
+
 #if 1
   if (!menBorder.Checked)
   {
@@ -356,6 +502,29 @@ void BlitScreenToBitmap_SP(Bitmap *target_bitmap)
   }
 #endif
 
+#if 0
+  if (mScrollX >= 0 && mScrollX <= 16)
+  {
+    px -= mScrollX;
+  }
+#if 0
+  else if (mScrollX >= 352 && mScrollX <= 368)
+  {
+    px -= mScrollX;
+  }
+#endif
+  else if (mScrollX >= 16) // && mScrollX <= 352)
+  {
+    px -= TILEX / 2;
+  }
+#endif
+
+#if 0
+  /* !!! TEST ONLY !!! */
+  px = py = 0;
+  sx = sy = SX;
+#endif
+
   BlitBitmap(screenBitmap, target_bitmap, px, py, sxsize, sysize, sx, sy);
 }
 
@@ -457,8 +626,12 @@ void BackToFront_SP(void)
 
 void DDScrollBuffer_Blt_Ext(Bitmap *target_bitmap)
 {
-  RECT DR, SR;
+  MyRECT DR, SR;
+#if 1
+  long tX, tY;
+#else
   long tX, tY, L;
+#endif
   int sX, sY;
   // RECT ERect;
   // long Restore;
@@ -574,8 +747,12 @@ void DDScrollBuffer_Blt_Ext(Bitmap *target_bitmap)
   if (IS_NOTHING(&Buffer, sizeof(Buffer)))
     return;
 
+#if 0
   if (IS_NOTHING(&PrimarySurface, sizeof(PrimarySurface)))
     return;
+#endif
+
+#if 0
 
   L = PrimarySurface.Blt(DR, &Buffer, SR, DDBLT_WAIT);
   if (L != DD_OK)
@@ -644,6 +821,7 @@ void DDScrollBuffer_Blt_Ext(Bitmap *target_bitmap)
         break;
 #endif
 
+#if 0
       case DDERR_SURFACELOST:
         DDraw.RestoreAllSurfaces();
         if (! PrimarySurface.isLost())
@@ -655,6 +833,7 @@ void DDScrollBuffer_Blt_Ext(Bitmap *target_bitmap)
         // RestorePrimarySurface
         // ClipToWindow 0
         break;
+#endif
 
 #if 0
       case DDERR_UNSUPPORTED:
@@ -672,6 +851,8 @@ void DDScrollBuffer_Blt_Ext(Bitmap *target_bitmap)
     }
   }
 
+#endif
+
 #if 0
   //  Buffer.UpdateOverlay SR, PrimarySurface, DR, DDOVER_SHOW
   if (EditFlag)
@@ -728,8 +909,8 @@ void DDScrollBuffer_ScrollTowards(int X, int Y, double Step)
     return;
 
 #if 0
-  printf("::: DDScrollBuffer.c: DDScrollBuffer_ScrollTowards(): (1) mScroll: %ld, %ld [%d, %d, %f]\n",
-	 mScrollX, mScrollY, X, Y, Step);
+  printf("::: DDScrollBuffer.c: DDScrollBuffer_ScrollTowards(): (1) mScroll: %ld, %ld [%d, %d, %f, %f]\n",
+	 mScrollX, mScrollY, X, Y, Step, Stretch);
 #endif
 
   X = X / Stretch;
@@ -771,6 +952,14 @@ void DDScrollBuffer_SoftScrollTo(int X, int Y, long TimeMS, int FPS)
   long oldX, oldY, maxD;
   static boolean AlreadyRunning = False;
 
+#if 0
+  printf(":a: %d, %d [%d, %d] [%d, %d] [%d, %d]\n",
+	 mScrollX, mScrollY,
+	 mScrollX_last, mScrollY_last,
+	 ScreenScrollXPos, ScreenScrollYPos,
+	 ScrollX, ScrollY);
+#endif
+
   if (NoDisplayFlag)
     return;
 
@@ -813,9 +1002,20 @@ void DDScrollBuffer_SoftScrollTo(int X, int Y, long TimeMS, int FPS)
     mScrollY = oldY + T * dY;
     ScrollX = mScrollX;
     ScrollY = mScrollY;
-    // Blt();
+
+#if 0
+    Blt();
+#endif
   }
 
+#if 0
+  printf(":x: %d, %d [%d, %d] [%d, %d] [%d, %d]\n",
+	 mScrollX, mScrollY,
+	 mScrollX_last, mScrollY_last,
+	 ScreenScrollXPos, ScreenScrollYPos,
+	 ScrollX, ScrollY);
+#endif
+
   if (UserDragFlag)
     goto SoftScrollEH;
 
@@ -827,7 +1027,10 @@ void DDScrollBuffer_SoftScrollTo(int X, int Y, long TimeMS, int FPS)
   mScrollY = Y;
   ScrollX = mScrollX;
   ScrollY = mScrollY;
-  // Blt();
+
+#if 0
+  Blt();
+#endif
 
 SoftScrollEH:
   AlreadyRunning = False;
@@ -837,7 +1040,23 @@ SoftScrollEH:
 	 mScrollX, mScrollY);
 #endif
 
+#if 0
+  printf(":y: %d, %d [%d, %d] [%d, %d] [%d, %d]\n",
+	 mScrollX, mScrollY,
+	 mScrollX_last, mScrollY_last,
+	 ScreenScrollXPos, ScreenScrollYPos,
+	 ScrollX, ScrollY);
+#endif
+
 #if 1
   ScrollPlayfieldIfNeeded();
 #endif
+
+#if 0
+  printf(":z: %d, %d [%d, %d] [%d, %d] [%d, %d]\n",
+	 mScrollX, mScrollY,
+	 mScrollX_last, mScrollY_last,
+	 ScreenScrollXPos, ScreenScrollYPos,
+	 ScrollX, ScrollY);
+#endif
 }