X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame_mm%2Fmm_game.c;h=a5b34f290936e49ac503786a01760362e785a201;hb=3d59a9398925c218223ce77701c0cda3fe6c1d88;hp=78f0f954b802fa246733bee85a6ec434f6eeb3ca;hpb=a090db4b7fe71e37e0873111498a7b379b847995;p=rocksndiamonds.git

diff --git a/src/game_mm/mm_game.c b/src/game_mm/mm_game.c
index 78f0f954..a5b34f29 100644
--- a/src/game_mm/mm_game.c
+++ b/src/game_mm/mm_game.c
@@ -97,7 +97,6 @@ static void RaiseScoreElement_MM(int);
 static void RemoveMovingField_MM(int, int);
 static void InitMovingField_MM(int, int, int);
 static void ContinueMoving_MM(int, int);
-static void Moving2Blocked_MM(int, int, int *, int *);
 
 static void AddLaserEdge(int, int);
 static void ScanLaser(void);
@@ -364,7 +363,7 @@ static void DrawLaserLines(struct XY *points, int num_points, int mode)
   Pixel pixel_drawto = (mode == DL_LASER_ENABLED ? pen_ray     : pen_bg);
   Pixel pixel_buffer = (mode == DL_LASER_ENABLED ? WHITE_PIXEL : BLACK_PIXEL);
 
-  DrawLines(drawto, points, num_points, pixel_drawto);
+  DrawLines(drawto_mm, points, num_points, pixel_drawto);
 
   BEGIN_NO_HEADLESS
   {
@@ -570,6 +569,8 @@ static void InitField(int x, int y, boolean init_game)
           game_mm.laser_green = native_mm_level.df_laser_green;
           game_mm.laser_blue  = native_mm_level.df_laser_blue;
         }
+
+	game_mm.has_mcduffin = (IS_MCDUFFIN(element));
       }
 
       break;
@@ -642,8 +643,8 @@ void InitGameEngine_MM(void)
   BEGIN_NO_HEADLESS
   {
     // initialize laser bitmap to current playfield (screen) size
-    ReCreateBitmap(&laser_bitmap, drawto->width, drawto->height);
-    ClearRectangle(laser_bitmap, 0, 0, drawto->width, drawto->height);
+    ReCreateBitmap(&laser_bitmap, drawto_mm->width, drawto_mm->height);
+    ClearRectangle(laser_bitmap, 0, 0, drawto_mm->width, drawto_mm->height);
   }
   END_NO_HEADLESS
 
@@ -662,10 +663,12 @@ void InitGameEngine_MM(void)
   game_mm.laser_red = FALSE;
   game_mm.laser_green = FALSE;
   game_mm.laser_blue = TRUE;
+  game_mm.has_mcduffin = TRUE;
 
   game_mm.level_solved = FALSE;
   game_mm.game_over = FALSE;
   game_mm.game_over_cause = 0;
+  game_mm.game_over_message = NULL;
 
   game_mm.laser_overload_value = 0;
   game_mm.laser_enabled = FALSE;
@@ -758,7 +761,7 @@ void InitGameActions_MM(void)
 
     DrawLevel_MM();
 
-    BackToFront();
+    BackToFront_MM();
 
 #ifdef DEBUG
     if (setup.quick_doors)
@@ -791,7 +794,7 @@ static void FadeOutLaser(void)
 
     DrawLaser(0, DL_LASER_ENABLED);
 
-    BackToFront();
+    BackToFront_MM();
     Delay_WithScreenUpdates(50);
   }
 
