X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Feditor.c;h=2b4c4ff28cefd684ca554f0ff406ad00afc03da5;hb=d2fe3484366d23690887c6547636cd681db22007;hp=4c592cf8c2a674ba36efba07f5ea280a1593f9b1;hpb=fe3196f07cb50ffb788c0073b82f94c26f93cfbf;p=rocksndiamonds.git

diff --git a/src/editor.c b/src/editor.c
index 4c592cf8..2b4c4ff2 100644
--- a/src/editor.c
+++ b/src/editor.c
@@ -3119,7 +3119,11 @@ static int ed_fieldx = MAX_ED_FIELDX - 1, ed_fieldy = MAX_ED_FIELDY - 1;
 /* actual position of level editor drawing area in level playfield */
 static int level_xpos = -1, level_ypos = -1;
 
+#if 1
+#define IN_ED_FIELD(x,y)	IN_FIELD(x, y, ed_fieldx, ed_fieldy)
+#else
 #define IN_ED_FIELD(x,y)  ((x)>=0 && (x)<ed_fieldx && (y)>=0 &&(y)<ed_fieldy)
+#endif
 
 /* drawing elements on the three mouse buttons */
 static int new_element1 = EL_WALL;
@@ -3170,6 +3174,7 @@ static int properties_element = 0;
 
 static short FieldBackup[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 static short UndoBuffer[NUM_UNDO_STEPS][MAX_LEV_FIELDX][MAX_LEV_FIELDY];
+static short IntelliDrawBuffer[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 static int undo_buffer_position = 0;
 static int undo_buffer_steps = 0;
 
@@ -7562,8 +7567,8 @@ static int PrintElementDescriptionFromFile(char *filename, int start_line)
   int max_chars_per_line = (SXSIZE - 2 * pad_x) / font_width;
   int max_lines_per_screen = (SYSIZE - pad_y) / font_height - 1;
 
-  return DrawTextFromFile(sx, sy, filename, font_nr, max_chars_per_line,
-			  max_lines_per_screen, TRUE);
+  return DrawTextFile(sx, sy, filename, font_nr, max_chars_per_line, -1,
+		      max_lines_per_screen, -1, TRUE, FALSE, FALSE);
 }
 
 static void DrawPropertiesTabulatorGadgets()
@@ -8345,15 +8350,493 @@ static void UpdateCustomElementGraphicGadgets()
   }
 }
 
