X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=25e138060311fa14b1ebca089bd154b2c7dc68db;hb=fbe0eaa3234fb6a69a65136f764922e24943501d;hp=0f4ce58eb9455bbb3bcd9d0231a783da8a3ad5dd;hpb=ecba6429f85a26d8b7f350ae99bdb3dbef6d6f32;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index 0f4ce58e..25e13806 100644
--- a/src/game.c
+++ b/src/game.c
@@ -14,9 +14,9 @@
 #include "libgame/libgame.h"
 
 #include "game.h"
+#include "init.h"
 #include "tools.h"
 #include "screens.h"
-#include "init.h"
 #include "files.h"
 #include "tape.h"
 #include "network.h"
@@ -500,9 +500,13 @@ static void InitGameEngine()
 {
   int i;
 
+  /* set game engine from tape file when re-playing, else from level file */
   game.engine_version = (tape.playing ? tape.engine_version :
 			 level.game_version);
 
+  /* dynamically adjust element properties according to game engine version */
+  InitElementPropertiesEngine(game.engine_version);
+
 #if 0
     printf("level %d: level version == %06d\n", level_nr, level.game_version);
     printf("          tape version == %06d [%s] [file: %06d]\n",
@@ -520,6 +524,7 @@ static void InitGameEngine()
   game.initial_move_delay_value =
     (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
 
+#if 0
   /* dynamically adjust element properties according to game engine version */
   {
     static int ep_em_slippery_wall[] =
@@ -543,6 +548,7 @@ static void InitGameEngine()
 		 (level.em_slippery_gems &&
 		  game.engine_version > VERSION_IDENT(2,0,1)));
   }
+#endif
 
   /* initialize changing elements information */
   for (i=0; i<MAX_NUM_ELEMENTS; i++)
@@ -941,7 +947,8 @@ void InitGame()
   if (setup.sound_music)
     PlayMusic(level_nr);
 
-  KeyboardAutoRepeatOff();
+  if (!tape.playing)
+    KeyboardAutoRepeatOff();
 
   if (options.debug)
   {
@@ -1535,14 +1542,14 @@ void Explode(int ex, int ey, int phase, int mode)
       }
 
 #if 1
+      if (IS_EXPLOSION_PROOF(element))
+	continue;
+#else
       if ((IS_INDESTRUCTIBLE(element) &&
 	   (game.engine_version < VERSION_IDENT(2,2,0) ||
 	    (!IS_WALKABLE_OVER(element) && !IS_WALKABLE_UNDER(element)))) ||
 	  element == EL_FLAMES)
 	continue;
-#else
-      if (IS_INDESTRUCTIBLE(element) || element == EL_FLAMES)
-        continue;
 #endif
 
       if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
@@ -1557,26 +1564,14 @@ void Explode(int ex, int ey, int phase, int mode)
 	continue;
       }
 
-#if 1
       /* save walkable background elements while explosion on same tile */
       if (IS_INDESTRUCTIBLE(element))
 	Back[x][y] = element;
-#endif
 
       /* ignite explodable elements reached by other explosion */
       if (element == EL_EXPLOSION)
 	element = Store2[x][y];
 
-#if 0
-      else if (IS_INDESTRUCTIBLE(Store2[x][y]))	/* hard element under bomb */
-	element = Store2[x][y];
-#endif
-
-#if 0
-      else if (IS_INDESTRUCTIBLE(Store[x][y]))	/* hard element under bomb */
-	element = Store[x][y];
-#endif
-
       if (IS_PLAYER(ex, ey) && !PLAYER_PROTECTED(ex, ey))
       {
 	switch(StorePlayer[ex][ey])
@@ -1599,18 +1594,6 @@ void Explode(int ex, int ey, int phase, int mode)
 	if (game.emulation == EMU_SUPAPLEX)
 	  Store[x][y] = EL_EMPTY;
       }
-#if 0
-      else if (IS_INDESTRUCTIBLE(Store[x][y]))
-	;
-#endif
-#if 0
-      else if (IS_INDESTRUCTIBLE(element))
-	Store[x][y] = element;
-#endif
-#if 0
-      else if (IS_INDESTRUCTIBLE(element) && IS_ACCESSIBLE(element))
-	Store[x][y] = element;
-#endif
       else if (center_element == EL_MOLE)
 	Store[x][y] = EL_EMERALD_RED;
       else if (center_element == EL_PENGUIN)
@@ -1641,31 +1624,8 @@ void Explode(int ex, int ey, int phase, int mode)
 	Store[x][y] = EL_PEARL;
       else if (element == EL_WALL_CRYSTAL)
 	Store[x][y] = EL_CRYSTAL;
-#if 1
-#if 0
-#if 0
-      else if (IS_INDESTRUCTIBLE(element) && IS_ACCESSIBLE(element))
-	Store[x][y] = element;
-#else
-      else if (IS_INDESTRUCTIBLE(element))
-	Store[x][y] = element;
-#endif
-#endif
       else
 	Store[x][y] = EL_EMPTY;
-#else
-
-#if 0
-      else if (IS_PFORTE(element))
-	Store[x][y] = element;
-      else
-	Store[x][y] = EL_EMPTY;
-#else
-      else if (!IS_PFORTE(Store[x][y]))
-	Store[x][y] = EL_EMPTY;
-#endif
-
-#endif
 
       if (x != ex || y != ey ||
 	  center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_BORDER)
@@ -1736,11 +1696,9 @@ void Explode(int ex, int ey, int phase, int mode)
     element = Feld[x][y] = Store[x][y];
     Store[x][y] = Store2[x][y] = 0;
 
-#if 1
     if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
       element = Feld[x][y] = Back[x][y];
     Back[x][y] = 0;
-#endif
 
     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
     InitField(x, y, FALSE);
@@ -1762,7 +1720,6 @@ void Explode(int ex, int ey, int phase, int mode)
     if (phase == delay)
       DrawLevelFieldCrumbledSand(x, y);
 
-#if 1
     if (IS_WALKABLE_OVER(Back[x][y]))
     {
       DrawLevelElement(x, y, Back[x][y]);
@@ -1775,15 +1732,6 @@ void Explode(int ex, int ey, int phase, int mode)
     }
     else if (!IS_WALKABLE_INSIDE(Back[x][y]))
       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
-#else
-    if (IS_PFORTE(Store[x][y]))
-    {
-      DrawLevelElement(x, y, Store[x][y]);
-      DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
-    }
-    else
-      DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
-#endif
   }
 }
 