@@ -802,31 +805,35 @@ static void FadeOutLaser(void)
 
 static void GameOver_MM(int game_over_cause)
 {
-  // do not handle game over if request dialog is already active
-  if (game.request_active)
-    return;
-
   game_mm.game_over = TRUE;
   game_mm.game_over_cause = game_over_cause;
-
-  if (setup.ask_on_game_over)
-    game.restart_game_message = (game_over_cause == GAME_OVER_BOMB ?
-				 "Bomb killed Mc Duffin! Play it again?" :
-				 game_over_cause == GAME_OVER_NO_ENERGY ?
-				 "Out of magic energy! Play it again?" :
-				 game_over_cause == GAME_OVER_OVERLOADED ?
-				 "Magic spell hit Mc Duffin! Play it again?" :
-				 NULL);
+  game_mm.game_over_message = (game_mm.has_mcduffin ?
+			       (game_over_cause == GAME_OVER_BOMB ?
+				"Bomb killed Mc Duffin!" :
+				game_over_cause == GAME_OVER_NO_ENERGY ?
+				"Out of magic energy!" :
+				game_over_cause == GAME_OVER_OVERLOADED ?
+				"Magic spell hit Mc Duffin!" :
+				NULL) :
+			       (game_over_cause == GAME_OVER_BOMB ?
+				"Bomb destroyed laser cannon!" :
+				game_over_cause == GAME_OVER_NO_ENERGY ?
+				"Out of laser energy!" :
+				game_over_cause == GAME_OVER_OVERLOADED ?
+				"Laser beam hit laser cannon!" :
+				NULL));
 
   SetTileCursorActive(FALSE);
 }
 
 static void AddLaserEdge(int lx, int ly)
 {
-  int clx = dSX + lx;
-  int cly = dSY + ly;
+  int full_sxsize = MAX(FULL_SXSIZE, lev_fieldx * TILEX);
+  int full_sysize = MAX(FULL_SYSIZE, lev_fieldy * TILEY);
 
-  if (clx < -2 || cly < -2 || clx >= SXSIZE + 2 || cly >= SYSIZE + 2)
+  // check if laser is still inside visible playfield area (or inside level)
+  if (cSX + lx < REAL_SX || cSX + lx >= REAL_SX + full_sxsize ||
+      cSY + ly < REAL_SY || cSY + ly >= REAL_SY + full_sysize)
   {
     Warn("AddLaserEdge: out of bounds: %d, %d", lx, ly);
 
@@ -874,16 +881,28 @@ static boolean StepBehind(void)
 
 static int getMaskFromElement(int element)
 {
-  if (IS_GRID(element))
-    return MM_MASK_GRID_1 + get_element_phase(element);
-  else if (IS_MCDUFFIN(element))
+  if (IS_MCDUFFIN(element))
     return MM_MASK_MCDUFFIN_RIGHT + get_element_phase(element);
-  else if (IS_RECTANGLE(element) || IS_DF_GRID(element))
+  else if (IS_GRID(element))
+    return MM_MASK_GRID_1 + get_element_phase(element);
+  else if (IS_DF_GRID(element))
+    return MM_MASK_RECTANGLE;
+  else if (IS_RECTANGLE(element))
     return MM_MASK_RECTANGLE;
   else
     return MM_MASK_CIRCLE;
 }
 
+static int getLevelFromLaserX(int x)
+{
+  return x / TILEX - (x < 0 ? 1 : 0);		// correct negative values
+}
+
+static int getLevelFromLaserY(int y)
+{
+  return y / TILEY - (y < 0 ? 1 : 0);		// correct negative values
+}
+
 static int ScanPixel(void)
 {
   int hit_mask = 0;
@@ -909,14 +928,34 @@ static int ScanPixel(void)
     }
 #endif
 
+    // check if laser scan has crossed element boundaries (not just mini tiles)
+    boolean cross_x = (LX / TILEX != (LX + 2) / TILEX);
+    boolean cross_y = (LY / TILEY != (LY + 2) / TILEY);
+
+    if (cross_x && cross_y)
+    {
+      int elx1 = (LX - XS) / TILEX;
+      int ely1 = (LY + YS) / TILEY;
+      int elx2 = (LX + XS) / TILEX;
+      int ely2 = (LY - YS) / TILEY;
+
+      // add element corners left and right from the laser beam to damage list
+
+      if (IN_LEV_FIELD(elx1, ely1) && Tile[elx1][ely1] != EL_EMPTY)
+	AddDamagedField(elx1, ely1);
+
+      if (IN_LEV_FIELD(elx2, ely2) && Tile[elx2][ely2] != EL_EMPTY)
+	AddDamagedField(elx2, ely2);
+    }
+
     for (i = 0; i < 4; i++)
     {
       int px = LX + (i % 2) * 2;
       int py = LY + (i / 2) * 2;
       int dx = px % TILEX;
       int dy = py % TILEY;
-      int lx = (px + TILEX) / TILEX - 1;  // ...+TILEX...-1 to get correct
-      int ly = (py + TILEY) / TILEY - 1;  // negative values!
+      int lx = getLevelFromLaserX(px);
+      int ly = getLevelFromLaserY(py);
       Pixel pixel;
 
       if (IN_LEV_FIELD(lx, ly))
@@ -942,6 +981,7 @@ static int ScanPixel(void)
       }
       else
       {
+	// check if laser is still inside visible playfield area
 	pixel = (cSX + px < REAL_SX || cSX + px >= REAL_SX + FULL_SXSIZE ||
 		 cSY + py < REAL_SY || cSY + py >= REAL_SY + FULL_SYSIZE);
       }
@@ -1032,41 +1072,92 @@ static void ScanLaser(void)
 	  LX, LY, XS, YS);
 #endif
 
-    // hit something -- check out what it was
-    ELX = (LX + XS) / TILEX;
-    ELY = (LY + YS) / TILEY;
+    // check if laser scan has hit two diagonally adjacent element corners
+    boolean diag_1 = ((hit_mask & HIT_MASK_DIAGONAL_1) == HIT_MASK_DIAGONAL_1);
+    boolean diag_2 = ((hit_mask & HIT_MASK_DIAGONAL_2) == HIT_MASK_DIAGONAL_2);
+
+    // check if laser scan has crossed element boundaries (not just mini tiles)
+    boolean cross_x = (getLevelFromLaserX(LX) != getLevelFromLaserX(LX + 2));
+    boolean cross_y = (getLevelFromLaserY(LY) != getLevelFromLaserY(LY + 2));
+
+    if (cross_x || cross_y)
+    {
+      // hit something at next tile -- check out what it was
+      ELX = getLevelFromLaserX(LX + XS);
+      ELY = getLevelFromLaserY(LY + YS);
+    }
+    else
+    {
+      // hit something at same tile -- check out what it was
+      ELX = getLevelFromLaserX(LX);
+      ELY = getLevelFromLaserY(LY);
+    }
 
 #if 0
     Debug("game:mm:ScanLaser", "hit_mask (1) == '%x' (%d, %d) (%d, %d)",
 	  hit_mask, LX, LY, ELX, ELY);
 #endif
 
-    if (!IN_LEV_FIELD(ELX, ELY) || !IN_PIX_FIELD(LX, LY))
+    if (!IN_LEV_FIELD(ELX, ELY))
     {
+      // laser next step position
+      int x = cSX + LX + XS;
+      int y = cSY + LY + YS;
+
+      // check if next step of laser is still inside visible playfield area
+      if (x >= REAL_SX && x < REAL_SX + FULL_SXSIZE &&
+	  y >= REAL_SY && y < REAL_SY + FULL_SYSIZE)
+      {
+	// go on with another step
+	LX += XS;
+	LY += YS;
+
+	continue;
+      }
+
       element = EL_EMPTY;
       laser.dest_element = element;
 
       break;
     }
 
-    if (hit_mask == (HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT))
+    // handle special case of laser hitting two diagonally adjacent elements
+    // (with or without a third corner element behind these two elements)
+    if ((diag_1 || diag_2) && cross_x && cross_y)
     {
-      /* we have hit the top-right and bottom-left element --
-	 choose the bottom-left one */
-      /* !!! THIS CAN BE DONE MORE INTELLIGENTLY, FOR EXAMPLE, IF ONE
-	 ELEMENT WAS STEEL AND THE OTHER ONE WAS ICE => ALWAYS CHOOSE
-	 THE ICE AND MELT IT AWAY INSTEAD OF OVERLOADING LASER !!! */
-      ELX = (LX - 2) / TILEX;
-      ELY = (LY + 2) / TILEY;
-    }
+      // compare the two diagonally adjacent elements
+      int xoffset = 2;
+      int yoffset = 2 * (diag_1 ? -1 : +1);
+      int elx1 = (LX - xoffset) / TILEX;
+      int ely1 = (LY + yoffset) / TILEY;
+      int elx2 = (LX + xoffset) / TILEX;
+      int ely2 = (LY - yoffset) / TILEY;
+      int e1 = Tile[elx1][ely1];
+      int e2 = Tile[elx2][ely2];
+      boolean use_element_1 = FALSE;
+
+      if (IS_WALL_ICE(e1) || IS_WALL_ICE(e2))
+      {
+	if (IS_WALL_ICE(e1) && IS_WALL_ICE(e2))
+	  use_element_1 = (RND(2) ? TRUE : FALSE);
+	else if (IS_WALL_ICE(e1))
+	  use_element_1 = TRUE;
+      }
+      else if (IS_WALL_AMOEBA(e1) || IS_WALL_AMOEBA(e2))
+      {
+	// if both tiles match, we can just select the first one
+	if (IS_WALL_AMOEBA(e1))
+	  use_element_1 = TRUE;
+      }
+      else if (IS_ABSORBING_BLOCK(e1) || IS_ABSORBING_BLOCK(e2))
+      {
+	// if both tiles match, we can just select the first one
+	if (IS_ABSORBING_BLOCK(e1))
+	  use_element_1 = TRUE;
+      }
 
-    if (hit_mask == (HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT))
-    {
-      /* we have hit the top-left and bottom-right element --
-	 choose the top-left one */
-      // !!! SEE ABOVE !!!
-      ELX = (LX - 2) / TILEX;
-      ELY = (LY - 2) / TILEY;
+      ELX = (use_element_1 ? elx1 : elx2);
+      ELY = (use_element_1 ? ely1 : ely2);
     }
 
 #if 0
@@ -1620,6 +1711,7 @@ static boolean HitElement(int element, int hit_mask)
       IS_POLAR_CROSS(element) ||
       IS_DF_MIRROR(element) ||
       IS_DF_MIRROR_AUTO(element) ||
+      IS_DF_MIRROR_FIXED(element) ||
       element == EL_PRISM ||
       element == EL_REFRACTOR)
   {
@@ -1638,7 +1730,8 @@ static boolean HitElement(int element, int hit_mask)
     if (IS_MIRROR(element) ||
 	IS_MIRROR_FIXED(element) ||
 	IS_DF_MIRROR(element) ||
-	IS_DF_MIRROR_AUTO(element))
+	IS_DF_MIRROR_AUTO(element) ||
+	IS_DF_MIRROR_FIXED(element))
       laser.current_angle = get_mirrored_angle(laser.current_angle,
 					       get_element_angle(element));
 