+static int getDirectionFromTube(int element)
+{
+  switch (element)
+  {
+    case EL_TUBE_LEFT_UP:		return (MV_LEFT | MV_UP);
+    case EL_TUBE_LEFT_DOWN:		return (MV_LEFT | MV_DOWN);
+    case EL_TUBE_RIGHT_UP:		return (MV_RIGHT | MV_UP);
+    case EL_TUBE_RIGHT_DOWN:		return (MV_RIGHT | MV_DOWN);
+    case EL_TUBE_HORIZONTAL:		return (MV_HORIZONTAL);
+    case EL_TUBE_HORIZONTAL_UP:		return (MV_HORIZONTAL | MV_UP);
+    case EL_TUBE_HORIZONTAL_DOWN:	return (MV_HORIZONTAL | MV_DOWN);
+    case EL_TUBE_VERTICAL:		return (MV_VERTICAL);
+    case EL_TUBE_VERTICAL_LEFT:		return (MV_VERTICAL | MV_LEFT);
+    case EL_TUBE_VERTICAL_RIGHT:	return (MV_VERTICAL | MV_RIGHT);
+    case EL_TUBE_ANY:			return (MV_ANY_DIRECTION);
+  }
+
+  return MV_NONE;
+}
+
+static int getTubeFromDirection(int direction)
+{
+  switch (direction)
+  {
+    case (MV_LEFT | MV_UP):		return EL_TUBE_LEFT_UP;
+    case (MV_LEFT | MV_DOWN):		return EL_TUBE_LEFT_DOWN;
+    case (MV_RIGHT | MV_UP):		return EL_TUBE_RIGHT_UP;
+    case (MV_RIGHT | MV_DOWN):		return EL_TUBE_RIGHT_DOWN;
+    case (MV_HORIZONTAL):		return EL_TUBE_HORIZONTAL;
+    case (MV_HORIZONTAL | MV_UP):	return EL_TUBE_HORIZONTAL_UP;
+    case (MV_HORIZONTAL | MV_DOWN):	return EL_TUBE_HORIZONTAL_DOWN;
+    case (MV_VERTICAL):			return EL_TUBE_VERTICAL;
+    case (MV_VERTICAL | MV_LEFT):	return EL_TUBE_VERTICAL_LEFT;
+    case (MV_VERTICAL | MV_RIGHT):	return EL_TUBE_VERTICAL_RIGHT;
+    case (MV_ANY_DIRECTION):		return EL_TUBE_ANY;
+
+    /* if only one direction, fall back to simple tube with that direction */
+    case (MV_LEFT):			return EL_TUBE_HORIZONTAL;
+    case (MV_RIGHT):			return EL_TUBE_HORIZONTAL;
+    case (MV_UP):			return EL_TUBE_VERTICAL;
+    case (MV_DOWN):			return EL_TUBE_VERTICAL;
+  }
+
+  return EL_EMPTY;
+}
+
+static int getTubeFromDirectionNotEmpty(int direction, int element_old)
+{
+  int element_new = getTubeFromDirection(direction);
+
+  return (element_new != EL_EMPTY ? element_new : element_old);
+}
+
+static int getOpenDirectionFromBelt(int element)
+{
+  int belt_dir = getBeltDirFromBeltElement(element);
+
+  return (belt_dir == MV_LEFT ? MV_RIGHT :
+	  belt_dir == MV_RIGHT ? MV_LEFT :
+	  belt_dir == MV_NONE ? MV_HORIZONTAL : belt_dir);
+}
+
+static int getBeltFromNrAndOpenDirection(int nr, int direction)
+{
+  int belt_dir = (direction == MV_LEFT ? MV_RIGHT :
+		  direction == MV_RIGHT ? MV_LEFT :
+		  direction == MV_HORIZONTAL ? MV_NONE : direction);
+
+  return getBeltElementFromBeltNrAndBeltDir(nr, belt_dir);
+}
+
+static int getClosedTube(int x, int y)
+{
+  static int xy[4][2] =
+  {
+    { -1, 0 },
+    { +1, 0 },
+    { 0, -1 },
+    { 0, +1 }
+  };
+  int element_old = IntelliDrawBuffer[x][y];
+  int tube_direction_old = getDirectionFromTube(element_old);
+  int tube_direction_new = MV_NONE;
+  int i;
+
+  for (i = 0; i < NUM_DIRECTIONS; i++)
+  {
+    int xx = x + xy[i][0];
+    int yy = y + xy[i][1];
+    int dir = MV_DIR_FROM_BIT(i);
+    int dir_opposite = MV_DIR_OPPOSITE(dir);
+
+    if (IN_LEV_FIELD(xx, yy) && IS_TUBE(IntelliDrawBuffer[xx][yy]) &&
+	(tube_direction_old & dir) &&
+	(getDirectionFromTube(IntelliDrawBuffer[xx][yy]) & dir_opposite))
+      tube_direction_new |= dir;
+  }
+
+  return getTubeFromDirectionNotEmpty(tube_direction_new, element_old);
+}
+
+static int getClosedBelt(int x, int y)
+{
+  static int xy[2][2] =
+  {
+    { -1, 0 },
+    { +1, 0 },
+  };
+  int element_old = IntelliDrawBuffer[x][y];
+  int belt_nr = getBeltNrFromBeltElement(element_old);
+  int belt_direction_old = getOpenDirectionFromBelt(element_old);
+  int belt_direction_new = MV_NONE;
+  int i;
+
+  for (i = 0; i < 2; i++)
+  {
+    int xx = x + xy[i][0];
+    int yy = y + xy[i][1];
+    int dir = MV_DIR_FROM_BIT(i);
+    int dir_opposite = MV_DIR_OPPOSITE(dir);
+
+    if (IN_LEV_FIELD(xx, yy) && IS_BELT(IntelliDrawBuffer[xx][yy]) &&
+	(belt_direction_old & dir) &&
+	(getOpenDirectionFromBelt(IntelliDrawBuffer[xx][yy]) & dir_opposite))
+      belt_direction_new |= dir;
+  }
+
+  return getBeltFromNrAndOpenDirection(belt_nr, belt_direction_new);
+}
+
+static void SetElementSimple(int x, int y, int element, boolean change_level)
+{
+  if (change_level)
+    Feld[x][y] = element;
+
+  IntelliDrawBuffer[x][y] = element;
+
+  if (IN_ED_FIELD(x - level_xpos, y - level_ypos))
+    DrawMiniElement(x - level_xpos, y - level_ypos, element);
+}
+
+static void SetElementIntelliDraw(int x, int y, int new_element,
+				  boolean change_level)
+{
+  static int last_x = -1;
+  static int last_y = -1;
+  int old_element = IntelliDrawBuffer[x][y];
+
+  if (new_element == EL_UNDEFINED)
+  {
+    last_x = -1;
+    last_y = -1;
+
+    return;
+  }
+
+  if (IS_TUBE(new_element))
+  {
+    static int xy[4][2] =
+    {
+      { -1, 0 },
+      { +1, 0 },
+      { 0, -1 },
+      { 0, +1 }
+    };
+    boolean last_element_is_neighbour = FALSE;
+    int last_element_new;
+    int direction = MV_NONE;
+    int i;
+
+    /* if existing element is tube, keep all existing tube directions */
+    if (IS_TUBE(old_element))
+      direction |= getDirectionFromTube(old_element);
+
+    for (i = 0; i < NUM_DIRECTIONS; i++)
+    {
+      int xx = x + xy[i][0];
+      int yy = y + xy[i][1];
+
+      if (last_x == xx && last_y == yy && IN_LEV_FIELD(last_x, last_y) &&
+	  IS_TUBE(IntelliDrawBuffer[last_x][last_y]))
+      {
+	int dir = MV_DIR_FROM_BIT(i);
+	int dir_opposite = MV_DIR_OPPOSITE(dir);
+	int last_element_old = IntelliDrawBuffer[last_x][last_y];
+	int last_direction_old = getDirectionFromTube(last_element_old);
+	int last_direction_new = last_direction_old | dir_opposite;
+
+	last_element_new = getTubeFromDirection(last_direction_new);
+	last_element_is_neighbour = TRUE;
+
+	direction |= dir;
+      }
+    }
+
+    new_element = getTubeFromDirectionNotEmpty(direction, new_element);
+
+    /* reduce connections of neighbour tube elements to minimal connections */
+    if (last_element_is_neighbour)
+    {
+      /* set neighbour tube elements to newly determined tube connections */
+      SetElementSimple(x, y, new_element, change_level);
+      SetElementSimple(last_x, last_y, last_element_new, change_level);
+
+      /* remove all open tube connections of neighbour tube elements */
+      new_element = getClosedTube(x, y);
+      last_element_new = getClosedTube(last_x, last_y);
+
+      /* set neighbour tube elements to new, minimized tube connections */
+      SetElementSimple(x, y, new_element, change_level);
+      SetElementSimple(last_x, last_y, last_element_new, change_level);
+    }
+  }
+  else if (IS_ACID_POOL(new_element))
+  {
+    int last_element_new = EL_UNDEFINED;
+
+    if (IS_ACID_POOL(old_element))
+    {
+      new_element = old_element;
+    }
+
+    if (last_x == x - 1 && last_y == y && IN_LEV_FIELD(last_x, last_y) &&
+	IS_ACID_POOL(IntelliDrawBuffer[last_x][last_y]))
+    {
+      if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPLEFT)
+      {
+	new_element = EL_ACID_POOL_TOPRIGHT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPRIGHT)
+      {
+	last_element_new = EL_ACID;
+	new_element = EL_ACID_POOL_TOPRIGHT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMLEFT)
+      {
+	new_element = EL_ACID_POOL_BOTTOMRIGHT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMRIGHT)
+      {
+	last_element_new = EL_ACID_POOL_BOTTOM;
+	new_element = EL_ACID_POOL_BOTTOMRIGHT;
+      }
+    }
+    else if (last_x == x + 1 && last_y == y && IN_LEV_FIELD(last_x, last_y) &&
+	     IS_ACID_POOL(IntelliDrawBuffer[last_x][last_y]))
+    {
+      if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPLEFT)
+      {
+	last_element_new = EL_ACID;
+	new_element = EL_ACID_POOL_TOPLEFT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPRIGHT)
+      {
+	new_element = EL_ACID_POOL_TOPLEFT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMLEFT)
+      {
+	last_element_new = EL_ACID_POOL_BOTTOM;
+	new_element = EL_ACID_POOL_BOTTOMLEFT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMRIGHT)
+      {
+	new_element = EL_ACID_POOL_BOTTOMLEFT;
+      }
+    }
+    else if (last_x == x && last_y == y - 1 && IN_LEV_FIELD(last_x, last_y) &&
+	     IS_ACID_POOL(IntelliDrawBuffer[last_x][last_y]))
+    {
+      if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPLEFT)
+      {
+	new_element = EL_ACID_POOL_BOTTOMLEFT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPRIGHT)
+      {
+	new_element = EL_ACID_POOL_BOTTOMRIGHT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMLEFT)
+      {
+	last_element_new = EL_ACID_POOL_TOPLEFT;
+	new_element = EL_ACID_POOL_BOTTOMLEFT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMRIGHT)
+      {
+	last_element_new = EL_ACID_POOL_TOPRIGHT;
+	new_element = EL_ACID_POOL_BOTTOMRIGHT;
+      }
+      else
+      {
+	last_element_new = EL_ACID;
+	new_element = EL_ACID_POOL_BOTTOM;
+      }
+    }
+    else if (last_x == x && last_y == y + 1 && IN_LEV_FIELD(last_x, last_y) &&
+	     IS_ACID_POOL(IntelliDrawBuffer[last_x][last_y]))
+    {
+      if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPLEFT)
+      {
+	new_element = EL_ACID_POOL_TOPLEFT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_TOPRIGHT)
+      {
+	new_element = EL_ACID_POOL_TOPRIGHT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMLEFT)
+      {
+	new_element = EL_ACID_POOL_TOPLEFT;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == EL_ACID_POOL_BOTTOMRIGHT)
+      {
+	new_element = EL_ACID_POOL_TOPRIGHT;
+      }
+      else
+      {
+	last_element_new = EL_ACID;
+	new_element = EL_ACID;
+      }
+    }
+
+    if (last_element_new != EL_UNDEFINED)
+      SetElementSimple(last_x, last_y, last_element_new, change_level);
+  }
+  else if (IS_BELT(new_element))
+  {
+    int last_element_new = EL_UNDEFINED;
+    int belt_nr = getBeltNrFromBeltElement(new_element);
+    int belt_left  = getBeltElementFromBeltNrAndBeltDir(belt_nr, MV_LEFT);
+    int belt_none  = getBeltElementFromBeltNrAndBeltDir(belt_nr, MV_NONE);
+    int belt_right = getBeltElementFromBeltNrAndBeltDir(belt_nr, MV_RIGHT);
+    boolean last_element_is_neighbour = FALSE;
+
+    if (IS_BELT(old_element))
+    {
+      new_element = old_element;
+    }
+
+    if (last_x == x - 1 && last_y == y && IN_LEV_FIELD(last_x, last_y) &&
+	IS_BELT(IntelliDrawBuffer[last_x][last_y]))
+    {
+      last_element_new = IntelliDrawBuffer[last_x][last_y];
+
+      if (IntelliDrawBuffer[last_x][last_y] == belt_left)
+      {
+	new_element = belt_right;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == belt_right)
+      {
+	last_element_new = belt_none;
+	new_element = belt_right;
+      }
+
+      last_element_is_neighbour = TRUE;
+    }
+    else if (last_x == x + 1 && last_y == y && IN_LEV_FIELD(last_x, last_y) &&
+	     IS_BELT(IntelliDrawBuffer[last_x][last_y]))
+    {
+      last_element_new = IntelliDrawBuffer[last_x][last_y];
+
+      if (IntelliDrawBuffer[last_x][last_y] == belt_left)
+      {
+	last_element_new = belt_none;
+	new_element = belt_left;
+      }
+      else if (IntelliDrawBuffer[last_x][last_y] == belt_right)
+      {
+	new_element = belt_left;
+      }
+
+      last_element_is_neighbour = TRUE;
+    }
+
+    if (last_element_new != EL_UNDEFINED)
+      SetElementSimple(last_x, last_y, last_element_new, change_level);
+
+    /* reduce connections of neighbour belt elements to minimal connections */
+    if (last_element_is_neighbour)
+    {
+      /* set neighbour belt elements to newly determined belt connections */
+      SetElementSimple(x, y, new_element, change_level);
+      SetElementSimple(last_x, last_y, last_element_new, change_level);
+
+      /* remove all open belt connections of neighbour belt elements */
+      new_element = getClosedBelt(x, y);
+      last_element_new = getClosedBelt(last_x, last_y);
+
+      /* set neighbour belt elements to new, minimized belt connections */
+      SetElementSimple(x, y, new_element, change_level);
+      SetElementSimple(last_x, last_y, last_element_new, change_level);
+    }
+  }
+  else if (new_element == EL_EMC_WALL_1 ||
+	   new_element == EL_EMC_WALL_2 ||
+	   new_element == EL_EMC_WALL_3)
+  {
+    int last_element_new = EL_UNDEFINED;
+
+    if (last_x == x && last_y == y - 1 && IN_LEV_FIELD(last_x, last_y) &&
+	(IntelliDrawBuffer[last_x][last_y] == EL_EMC_WALL_1 ||
+	 IntelliDrawBuffer[last_x][last_y] == EL_EMC_WALL_2 ||
+	 IntelliDrawBuffer[last_x][last_y] == EL_EMC_WALL_3))
+    {
+      if (IN_LEV_FIELD(last_x, last_y - 1))
+      {
+	if (IntelliDrawBuffer[last_x][last_y - 1] != EL_EMC_WALL_1 &&
+	    IntelliDrawBuffer[last_x][last_y - 1] != EL_EMC_WALL_2)
+	  last_element_new = EL_EMC_WALL_1;
+	else if (IntelliDrawBuffer[last_x][last_y - 1] == EL_EMC_WALL_1 ||
+		 IntelliDrawBuffer[last_x][last_y - 1] == EL_EMC_WALL_2)
+	  last_element_new = EL_EMC_WALL_2;
+      }
+
+      new_element = EL_EMC_WALL_3;
+    }
+    else if (last_x == x && last_y == y + 1 && IN_LEV_FIELD(last_x, last_y) &&
+	     (IntelliDrawBuffer[last_x][last_y] == EL_EMC_WALL_1 ||
+	      IntelliDrawBuffer[last_x][last_y] == EL_EMC_WALL_2 ||
+	      IntelliDrawBuffer[last_x][last_y] == EL_EMC_WALL_3))
+    {
+      if (IN_LEV_FIELD(last_x, last_y + 1))
+      {
+	if (IntelliDrawBuffer[last_x][last_y + 1] != EL_EMC_WALL_2 &&
+	    IntelliDrawBuffer[last_x][last_y + 1] != EL_EMC_WALL_3)
+	  last_element_new = EL_EMC_WALL_3;
+	else if (IntelliDrawBuffer[last_x][last_y + 1] == EL_EMC_WALL_2 ||
+		 IntelliDrawBuffer[last_x][last_y + 1] == EL_EMC_WALL_3)
+	  last_element_new = EL_EMC_WALL_2;
+      }
+
+      new_element = EL_EMC_WALL_1;
+    }
+
+    if (last_element_new != EL_UNDEFINED)
+      SetElementSimple(last_x, last_y, last_element_new, change_level);
+  }
+
+  SetElementSimple(x, y, new_element, change_level);
+
+  last_x = x;
+  last_y = y;
+}
+
+static void ResetIntelliDraw()
+{
+  int x, y;
+
+  for (x = 0; x < lev_fieldx; x++)
+    for (y = 0; y < lev_fieldy; y++)
+      IntelliDrawBuffer[x][y] = Feld[x][y];
+
+  SetElementIntelliDraw(-1, -1, EL_UNDEFINED, FALSE);
+}
+
+static void SetElementExt(int x, int y, int element, boolean change_level)
+{
+  if (element < 0)
+    element = IntelliDrawBuffer[x][y] = Feld[x][y];
+
+  if (GetKeyModState() & KMOD_Shift)
+    SetElementIntelliDraw(x, y, element, change_level);
+  else
+    SetElementSimple(x, y, element, change_level);
+}
+
+static void SetElement(int x, int y, int element)
+{
+  SetElementExt(x, y, element, TRUE);
+}
+
 static void DrawLineElement(int sx, int sy, int element, boolean change_level)
 {
+#if 1
+  int lx = sx + level_xpos;
+  int ly = sy + level_ypos;
+
+  SetElementExt(lx, ly, element, change_level);
+
+#else
+
   int lx = sx + level_xpos;
   int ly = sy + level_ypos;
+  int element_new = (element < 0 ? Feld[lx][ly] : element);
 
-  DrawMiniElement(sx, sy, (element < 0 ? Feld[lx][ly] : element));
+  DrawMiniElement(sx, sy, element_new);
 
   if (change_level)
     Feld[lx][ly] = element;
+#endif
 }
 
 static void DrawLine(int from_x, int from_y, int to_x, int to_y,
@@ -8617,7 +9100,7 @@ static void CopyBrushExt(int from_x, int from_y, int to_x, int to_y,
 
     for (y = 0; y < brush_height; y++)
     {
-      for (x=0; x < brush_width; x++)
+      for (x = 0; x < brush_width; x++)
       {
 	brush_buffer[x][y] = Feld[from_lx + x][from_ly + y];
 
@@ -9047,6 +9530,12 @@ static void HandleDrawingAreas(struct GadgetInfo *gi)
     actual_drawing_function = GADGET_ID_PICK_ELEMENT;
   }
 
+  if (GetKeyModState() & KMOD_Shift)
+  {
+    if (button_press_event || button_release_event)
+      ResetIntelliDraw();
+  }
+
   switch (actual_drawing_function)
   {
     case GADGET_ID_SINGLE_ITEMS:
@@ -9059,17 +9548,27 @@ static void HandleDrawingAreas(struct GadgetInfo *gi)
 	  if (edit_mode == ED_MODE_DRAWING && draw_with_brush &&
 	      !inside_drawing_area)
 	    DeleteBrushFromCursor();
+
+#if 0
+	  ResetIntelliDraw();
+#endif
 	}
 
-	if (!button)
+	if (!button || button_release_event)
 	  break;
 
 	if (draw_with_brush)
 	{
+#if 0
 	  if (!button_release_event)
+#endif
 	    CopyBrushToLevel(sx, sy, button);
 	}
+#if 1
+	else
+#else
 	else if (new_element != Feld[lx][ly])
+#endif
 	{
 	  if (new_element == EL_PLAYER_1)
 	  {
@@ -9080,18 +9579,30 @@ static void HandleDrawingAreas(struct GadgetInfo *gi)
 	      {
 		if (Feld[x][y] == EL_PLAYER_1)
 		{
+#if 1
+		  SetElement(x, y, EL_EMPTY);
+#else
 		  Feld[x][y] = EL_EMPTY;
+#if 1
+		  if (IN_ED_FIELD(x - level_xpos, y - level_ypos))
+		    DrawMiniElement(x - level_xpos, y - level_ypos, EL_EMPTY);
+#else
 		  if (x - level_xpos >= 0 && x - level_xpos < ed_fieldx &&
 		      y - level_ypos >= 0 && y - level_ypos < ed_fieldy)
-		    DrawMiniElement(x - level_xpos, y - level_ypos,
-				    EL_EMPTY);
+		    DrawMiniElement(x - level_xpos, y - level_ypos, EL_EMPTY);
+#endif
+#endif
 		}
 	      }
 	    }
 	  }
 
+#if 1
+	  SetElement(lx, ly, new_element);
+#else
 	  Feld[lx][ly] = new_element;
 	  DrawMiniElement(sx, sy, new_element);
+#endif
 	}
       }
       else