@@ -3162,9 +3110,14 @@ void StartMoving(int x, int y)
 	  int sx = SCREENX(xx), sy = SCREENY(yy);
 	  int flame_graphic = graphic + (i - 1);
 
+#if 1
+	  if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
+	    break;
+#else
 	  if (!IN_LEV_FIELD(xx, yy) ||
-	      IS_SOLID(Feld[xx][yy]) || Feld[xx][yy] == EL_EXPLOSION)
+	      IS_HISTORIC_SOLID(Feld[xx][yy]) || Feld[xx][yy] == EL_EXPLOSION)
 	    break;
+#endif
 
 	  if (MovDelay[x][y])
 	  {
@@ -4228,22 +4181,22 @@ void MauerWaechst(int x, int y)
     {
       if (MovDir[x][y] == MV_LEFT)
       {
-	if (IN_LEV_FIELD(x - 1, y) && IS_MAUER(Feld[x - 1][y]))
+	if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
 	  DrawLevelField(x - 1, y);
       }
       else if (MovDir[x][y] == MV_RIGHT)
       {
-	if (IN_LEV_FIELD(x + 1, y) && IS_MAUER(Feld[x + 1][y]))
+	if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y]))
 	  DrawLevelField(x + 1, y);
       }
       else if (MovDir[x][y] == MV_UP)
       {
-	if (IN_LEV_FIELD(x, y - 1) && IS_MAUER(Feld[x][y - 1]))
+	if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
 	  DrawLevelField(x, y - 1);
       }
       else
       {
-	if (IN_LEV_FIELD(x, y + 1) && IS_MAUER(Feld[x][y + 1]))
+	if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
 	  DrawLevelField(x, y + 1);
       }
 