@@ -1975,10 +2068,16 @@ static boolean HitPolarizer(int element, int hit_mask)
   }
   else if (IS_GRID_STEEL(element))
   {
+    // may be required if graphics for steel grid redefined
+    AddDamagedField(ELX, ELY);
+
     return HitReflectingWalls(element, hit_mask);
   }
   else	// IS_GRID_WOOD
   {
+    // may be required if graphics for wooden grid redefined
+    AddDamagedField(ELX, ELY);
+
     return HitAbsorbingWalls(element, hit_mask);
   }
 
@@ -2028,11 +2127,9 @@ static boolean HitBlock(int element, int hit_mask)
   if (element == EL_GATE_STONE || element == EL_GATE_WOOD)
   {
     int xs = XS / 2, ys = YS / 2;
-    int hit_mask_diagonal1 = HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT;
-    int hit_mask_diagonal2 = HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT;
 
-    if ((hit_mask & hit_mask_diagonal1) == hit_mask_diagonal1 ||
-	(hit_mask & hit_mask_diagonal2) == hit_mask_diagonal2)
+    if ((hit_mask & HIT_MASK_DIAGONAL_1) == HIT_MASK_DIAGONAL_1 ||
+	(hit_mask & HIT_MASK_DIAGONAL_2) == HIT_MASK_DIAGONAL_2)
     {
       laser.overloaded = (element == EL_GATE_STONE);
 
@@ -2071,11 +2168,9 @@ static boolean HitBlock(int element, int hit_mask)
   if (element == EL_BLOCK_STONE || element == EL_BLOCK_WOOD)
   {
     int xs = XS / 2, ys = YS / 2;
-    int hit_mask_diagonal1 = HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT;
-    int hit_mask_diagonal2 = HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT;
 
-    if ((hit_mask & hit_mask_diagonal1) == hit_mask_diagonal1 ||
-	(hit_mask & hit_mask_diagonal2) == hit_mask_diagonal2)
+    if ((hit_mask & HIT_MASK_DIAGONAL_1) == HIT_MASK_DIAGONAL_1 ||
+	(hit_mask & HIT_MASK_DIAGONAL_2) == HIT_MASK_DIAGONAL_2)
     {
       laser.overloaded = (element == EL_BLOCK_STONE);
 
@@ -2405,10 +2500,18 @@ static boolean HitAbsorbingWalls(int element, int hit_mask)
 
   if (IS_WALL_ICE(element))
   {
+    int lx = LX + XS;
+    int ly = LY + YS;
     int mask;
 
-    mask = (LX + XS) / MINI_TILEX - ELX * 2 + 1;    // Quadrant (horizontal)
-    mask <<= (((LY + YS) / MINI_TILEY - ELY * 2) > 0) * 2;  // || (vertical)
+    // check if laser hit adjacent edges of two diagonal tiles
+    if (ELX != lx / TILEX)
+      lx = LX - XS;
+    if (ELY != ly / TILEY)
+      ly = LY - YS;
+
+    mask =     lx / MINI_TILEX - ELX * 2 + 1;    // Quadrant (horizontal)
+    mask <<= ((ly / MINI_TILEY - ELY * 2) > 0 ? 2 : 0);  // || (vertical)
 
     // check if laser hits wall with an angle of 90°
     if (IS_90_ANGLE(laser.current_angle))
@@ -2504,7 +2607,7 @@ static void OpenGrayBall(int x, int y)
       DrawWalls_MM(x, y, Store[x][y]);
 
       // copy wall tile to spare bitmap for "melting" animation
-      BlitBitmap(drawto, bitmap_db_field, cSX + x * TILEX, cSY + y * TILEY,
+      BlitBitmap(drawto_mm, bitmap_db_field, cSX + x * TILEX, cSY + y * TILEY,
 		 TILEX, TILEY, x * TILEX, y * TILEY);
 
       DrawElement_MM(x, y, EL_GRAY_BALL);
@@ -2537,7 +2640,7 @@ static void OpenGrayBall(int x, int y)
 	getGraphicSource(graphic, 0, &bitmap, &gx, &gy);
       }
 
-      BlitBitmap(bitmap, drawto, gx + dx, gy + dy, 6, 6,
+      BlitBitmap(bitmap, drawto_mm, gx + dx, gy + dy, 6, 6,
 		 cSX + x * TILEX + dx, cSY + y * TILEY + dy);
 
       laser.redraw = TRUE;
@@ -2590,7 +2693,7 @@ static void OpenEnvelope(int x, int y)
 
       ScanLaser();
 
-      ShowEnvelope_MM(nr);
+      ShowEnvelope(nr);
     }
   }
 }
@@ -2769,11 +2872,9 @@ static void Explode_MM(int x, int y, int phase, int mode)
 
       Bang_MM(laser.start_edge.x, laser.start_edge.y);
 
-      GameOver_MM(GAME_OVER_DELAYED);
-
       laser.overloaded = FALSE;
     }
-    else if (IS_MCDUFFIN(center_element))
+    else if (IS_MCDUFFIN(center_element) || IS_LASER(center_element))
     {
       GameOver_MM(GAME_OVER_BOMB);
     }
@@ -2823,26 +2924,28 @@ static void TurnRound(int x, int y)
     int x, y;
   } move_xy[] =
   {
-    { 0, 0 },
-    {-1, 0 },
-    {+1, 0 },
-    { 0, 0 },
-    { 0, -1 },
-    { 0, 0 }, { 0, 0 }, { 0, 0 },
-    { 0, +1 }
+    {  0,  0 },
+    { -1,  0 },
+    { +1,  0 },
+    {  0,  0 },
+    {  0, -1 },
+    {  0,  0 }, { 0, 0 }, { 0, 0 },
+    {  0, +1 }
   };
   static struct
   {
     int left, right, back;
   } turn[] =
   {
-    { 0,	0,		0 },
+    { 0,	0,		0	 },
     { MV_DOWN,	MV_UP,		MV_RIGHT },
-    { MV_UP,	MV_DOWN,	MV_LEFT },
-    { 0,	0,		0 },
-    { MV_LEFT,	MV_RIGHT,	MV_DOWN },
-    { 0,0,0 },	{ 0,0,0 },	{ 0,0,0 },
-    { MV_RIGHT,	MV_LEFT,	MV_UP }
+    { MV_UP,	MV_DOWN,	MV_LEFT	 },
+    { 0,	0,		0	 },
+    { MV_LEFT,	MV_RIGHT,	MV_DOWN	 },
+    { 0,	0,		0	 },
+    { 0,	0,		0	 },
+    { 0,	0,		0	 },
+    { MV_RIGHT,	MV_LEFT,	MV_UP	 }
   };
 
   int element = Tile[x][y];
@@ -2890,7 +2993,7 @@ static void StartMoving_MM(int x, int y)
 
     // now make next step
 
-    Moving2Blocked_MM(x, y, &newx, &newy);	// get next screen position
+    Moving2Blocked(x, y, &newx, &newy);	// get next screen position
 
     if (element == EL_PACMAN &&
 	IN_LEV_FIELD(newx, newy) && IS_EATABLE4PACMAN(Tile[newx][newy]) &&
@@ -3027,29 +3130,25 @@ boolean ClickElement(int x, int y, int button)
   }
   else if (IS_MCDUFFIN(element))
   {
-    if (!laser.fuse_off)
-    {
-      DrawLaser(0, DL_LASER_DISABLED);
+    boolean has_laser = (x == laser.start_edge.x && y == laser.start_edge.y);
 
-      /*
-      BackToFront();
-      */
-    }
+    if (has_laser && !laser.fuse_off)
+      DrawLaser(0, DL_LASER_DISABLED);
 
     element = get_rotated_element(element, BUTTON_ROTATION(button));
-    laser.start_angle = get_element_angle(element);
-
-    InitLaser();
 
     Tile[x][y] = element;
     DrawField_MM(x, y);
 
-    /*
-    BackToFront();
-    */
+    if (has_laser)
+    {
+      laser.start_angle = get_element_angle(element);
 
-    if (!laser.fuse_off)
-      ScanLaser();
+      InitLaser();
+
+      if (!laser.fuse_off)
+	ScanLaser();
+    }
 
     element_clicked = TRUE;
   }
@@ -3216,7 +3315,11 @@ static void AutoRotateMirrors(void)
 	  IS_GRID_WOOD_AUTO(element) ||
 	  IS_GRID_STEEL_AUTO(element) ||
 	  element == EL_REFRACTOR)