@@ -4342,13 +4295,13 @@ void MauerAbleger(int ax, int ay)
   if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
     DrawLevelField(ax, ay);
 
-  if (!IN_LEV_FIELD(ax, ay-1) || IS_MAUER(Feld[ax][ay-1]))
+  if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
     oben_massiv = TRUE;
-  if (!IN_LEV_FIELD(ax, ay+1) || IS_MAUER(Feld[ax][ay+1]))
+  if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
     unten_massiv = TRUE;
-  if (!IN_LEV_FIELD(ax-1, ay) || IS_MAUER(Feld[ax-1][ay]))
+  if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
     links_massiv = TRUE;
-  if (!IN_LEV_FIELD(ax+1, ay) || IS_MAUER(Feld[ax+1][ay]))
+  if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
     rechts_massiv = TRUE;
 
   if (((oben_massiv && unten_massiv) ||
@@ -5695,13 +5648,8 @@ void KillHero(struct PlayerInfo *player)
   if (!player->active)
     return;
 
-#if 1
   /* remove accessible field at the player's position */
   Feld[jx][jy] = EL_EMPTY;
-#else
-  if (IS_PFORTE(Feld[jx][jy]))
-    Feld[jx][jy] = EL_EMPTY;
-#endif
 
   /* deactivate shield (else Bang()/Explode() would not work right) */
   player->shield_normal_time_left = 0;
@@ -5753,17 +5701,57 @@ void RemoveHero(struct PlayerInfo *player)
   ExitY = ZY = jy;
 }
 
-#if 0
 /*
   checkDiagonalPushing()
   -----------------------------------------------------------------------------
   check if diagonal input device direction results in pushing of object
+  (by checking if the alternative direction is walkable, diggable, ...)
 */
 
-static boolean checkDiagonalPushing(int x, int y, int real_dx, int real_dy)
+static boolean checkDiagonalPushing(struct PlayerInfo *player,
+				    int x, int y, int real_dx, int real_dy)
 {
-}
+#if 1
+  int jx, jy, dx, dy, xx, yy;
+
+  if (real_dx == 0 || real_dy == 0)	/* no diagonal direction => push */
+    return TRUE;
+
+  /* diagonal direction: check alternative direction */
+  jx = player->jx;
+  jy = player->jy;
+  dx = x - jx;
+  dy = y - jy;
+  xx = jx + (dx == 0 ? real_dx : 0);
+  yy = jy + (dy == 0 ? real_dy : 0);
+
+  return (!IN_LEV_FIELD(xx, yy) || IS_SOLID(Feld[xx][yy]));
+#else
+
+  if (real_dx && real_dy) 	/* diagonal direction input => do check */
+  {
+    /* diagonal direction: check alternative direction */
+    int jx = player->jx, jy = player->jy;
+    int dx = x - jx, dy = y - jy;
+    int xx = jx + (dx == 0 ? real_dx : 0);
+    int yy = jy + (dy == 0 ? real_dy : 0);
+
+    if (IN_LEV_FIELD(xx, yy))
+    {
+      int element = Feld[xx][yy];
+
+      if (game.engine_version < VERSION_IDENT(2,2,0))
+	return IS_HISTORIC_SOLID(element);
+      else
+	return !(IS_WALKABLE(element) ||
+		 IS_DIGGABLE(element) ||
+		 IS_COLLECTIBLE(element));
+    }
+  }
+
+  return TRUE;		/* no diagonal direction input => push object */
 #endif
+}
 
 /*
   DigField()
@@ -5802,9 +5790,15 @@ int DigField(struct PlayerInfo *player,
   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
     return MF_NO_ACTION;
 
-  if (IS_TUBE(Feld[jx][jy]))
+#if 0
+  if (IS_TUBE(Feld[jx][jy]) || IS_TUBE(Back[jx][jy]))
+#else
+  if (IS_TUBE(Feld[jx][jy]) ||
+      (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0)))
+#endif
   {
     int i = 0;
+    int tube_element = (IS_TUBE(Feld[jx][jy]) ? Feld[jx][jy] : Back[jx][jy]);
     int tube_leave_directions[][2] =
     {
       { EL_TUBE_ANY,			MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
@@ -5821,7 +5815,7 @@ int DigField(struct PlayerInfo *player,
       { -1,                     	MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
     };
 
-    while (tube_leave_directions[i][0] != Feld[jx][jy])
+    while (tube_leave_directions[i][0] != tube_element)
     {
       i++;
       if (tube_leave_directions[i][0] == -1)	/* should not happen */
@@ -6112,11 +6106,17 @@ int DigField(struct PlayerInfo *player,
       if (!IN_LEV_FIELD(x+dx, y+dy) || !IS_FREE(x+dx, y+dy))
 	return MF_NO_ACTION;
 
+#if 1
+      if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
+	return MF_NO_ACTION;
+#else
       if (real_dy)
       {
-	if (IN_LEV_FIELD(jx, jy+real_dy) && !IS_SOLID(Feld[jx][jy+real_dy]))
+	if (IN_LEV_FIELD(jx, jy+real_dy) &&
+	    !IS_HISTORIC_SOLID(Feld[jx][jy+real_dy]))
 	  return MF_NO_ACTION;
       }
+#endif
 
       if (player->push_delay == 0)
 	player->push_delay = FrameCounter;
@@ -6358,16 +6358,23 @@ int DigField(struct PlayerInfo *player,
 		  || !IS_SB_ELEMENT(element))))
 	return MF_NO_ACTION;
 
+#if 1
+      if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
+	return MF_NO_ACTION;
+#else
       if (dx && real_dy)
       {
-	if (IN_LEV_FIELD(jx, jy+real_dy) && !IS_SOLID(Feld[jx][jy+real_dy]))
+	if (IN_LEV_FIELD(jx, jy+real_dy) &&
+	    !IS_HISTORIC_SOLID(Feld[jx][jy+real_dy]))
 	  return MF_NO_ACTION;
       }
       else if (dy && real_dx)
       {
-	if (IN_LEV_FIELD(jx+real_dx, jy) && !IS_SOLID(Feld[jx+real_dx][jy]))
+	if (IN_LEV_FIELD(jx+real_dx, jy) &&
+	    !IS_HISTORIC_SOLID(Feld[jx+real_dx][jy]))
 	  return MF_NO_ACTION;
       }
+#endif
 
       if (player->push_delay == 0)
 	player->push_delay = FrameCounter;
@@ -6467,16 +6474,23 @@ int DigField(struct PlayerInfo *player,
 	if (!IN_LEV_FIELD(x+dx, y+dy) || !IS_FREE(x+dx, y+dy))
 	  return MF_NO_ACTION;
 
+#if 1
+	if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
+	  return MF_NO_ACTION;
+#else
 	if (dx && real_dy)
 	{
-	  if (IN_LEV_FIELD(jx, jy+real_dy) && !IS_SOLID(Feld[jx][jy+real_dy]))
+	  if (IN_LEV_FIELD(jx, jy+real_dy) &&
+	      !IS_HISTORIC_SOLID(Feld[jx][jy+real_dy]))
 	    return MF_NO_ACTION;
 	}
 	else if (dy && real_dx)
 	{
-	  if (IN_LEV_FIELD(jx+real_dx, jy) && !IS_SOLID(Feld[jx+real_dx][jy]))
+	  if (IN_LEV_FIELD(jx+real_dx, jy) &&
+	      !IS_HISTORIC_SOLID(Feld[jx+real_dx][jy]))
 	    return MF_NO_ACTION;
 	}
+#endif
 
 	if (player->push_delay == 0)
 	  player->push_delay = FrameCounter;
@@ -6569,6 +6583,11 @@ boolean PlaceBomb(struct PlayerInfo *player)
       IS_ACTIVE_BOMB(element) || element == EL_EXPLOSION)
     return FALSE;
 
+#if 0
+  if (element != EL_EMPTY)
+    return FALSE;
+#endif
+
   if (element != EL_EMPTY)
   {
 #if 0