+      {
 	RotateMirror(x, y, MB_RIGHTBUTTON);
+
+	laser.redraw = TRUE;
+      }
     }
   }
 }
@@ -3689,7 +3792,7 @@ static void GameActions_MM_Ext(void)
 
       UpdateAndDisplayGameControlValues();
 
-      BackToFront();
+      BackToFront_MM();
     }
 
     Tile[ELX][ELY] = laser.dest_element = EL_FUEL_EMPTY;
@@ -3788,7 +3891,7 @@ static void MovePacMen(void)
     }
 
     DrawField_MM(nx, ny);
-    BackToFront();
+    BackToFront_MM();
 
     if (!laser.fuse_off)
     {
@@ -3829,35 +3932,6 @@ static void InitMovingField_MM(int x, int y, int direction)
     Tile[newx][newy] = EL_BLOCKED;
 }
 
-static void Moving2Blocked_MM(int x, int y, int *goes_to_x, int *goes_to_y)
-{
-  int direction = MovDir[x][y];
-  int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
-  int newy = y + (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
-
-  *goes_to_x = newx;
-  *goes_to_y = newy;
-}
-
-static void Blocked2Moving_MM(int x, int y,
-			      int *comes_from_x, int *comes_from_y)
-{
-  int oldx = x, oldy = y;
-  int direction = MovDir[x][y];
-
-  if (direction == MV_LEFT)
-    oldx++;
-  else if (direction == MV_RIGHT)
-    oldx--;
-  else if (direction == MV_UP)
-    oldy++;
-  else if (direction == MV_DOWN)
-    oldy--;
-
-  *comes_from_x = oldx;
-  *comes_from_y = oldy;
-}
-
 static int MovingOrBlocked2Element_MM(int x, int y)
 {
   int element = Tile[x][y];
@@ -3866,7 +3940,7 @@ static int MovingOrBlocked2Element_MM(int x, int y)
   {
     int oldx, oldy;
 
-    Blocked2Moving_MM(x, y, &oldx, &oldy);
+    Blocked2Moving(x, y, &oldx, &oldy);
 
     return Tile[oldx][oldy];
   }
@@ -3883,13 +3957,13 @@ static void RemoveMovingField_MM(int x, int y)
 
   if (IS_MOVING(x, y))
   {
-    Moving2Blocked_MM(x, y, &newx, &newy);
+    Moving2Blocked(x, y, &newx, &newy);
     if (Tile[newx][newy] != EL_BLOCKED)
       return;
   }
   else if (Tile[x][y] == EL_BLOCKED)
   {
-    Blocked2Moving_MM(x, y, &oldx, &oldy);
+    Blocked2Moving(x, y, &oldx, &oldy);
     if (!IS_MOVING(oldx, oldy))
       return;
   }