X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=eba90f7076c043aca03039fa62c779e27f932728;hb=88a46f726da49d5ae03e736b1388a4b854221685;hp=8946e84b61b483d3d28b6578d487db5e6c6ceae9;hpb=e0e2697df0d0da483a91b1248c120aef6b3caf9b;p=rocksndiamonds.git

diff --git a/src/tools.c b/src/tools.c
index 8946e84b..eba90f70 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -1,7 +1,7 @@
 /***********************************************************
 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
 *----------------------------------------------------------*
-* (c) 1995-2001 Artsoft Entertainment                      *
+* (c) 1995-2002 Artsoft Entertainment                      *
 *               Holger Schemel                             *
 *               Detmolder Strasse 189                      *
 *               33604 Bielefeld                            *
@@ -20,10 +20,6 @@
 #include "network.h"
 #include "tape.h"
 
-#if defined(PLATFORM_MSDOS)
-extern boolean wait_for_vsync;
-#endif
-
 /* tool button identifiers */
 #define TOOL_CTRL_ID_YES	0
 #define TOOL_CTRL_ID_NO		1
@@ -75,6 +71,51 @@ void SetDrawtoField(int mode)
   }
 }
 
+void RedrawPlayfield(boolean force_redraw, int x, int y, int width, int height)
+{
+  if (game_status == PLAYING)
+  {
+    if (force_redraw)
+    {
+      x = gfx.sx - TILEX;
+      y = gfx.sy - TILEY;
+      width = gfx.sxsize + 2 * TILEX;
+      height = gfx.sysize + 2 * TILEY;
+    }
+
+    if (force_redraw || setup.direct_draw)
+    {
+      int xx, yy;
+      int x1 = (x - SX) / TILEX, y1 = (y - SY) / TILEY;
+      int x2 = (x - SX + width) / TILEX, y2 = (y - SY + height) / TILEY;
+
+      if (setup.direct_draw)
+	SetDrawtoField(DRAW_BACKBUFFER);
+
+      for(xx=BX1; xx<=BX2; xx++)
+	for(yy=BY1; yy<=BY2; yy++)
+	  if (xx >= x1 && xx <= x2 && yy >= y1 && yy <= y2)
+	    DrawScreenField(xx, yy);
+      DrawAllPlayers();
+
+      if (setup.direct_draw)
+	SetDrawtoField(DRAW_DIRECT);
+    }
+
+    if (setup.soft_scrolling)
+    {
+      int fx = FX, fy = FY;
+
+      fx += (ScreenMovDir & (MV_LEFT|MV_RIGHT) ? ScreenGfxPos : 0);
+      fy += (ScreenMovDir & (MV_UP|MV_DOWN)    ? ScreenGfxPos : 0);
+
+      BlitBitmap(fieldbuffer, backbuffer, fx,fy, SXSIZE,SYSIZE, SX,SY);
+    }
+  }
+
+  BlitBitmap(drawto, window, x, y, width, height, x, y);
+}
+
 void BackToFront()
 {
   int x,y;
@@ -89,7 +130,7 @@ void BackToFront()
   if (redraw_mask & REDRAW_FIELD)
     redraw_mask &= ~REDRAW_TILES;
 
-  if (!redraw_mask)
+  if (redraw_mask == REDRAW_NONE)
     return;
 
   if (global.fps_slowdown && game_status == PLAYING)
@@ -250,7 +291,7 @@ void BackToFront()
     for(y=0; y<MAX_BUF_YSIZE; y++)
       redraw[x][y] = 0;
   redraw_tiles = 0;
-  redraw_mask = 0;
+  redraw_mask = REDRAW_NONE;
 }
 
 void FadeToFront()
@@ -361,14 +402,14 @@ void SetBorderElement()
 {
   int x, y;
 
-  BorderElement = EL_LEERRAUM;
+  BorderElement = EL_EMPTY;
 
-  for(y=0; y<lev_fieldy && BorderElement == EL_LEERRAUM; y++)
+  for(y=0; y<lev_fieldy && BorderElement == EL_EMPTY; y++)
   {
     for(x=0; x<lev_fieldx; x++)
     {
       if (!IS_MASSIVE(Feld[x][y]))
-	BorderElement = EL_BETON;
+	BorderElement = EL_STEELWALL;
 
       if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
 	x = lev_fieldx - 2;
@@ -417,7 +458,7 @@ void DrawPlayer(struct PlayerInfo *player)
   }
 #endif
 
-  if (element == EL_EXPLODING)
+  if (element == EL_EXPLOSION)
     return;
 
   /* draw things in the field the player is leaving, if needed */
@@ -441,10 +482,10 @@ void DrawPlayer(struct PlayerInfo *player)
     {
       if (player->GfxPos)
       {
-  	if (Feld[next_jx][next_jy] == EL_SOKOBAN_FELD_VOLL)
-  	  DrawLevelElement(next_jx, next_jy, EL_SOKOBAN_FELD_LEER);
+  	if (Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL)
+  	  DrawLevelElement(next_jx, next_jy, EL_SOKOBAN_FIELD_EMPTY);
   	else
-  	  DrawLevelElement(next_jx, next_jy, EL_LEERRAUM);
+  	  DrawLevelElement(next_jx, next_jy, EL_EMPTY);
       }
       else
   	DrawLevelField(next_jx, next_jy);
@@ -464,7 +505,7 @@ void DrawPlayer(struct PlayerInfo *player)
   else if (!IS_ACTIVE_BOMB(element))
     DrawLevelField(jx, jy);
   else
-    DrawLevelElement(jx, jy, EL_LEERRAUM);
+    DrawLevelElement(jx, jy, EL_EMPTY);
 
   /* draw player himself */
 
@@ -515,7 +556,7 @@ void DrawPlayer(struct PlayerInfo *player)
       else
 	graphic = GFX_MURPHY_GO_LEFT;
 
-      graphic += getGraphicAnimationPhase(3, 2, ANIM_OSCILLATE);
+      graphic += getGraphicAnimationPhase(3, 2, ANIM_PINGPONG);
     }
 
     if (player->MovDir == MV_LEFT || player->MovDir == MV_RIGHT)
@@ -557,15 +598,15 @@ void DrawPlayer(struct PlayerInfo *player)
 		   GFX2_SHIELD_PASSIVE);
 
     DrawGraphicAnimationShiftedThruMask(sx, sy, sxx, syy, graphic,
-					3, 8, ANIM_OSCILLATE);
+					3, 8, ANIM_PINGPONG);
   }
 
   if (player->Pushing && player->GfxPos)
   {
     int px = SCREENX(next_jx), py = SCREENY(next_jy);
 
-    if (element == EL_SOKOBAN_FELD_LEER ||
-	Feld[next_jx][next_jy] == EL_SOKOBAN_FELD_VOLL)
+    if (element == EL_SOKOBAN_FIELD_EMPTY ||
+	Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL)
       DrawGraphicShiftedThruMask(px, py, sxx, syy, GFX_SOKOBAN_OBJEKT,
 				 NO_CUTTING);
     else
@@ -573,7 +614,7 @@ void DrawPlayer(struct PlayerInfo *player)
       int element = Feld[next_jx][next_jy];
       int graphic = el2gfx(element);
 
-      if ((element == EL_FELSBROCKEN ||
+      if ((element == EL_ROCK ||
 	   element == EL_SP_ZONK ||
 	   element == EL_BD_ROCK) && sxx)
       {
@@ -612,7 +653,7 @@ void DrawPlayer(struct PlayerInfo *player)
       DrawGraphicThruMask(sx, sy, graphic + phase);
   }
 
-  if (player_is_moving && last_element == EL_EXPLODING)
+  if (player_is_moving && last_element == EL_EXPLOSION)
   {
     int phase = Frame[last_jx][last_jy];
     int delay = 2;
@@ -649,19 +690,63 @@ static int getGraphicAnimationPhase(int frames, int delay, int mode)
 {
   int phase;
 
-  if (mode == ANIM_OSCILLATE)
+  if (mode & ANIM_PINGPONG)
   {
     int max_anim_frames = 2 * frames - 2;
+
     phase = (FrameCounter % (delay * max_anim_frames)) / delay;
     phase = (phase < frames ? phase : max_anim_frames - phase);
   }
   else
     phase = (FrameCounter % (delay * frames)) / delay;
 
-  if (mode == ANIM_REVERSE)
+  if (mode & ANIM_REVERSE)
     phase = -phase;
 
-  return(phase);
+  return phase;
+}
+
+int getNewGraphicAnimationFrame(int graphic, int sync_frame)
+{
+  int num_frames = new_graphic_info[graphic].anim_frames;
+  int delay = new_graphic_info[graphic].anim_delay;
+  int mode = new_graphic_info[graphic].anim_mode;
+  int frame = 0;
+
+  /* animation synchronized with global frame counter, not move position */
+  if (new_graphic_info[graphic].anim_global_sync || sync_frame < 0)
+    sync_frame = FrameCounter;
+
+  if (mode & ANIM_LOOP)			/* normal, looping animation */
+  {
+    frame = (sync_frame % (delay * num_frames)) / delay;
+  }
+  else if (mode & ANIM_LINEAR)		/* normal, non-looping animation */
+  {
+    frame = sync_frame / delay;
+
+    if (frame > num_frames - 1)
+      frame = num_frames - 1;
+  }
+  else if (mode & ANIM_PINGPONG)	/* use border frames once */
+  {
+    int max_anim_frames = 2 * num_frames - 2;
+
+    frame = (sync_frame % (delay * max_anim_frames)) / delay;
+    frame = (frame < num_frames ? frame : max_anim_frames - frame);
+  }
+  else if (mode & ANIM_PINGPONG2)	/* use border frames twice */
+  {
+    int max_anim_frames = 2 * num_frames;
+
+    frame = (sync_frame % (delay * max_anim_frames)) / delay;
+    frame = (frame < num_frames ? frame : max_anim_frames - frame - 1);
+  }
+
+  if (mode & ANIM_REVERSE)		/* use reverse animation direction */
+    frame = num_frames - frame - 1;
+
+  return frame;
 }
 
 void DrawGraphicAnimationExt(int x, int y, int graphic,
@@ -678,12 +763,36 @@ void DrawGraphicAnimationExt(int x, int y, int graphic,
   }
 }
 
+void DrawNewGraphicAnimationExt(int x, int y, int graphic, int mask_mode)
+{
+#if 0
+  int delay = new_graphic_info[graphic].anim_delay;
+
+  if (!(FrameCounter % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+#else
+  if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+#endif
+  {
+    int frame = getNewGraphicAnimationFrame(graphic, -1);
+
+    if (mask_mode == USE_MASKING)
+      DrawNewGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
+    else
+      DrawNewGraphic(SCREENX(x), SCREENY(y), graphic, frame);
+  }
+}
+
 void DrawGraphicAnimation(int x, int y, int graphic,
 			  int frames, int delay, int mode)
 {
   DrawGraphicAnimationExt(x, y, graphic, frames, delay, mode, NO_MASKING);
 }
 
+void DrawNewGraphicAnimation(int x, int y, int graphic)
+{
+  DrawNewGraphicAnimationExt(x, y, graphic, NO_MASKING);
+}
+
 void DrawGraphicAnimationThruMask(int x, int y, int graphic,
 				  int frames, int delay, int mode)
 {
@@ -701,54 +810,60 @@ static void DrawGraphicAnimationShiftedThruMask(int sx, int sy,
   DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic + phase, NO_CUTTING);
 }
 
-void getGraphicSource(int graphic, int *bitmap_nr, int *x, int *y)
+void getGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
 {
-  if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN)
+  if (graphic >= 0 && graphic_info[graphic].bitmap != NULL)
+  {
+    *bitmap = graphic_info[graphic].bitmap;
+    *x = graphic_info[graphic].src_x;
+    *y = graphic_info[graphic].src_y;
+  }
+  else if (graphic >= GFX_START_ROCKSELEMENTS &&
+	   graphic <= GFX_END_ROCKSELEMENTS)
   {
-    graphic -= GFX_START_ROCKSSCREEN;
-    *bitmap_nr = PIX_BACK;
-    *x = SX + (graphic % GFX_PER_LINE) * TILEX;
-    *y = SY + (graphic / GFX_PER_LINE) * TILEY;
+    graphic -= GFX_START_ROCKSELEMENTS;
+    *bitmap = pix[PIX_ELEMENTS];
+    *x = (graphic % GFX_PER_LINE) * TILEX;
+    *y = (graphic / GFX_PER_LINE) * TILEY;
   }
   else if (graphic >= GFX_START_ROCKSHEROES && graphic <= GFX_END_ROCKSHEROES)
   {
     graphic -= GFX_START_ROCKSHEROES;
-    *bitmap_nr = PIX_HEROES;
+    *bitmap = pix[PIX_HEROES];
     *x = (graphic % HEROES_PER_LINE) * TILEX;
     *y = (graphic / HEROES_PER_LINE) * TILEY;
   }
   else if (graphic >= GFX_START_ROCKSSP && graphic <= GFX_END_ROCKSSP)
   {
     graphic -= GFX_START_ROCKSSP;
-    *bitmap_nr = PIX_SP;
+    *bitmap = pix[PIX_SP];
     *x = (graphic % SP_PER_LINE) * TILEX;
     *y = (graphic / SP_PER_LINE) * TILEY;
   }
   else if (graphic >= GFX_START_ROCKSDC && graphic <= GFX_END_ROCKSDC)
   {
     graphic -= GFX_START_ROCKSDC;
-    *bitmap_nr = PIX_DC;
+    *bitmap = pix[PIX_DC];
     *x = (graphic % DC_PER_LINE) * TILEX;
     *y = (graphic / DC_PER_LINE) * TILEY;
   }
   else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE)
   {
     graphic -= GFX_START_ROCKSMORE;
-    *bitmap_nr = PIX_MORE;
+    *bitmap = pix[PIX_MORE];
     *x = (graphic % MORE_PER_LINE) * TILEX;
     *y = (graphic / MORE_PER_LINE) * TILEY;
   }
   else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT)
   {
     graphic -= GFX_START_ROCKSFONT;
-    *bitmap_nr = PIX_BIGFONT;
+    *bitmap = pix[PIX_FONT_EM];
     *x = (graphic % FONT_CHARS_PER_LINE) * TILEX;
-    *y = ((graphic / FONT_CHARS_PER_LINE) * TILEY +
-	  FC_SPECIAL1 * FONT_LINES_PER_FONT * TILEY);
+    *y = (graphic / FONT_CHARS_PER_LINE) * TILEY;
   }
   else
   {
-    *bitmap_nr = PIX_SP;
+    *bitmap = pix[PIX_SP];
     *x = 0;
     *y = 0;
   }
@@ -757,31 +872,62 @@ void getGraphicSource(int graphic, int *bitmap_nr, int *x, int *y)
 void DrawGraphic(int x, int y, int graphic)
 {
 #if DEBUG
-  if (!IN_SCR_FIELD(x,y))
+  if (!IN_SCR_FIELD(x, y))
   {
-    printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
+    printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n", x, y, graphic);
     printf("DrawGraphic(): This should never happen!\n");
     return;
   }
 #endif
 
-  DrawGraphicExt(drawto_field, FX + x*TILEX, FY + y*TILEY, graphic);
-  MarkTileDirty(x,y);
+  DrawGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic);
+  MarkTileDirty(x, y);
+}
+
+void DrawNewGraphic(int x, int y, int graphic, int frame)
+{
+#if DEBUG
+  if (!IN_SCR_FIELD(x, y))
+  {
+    printf("DrawNewGraphic(): x = %d, y = %d, graphic = %d\n", x, y, graphic);
+    printf("DrawNewGraphic(): This should never happen!\n");
+    return;
+  }
+#endif
+
+  DrawNewGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
+		    graphic, frame);
+  MarkTileDirty(x, y);
 }
 
-void DrawGraphicExt(DrawBuffer *bitmap, int x, int y, int graphic)
+void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic)
 {
-  int bitmap_nr;
+  Bitmap *src_bitmap;
   int src_x, src_y;
 
-  getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y);
-  BlitBitmap(pix[bitmap_nr], bitmap, src_x, src_y, TILEX, TILEY, x, y);
+  getGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+  BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
+}
+
+void DrawNewGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
+		       int frame)
+{
+  Bitmap *src_bitmap = new_graphic_info[graphic].bitmap;
+  int src_x = new_graphic_info[graphic].src_x;
+  int src_y = new_graphic_info[graphic].src_y;
+  int offset_x = new_graphic_info[graphic].offset_x;
+  int offset_y = new_graphic_info[graphic].offset_y;
+
+  src_x += frame * offset_x;
+  src_y += frame * offset_y;
+
+  BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
 }
 
 void DrawGraphicThruMask(int x, int y, int graphic)
 {
 #if DEBUG
-  if (!IN_SCR_FIELD(x,y))
+  if (!IN_SCR_FIELD(x, y))
   {
     printf("DrawGraphicThruMask(): x = %d,y = %d, graphic = %d\n",x,y,graphic);
     printf("DrawGraphicThruMask(): This should never happen!\n");
@@ -789,14 +935,29 @@ void DrawGraphicThruMask(int x, int y, int graphic)
   }
 #endif
 
-  DrawGraphicThruMaskExt(drawto_field, FX + x*TILEX, FY + y*TILEY, graphic);
-  MarkTileDirty(x,y);
+  DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y *TILEY, graphic);
+  MarkTileDirty(x, y);
+}
+
+void DrawNewGraphicThruMask(int x, int y, int graphic, int frame)
+{
+#if DEBUG
+  if (!IN_SCR_FIELD(x, y))
+  {
+    printf("DrawGraphicThruMask(): x = %d,y = %d, graphic = %d\n",x,y,graphic);
+    printf("DrawGraphicThruMask(): This should never happen!\n");
+    return;
+  }
+#endif
+
+  DrawNewGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y *TILEY,
+			    graphic, frame);
+  MarkTileDirty(x, y);
 }
 
 void DrawGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y, int graphic)
 {
   int tile = graphic;
-  int bitmap_nr;
   int src_x, src_y;
   Bitmap *src_bitmap;
   GC drawing_gc;
@@ -804,9 +965,8 @@ void DrawGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y, int graphic)
   if (graphic == GFX_LEERRAUM)
     return;
 
-  getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y);
-  src_bitmap = pix[bitmap_nr];
-  drawing_gc = pix[bitmap_nr]->stored_clip_gc;
+  getGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+  drawing_gc = src_bitmap->stored_clip_gc;
 
   if (tile_clipmask[tile] != None)
   {
@@ -823,31 +983,55 @@ void DrawGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y, int graphic)
 #endif
 #endif
 
-    SetClipOrigin(src_bitmap, drawing_gc, dest_x-src_x, dest_y-src_y);
+    SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
     BlitBitmapMasked(src_bitmap, d,
 		     src_x, src_y, TILEX, TILEY, dest_x, dest_y);
   }
 }
 
+void DrawNewGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y,
+			       int graphic, int frame)
+{
+  Bitmap *src_bitmap = new_graphic_info[graphic].bitmap;
+  GC drawing_gc = src_bitmap->stored_clip_gc;
+  int src_x = new_graphic_info[graphic].src_x;
+  int src_y = new_graphic_info[graphic].src_y;
+  int offset_x = new_graphic_info[graphic].offset_x;
+  int offset_y = new_graphic_info[graphic].offset_y;
+
+  src_x += frame * offset_x;
+  src_y += frame * offset_y;
+
+  SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
+  BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dest_x, dest_y);
+}
+
 void DrawMiniGraphic(int x, int y, int graphic)
 {
-  DrawMiniGraphicExt(drawto, SX + x*MINI_TILEX, SY + y*MINI_TILEY, graphic);
-  MarkTileDirty(x/2, y/2);
+  DrawMiniGraphicExt(drawto,
+		     SX + x * MINI_TILEX, SY + y * MINI_TILEY, graphic);
+  MarkTileDirty(x / 2, y / 2);
+}
+
+void DrawNewMiniGraphic(int x, int y, int graphic)
+{
+  DrawNewMiniGraphicExt(drawto,
+			SX + x * MINI_TILEX, SY + y * MINI_TILEY, graphic);
+  MarkTileDirty(x / 2, y / 2);
 }
 
 void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
 {
-  if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN)
+  if (graphic >= GFX_START_ROCKSELEMENTS && graphic <= GFX_END_ROCKSELEMENTS)
   {
-    graphic -= GFX_START_ROCKSSCREEN;
-    *bitmap = pix[PIX_BACK];
+    graphic -= GFX_START_ROCKSELEMENTS;
+    *bitmap = pix[PIX_ELEMENTS];
     *x = MINI_GFX_STARTX + (graphic % MINI_GFX_PER_LINE) * MINI_TILEX;
     *y = MINI_GFX_STARTY + (graphic / MINI_GFX_PER_LINE) * MINI_TILEY;
   }
   else if (graphic >= GFX_START_ROCKSSP && graphic <= GFX_END_ROCKSSP)
   {
     graphic -= GFX_START_ROCKSSP;
-    graphic -= ((graphic / SP_PER_LINE) * SP_PER_LINE) / 2;
     *bitmap = pix[PIX_SP];
     *x = MINI_SP_STARTX + (graphic % MINI_SP_PER_LINE) * MINI_TILEX;
     *y = MINI_SP_STARTY + (graphic / MINI_SP_PER_LINE) * MINI_TILEY;
@@ -869,10 +1053,9 @@ void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
   else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT)
   {
     graphic -= GFX_START_ROCKSFONT;
-    *bitmap = pix[PIX_SMALLFONT];
-    *x = (graphic % FONT_CHARS_PER_LINE) * FONT4_XSIZE;
-    *y = ((graphic / FONT_CHARS_PER_LINE) * FONT4_YSIZE +
-	      FC_SPECIAL2 * FONT2_YSIZE * FONT_LINES_PER_FONT);
+    *bitmap = pix[PIX_FONT_EM];
+    *x = MINI_FONT_STARTX + (graphic % FONT_CHARS_PER_LINE) * FONT4_XSIZE;
+    *y = MINI_FONT_STARTY + (graphic / FONT_CHARS_PER_LINE) * FONT4_YSIZE;
   }
   else
   {
@@ -882,6 +1065,19 @@ void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
   }
 }
 
+void getNewMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
+{
+  Bitmap *src_bitmap = new_graphic_info[graphic].bitmap;
+  int mini_startx = 0;
+  int mini_starty = src_bitmap->height * 2 / 3;
+  int src_x = mini_startx + new_graphic_info[graphic].src_x / 2;
+  int src_y = mini_starty + new_graphic_info[graphic].src_y / 2;
+
+  *bitmap = src_bitmap;
+  *x = src_x;
+  *y = src_y;
+}
+
 void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
 {
   Bitmap *bitmap;
@@ -891,6 +1087,24 @@ void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
   BlitBitmap(bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
 }
 
+void DrawNewMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
+{
+#if 1
+  Bitmap *src_bitmap;
+  int src_x, src_y;
+
+  getNewMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+#else
+  Bitmap *src_bitmap = new_graphic_info[graphic].bitmap;
+  int mini_startx = src_bitmap->width  * 2 / 3;
+  int mini_starty = src_bitmap->height * 2 / 3;
+  int src_x = mini_startx + new_graphic_info[graphic].src_x / 2;
+  int src_y = mini_starty + new_graphic_info[graphic].src_y / 2;
+#endif
+
+  BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
+}
+
 void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic,
 			int cut_mode, int mask_mode)
 {
@@ -898,7 +1112,6 @@ void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic,
   int cx = 0, cy = 0;
   int src_x, src_y, dest_x, dest_y;
   int tile = graphic;
-  int bitmap_nr;
   Bitmap *src_bitmap;
   GC drawing_gc;
 
@@ -972,9 +1185,8 @@ void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic,
       MarkTileDirty(x, y + SIGN(dy));
   }
 
-  getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y);
-  src_bitmap = pix[bitmap_nr];
-  drawing_gc = pix[bitmap_nr]->stored_clip_gc;
+  getGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+  drawing_gc = src_bitmap->stored_clip_gc;
 
   src_x += cx;
   src_y += cy;
@@ -1014,18 +1226,142 @@ void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic,
     }
   }
   else
-    BlitBitmap(pix[bitmap_nr], drawto_field,
+    BlitBitmap(src_bitmap, drawto_field,
 	       src_x, src_y, width, height, dest_x, dest_y);
 
   MarkTileDirty(x,y);
 }
 
+void DrawNewGraphicShifted(int x,int y, int dx,int dy, int graphic, int frame,
+			int cut_mode, int mask_mode)
+{
+  Bitmap *src_bitmap;
+  GC drawing_gc;
+  int src_x;
+  int src_y;
+  int offset_x;
+  int offset_y;
+
+  int width = TILEX, height = TILEY;
+  int cx = 0, cy = 0;
+  int dest_x, dest_y;
+
+  if (graphic < 0)
+  {
+    DrawNewGraphic(x, y, graphic, frame);
+    return;
+  }
+
+  if (dx || dy)			/* Verschiebung der Grafik? */
+  {
+    if (x < BX1)		/* Element kommt von links ins Bild */
+    {
+      x = BX1;
+      width = dx;
+      cx = TILEX - dx;
+      dx = 0;
+    }
+    else if (x > BX2)		/* Element kommt von rechts ins Bild */
+    {
+      x = BX2;
+      width = -dx;
+      dx = TILEX + dx;
+    }
+    else if (x==BX1 && dx < 0)	/* Element verläßt links das Bild */
+    {
+      width += dx;
+      cx = -dx;
+      dx = 0;
+    }
+    else if (x==BX2 && dx > 0)	/* Element verläßt rechts das Bild */
+      width -= dx;
+    else if (dx)		/* allg. Bewegung in x-Richtung */
+      MarkTileDirty(x + SIGN(dx), y);
+
+    if (y < BY1)		/* Element kommt von oben ins Bild */
+    {
+      if (cut_mode==CUT_BELOW)	/* Element oberhalb des Bildes */
+	return;
+
+      y = BY1;
+      height = dy;
+      cy = TILEY - dy;
+      dy = 0;
+    }
+    else if (y > BY2)		/* Element kommt von unten ins Bild */
+    {
+      y = BY2;
+      height = -dy;
+      dy = TILEY + dy;
+    }
+    else if (y==BY1 && dy < 0)	/* Element verläßt oben das Bild */
+    {
+      height += dy;
+      cy = -dy;
+      dy = 0;
+    }
+    else if (dy > 0 && cut_mode == CUT_ABOVE)
+    {
+      if (y == BY2)		/* Element unterhalb des Bildes */
+	return;
+
+      height = dy;
+      cy = TILEY - dy;
+      dy = TILEY;
+      MarkTileDirty(x, y + 1);
+    }				/* Element verläßt unten das Bild */
+    else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
+      height -= dy;
+    else if (dy)		/* allg. Bewegung in y-Richtung */
+      MarkTileDirty(x, y + SIGN(dy));
+  }
+
+  src_bitmap = new_graphic_info[graphic].bitmap;
+  drawing_gc = src_bitmap->stored_clip_gc;
+  src_x = new_graphic_info[graphic].src_x;
+  src_y = new_graphic_info[graphic].src_y;
+  offset_x = new_graphic_info[graphic].offset_x;
+  offset_y = new_graphic_info[graphic].offset_y;
+
+  src_x += frame * offset_x;
+  src_y += frame * offset_y;
+
+  src_x += cx;
+  src_y += cy;
+
+  dest_x = FX + x * TILEX + dx;
+  dest_y = FY + y * TILEY + dy;
+
+#if DEBUG
+  if (!IN_SCR_FIELD(x,y))
+  {
+    printf("DrawGraphicShifted(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
+    printf("DrawGraphicShifted(): This should never happen!\n");
+    return;
+  }
+#endif
+
+  if (mask_mode == USE_MASKING)
+    SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
+
+  BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
+	     dest_x, dest_y);
+
+  MarkTileDirty(x,y);
+}
+
 void DrawGraphicShiftedThruMask(int x,int y, int dx,int dy, int graphic,
 				int cut_mode)
 {
   DrawGraphicShifted(x,y, dx,dy, graphic, cut_mode, USE_MASKING);
 }
 
+void DrawNewGraphicShiftedThruMask(int x,int y, int dx,int dy, int graphic,
+				   int frame, int cut_mode)
+{
+  DrawNewGraphicShifted(x,y, dx,dy, graphic, frame, cut_mode, USE_MASKING);
+}
+
 void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
 			  int cut_mode, int mask_mode)
 {
@@ -1036,16 +1372,16 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
   int phase2  = phase8 / 4;
   int dir = MovDir[ux][uy];
 
-  if (element == EL_PACMAN || element == EL_KAEFER || element == EL_FLIEGER)
+  if (element == EL_PACMAN || element == EL_BUG || element == EL_SPACESHIP)
   {
-    graphic += 4 * !phase2;
+    graphic += 1 * !phase2;
 
     if (dir == MV_UP)
-      graphic += 1;
+      graphic += 1 * 2;
     else if (dir == MV_LEFT)
-      graphic += 2;
+      graphic += 2 * 2;
     else if (dir == MV_DOWN)
-      graphic += 3;
+      graphic += 3 * 2;
   }
   else if (element == EL_SP_SNIKSNAK)
   {
@@ -1062,39 +1398,39 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
   }
   else if (element == EL_SP_ELECTRON)
   {
-    graphic = GFX2_SP_ELECTRON + getGraphicAnimationPhase(8, 2, ANIM_NORMAL);
+    graphic = GFX2_SP_ELECTRON + getGraphicAnimationPhase(8, 2, ANIM_LOOP);
   }
-  else if (element == EL_MOLE || element == EL_PINGUIN ||
-	   element == EL_SCHWEIN || element == EL_DRACHE)
+  else if (element == EL_MOLE || element == EL_PENGUIN ||
+	   element == EL_PIG || element == EL_DRAGON)
   {
     if (dir == MV_LEFT)
       graphic = (element == EL_MOLE ? GFX_MOLE_LEFT :
-		 element == EL_PINGUIN ? GFX_PINGUIN_LEFT :
-		 element == EL_SCHWEIN ? GFX_SCHWEIN_LEFT : GFX_DRACHE_LEFT);
+		 element == EL_PENGUIN ? GFX_PINGUIN_LEFT :
+		 element == EL_PIG ? GFX_SCHWEIN_LEFT : GFX_DRACHE_LEFT);
     else if (dir == MV_RIGHT)
       graphic = (element == EL_MOLE ? GFX_MOLE_RIGHT :
-		 element == EL_PINGUIN ? GFX_PINGUIN_RIGHT :
-		 element == EL_SCHWEIN ? GFX_SCHWEIN_RIGHT : GFX_DRACHE_RIGHT);
+		 element == EL_PENGUIN ? GFX_PINGUIN_RIGHT :
+		 element == EL_PIG ? GFX_SCHWEIN_RIGHT : GFX_DRACHE_RIGHT);
     else if (dir == MV_UP)
       graphic = (element == EL_MOLE ? GFX_MOLE_UP :
-		 element == EL_PINGUIN ? GFX_PINGUIN_UP :
-		 element == EL_SCHWEIN ? GFX_SCHWEIN_UP : GFX_DRACHE_UP);
+		 element == EL_PENGUIN ? GFX_PINGUIN_UP :
+		 element == EL_PIG ? GFX_SCHWEIN_UP : GFX_DRACHE_UP);
     else
       graphic = (element == EL_MOLE ? GFX_MOLE_DOWN :
-		 element == EL_PINGUIN ? GFX_PINGUIN_DOWN :
-		 element == EL_SCHWEIN ? GFX_SCHWEIN_DOWN : GFX_DRACHE_DOWN);
+		 element == EL_PENGUIN ? GFX_PINGUIN_DOWN :
+		 element == EL_PIG ? GFX_SCHWEIN_DOWN : GFX_DRACHE_DOWN);
 
     graphic += phase4;
   }
-  else if (element == EL_SONDE)
+  else if (element == EL_SATELLITE)
   {
-    graphic = GFX_SONDE_START + getGraphicAnimationPhase(8, 2, ANIM_NORMAL);
+    graphic = GFX_SONDE_START + getGraphicAnimationPhase(8, 2, ANIM_LOOP);
   }
-  else if (element == EL_SALZSAEURE)
+  else if (element == EL_ACID)
   {
-    graphic = GFX_GEBLUBBER + getGraphicAnimationPhase(4, 10, ANIM_NORMAL);
+    graphic = GFX_GEBLUBBER + getGraphicAnimationPhase(4, 10, ANIM_LOOP);
   }
-  else if (element == EL_BUTTERFLY || element == EL_FIREFLY)
+  else if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY)
   {
     graphic += !phase2;
   }
@@ -1102,7 +1438,7 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
   {
     graphic += phase4;
   }
-  else if ((element == EL_FELSBROCKEN ||
+  else if ((element == EL_ROCK ||
 	    element == EL_SP_ZONK ||
 	    element == EL_BD_ROCK ||
 	    element == EL_SP_INFOTRON ||
@@ -1111,7 +1447,7 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
   {
     if (uy >= lev_fieldy-1 || !IS_BELT(Feld[ux][uy+1]))
     {
-      if (element == EL_FELSBROCKEN ||
+      if (element == EL_ROCK ||
 	  element == EL_SP_ZONK ||
 	  element == EL_BD_ROCK)
       {
@@ -1126,21 +1462,21 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
 	graphic += phase2;
     }
   }
-  else if (element == EL_MAGIC_WALL_EMPTY ||
+  else if (element == EL_MAGIC_WALL_ACTIVE ||
 	   element == EL_MAGIC_WALL_EMPTYING ||
-	   element == EL_MAGIC_WALL_BD_EMPTY ||
-	   element == EL_MAGIC_WALL_BD_EMPTYING ||
+	   element == EL_BD_MAGIC_WALL_ACTIVE ||
+	   element == EL_BD_MAGIC_WALL_EMPTYING ||
 	   element == EL_MAGIC_WALL_FULL ||
-	   element == EL_MAGIC_WALL_BD_FULL)
+	   element == EL_BD_MAGIC_WALL_FULL)
   {
     graphic += 3 + getGraphicAnimationPhase(4, 4, ANIM_REVERSE);
   }
   else if (IS_AMOEBOID(element) || element == EL_AMOEBA_DRIPPING)
   {
-    graphic = (element == EL_AMOEBE_TOT ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT);
+    graphic = (element == EL_AMOEBA_DEAD ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT);
     graphic += (x + 2 * y + 4) % 4;
   }
-  else if (element == EL_MAUER_LEBT)
+  else if (element == EL_WALL_GROWING)
   {
     boolean links_massiv = FALSE, rechts_massiv = FALSE;
 
@@ -1156,14 +1492,16 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
     else if (rechts_massiv)
       graphic = GFX_MAUER_L;
   }
-  else if ((element == EL_INVISIBLE_STEEL ||
-	    element == EL_UNSICHTBAR ||
-	    element == EL_SAND_INVISIBLE) && game.light_time_left)
+#if 0
+  else if ((element == EL_INVISIBLE_STEELWALL ||
+	    element == EL_INVISIBLE_WALL ||
+	    element == EL_INVISIBLE_SAND) && game.light_time_left)
   {
-    graphic = (element == EL_INVISIBLE_STEEL ? GFX_INVISIBLE_STEEL_ON :
-	       element == EL_UNSICHTBAR ? GFX_UNSICHTBAR_ON :
+    graphic = (element == EL_INVISIBLE_STEELWALL ? GFX_INVISIBLE_STEEL_ON :
+	       element == EL_INVISIBLE_WALL ? GFX_UNSICHTBAR_ON :
 	       GFX_SAND_INVISIBLE_ON);
   }
+#endif
 
   if (dx || dy)
     DrawGraphicShifted(x, y, dx, dy, graphic, cut_mode, mask_mode);
@@ -1173,6 +1511,110 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
     DrawGraphic(x, y, graphic);
 }
 
+inline static int getFramePosition(int x, int y)
+{
+  int element = Feld[x][y];
+  int frame_pos = -1;
+
+  if (element == EL_QUICKSAND_FULL ||
+      element == EL_MAGIC_WALL_FULL ||
+      element == EL_BD_MAGIC_WALL_FULL)
+    frame_pos = -1;
+  else if (IS_MOVING(x, y) || CAN_MOVE(element) || CAN_FALL(element))
+    frame_pos = ABS(MovPos[x][y]) / (TILEX / 8);
+
+  return frame_pos;
+}
+
+inline static int getGfxAction(int x, int y)
+{
+  int gfx_action = GFX_ACTION_DEFAULT;
+
+  if (GfxAction[x][y] != GFX_ACTION_DEFAULT)
+    gfx_action = GfxAction[x][y];
+  else if (IS_MOVING(x, y))
+    gfx_action = GFX_ACTION_MOVING;
+
+  return gfx_action;
+}
+
+void DrawNewScreenElementExt(int x, int y, int dx, int dy, int element,
+			     int cut_mode, int mask_mode)
+{
+  int ux = LEVELX(x), uy = LEVELY(y);
+  int move_dir = MovDir[ux][uy];
+  int move_pos = getFramePosition(ux, uy);
+  int gfx_action = getGfxAction(ux, uy);
+  int graphic = el_dir_act2img(element, move_dir, gfx_action);
+  int frame = getNewGraphicAnimationFrame(graphic, move_pos);
+
+  if (element == EL_WALL_GROWING)
+  {
+    boolean left_stopped = FALSE, right_stopped = FALSE;
+
+    if (!IN_LEV_FIELD(ux - 1, uy) || IS_MAUER(Feld[ux - 1][uy]))
+      left_stopped = TRUE;
+    if (!IN_LEV_FIELD(ux + 1, uy) || IS_MAUER(Feld[ux + 1][uy]))
+      right_stopped = TRUE;
+
+    if (left_stopped && right_stopped)
+      graphic = IMG_WALL;
+    else if (left_stopped)
+    {
+      graphic = IMG_WALL_GROWING_ACTIVE_RIGHT;
+      frame = new_graphic_info[graphic].anim_frames - 1;
+    }
+    else if (right_stopped)
+    {
+      graphic = IMG_WALL_GROWING_ACTIVE_LEFT;
+      frame = new_graphic_info[graphic].anim_frames - 1;
+    }
+  }
+#if 0
+  else if ((element == EL_ROCK ||
+	    element == EL_SP_ZONK ||
+	    element == EL_BD_ROCK ||
+	    element == EL_SP_INFOTRON ||
+	    IS_GEM(element))
+	   && !cut_mode)
+  {
+    if (uy >= lev_fieldy-1 || !IS_BELT(Feld[ux][uy+1]))
+    {
+      if (element == EL_ROCK ||
+	  element == EL_SP_ZONK ||
+	  element == EL_BD_ROCK)
+      {
+	if (move_dir == MV_LEFT)
+	  graphic += (4 - phase4) % 4;
+	else if (move_dir == MV_RIGHT)
+	  graphic += phase4;
+	else
+	  graphic += phase2 * 2;
+      }
+      else if (element != EL_SP_INFOTRON)
+	graphic += phase2;
+    }
+  }
+#endif
+  else if (IS_AMOEBOID(element) || element == EL_AMOEBA_DRIPPING)
+  {
+    graphic = (element == EL_BD_AMOEBA ? IMG_BD_AMOEBA_PART1 :
+	       element == EL_AMOEBA_WET ? IMG_AMOEBA_WET_PART1 :
+	       element == EL_AMOEBA_DRY ? IMG_AMOEBA_DRY_PART1 :
+	       element == EL_AMOEBA_FULL ? IMG_AMOEBA_FULL_PART1 :
+	       IMG_AMOEBA_DEAD_PART1);
+
+    graphic += (x + 2 * y + 4) % 4;
+  }
+
+  if (dx || dy)
+    DrawNewGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
+  else if (mask_mode == USE_MASKING)
+    DrawNewGraphicThruMask(x, y, graphic, frame);
+  else
+    DrawNewGraphic(x, y, graphic, frame);
+}
+
 void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
 			 int cut_mode, int mask_mode)
 {
@@ -1181,35 +1623,72 @@ void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
 			 cut_mode, mask_mode);
 }
 
+void DrawNewLevelElementExt(int x, int y, int dx, int dy, int element,
+			 int cut_mode, int mask_mode)
+{
+  if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+    DrawNewScreenElementExt(SCREENX(x), SCREENY(y), dx, dy, element,
+			 cut_mode, mask_mode);
+}
+
 void DrawScreenElementShifted(int x, int y, int dx, int dy, int element,
 			      int cut_mode)
 {
   DrawScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
 }
 
+void DrawNewScreenElementShifted(int x, int y, int dx, int dy, int element,
+			      int cut_mode)
+{
+  DrawNewScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
+}
+
 void DrawLevelElementShifted(int x, int y, int dx, int dy, int element,
 			     int cut_mode)
 {
   DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
 }
 
+void DrawNewLevelElementShifted(int x, int y, int dx, int dy, int element,
+			     int cut_mode)
+{
+  DrawNewLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
+}
+
 void DrawScreenElementThruMask(int x, int y, int element)
 {
   DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
 }
 
+void DrawNewScreenElementThruMask(int x, int y, int element)
+{
+  DrawNewScreenElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
+}
+
 void DrawLevelElementThruMask(int x, int y, int element)
 {
   DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
 }
 
+void DrawNewLevelElementThruMask(int x, int y, int element)
+{
+  DrawNewLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
+}
+
 void DrawLevelFieldThruMask(int x, int y)
 {
   DrawLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
 }
 
+void DrawNewLevelFieldThruMask(int x, int y)
+{
+  DrawNewLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
+}
+
 void ErdreichAnbroeckeln(int x, int y)
 {
+  Bitmap *src_bitmap;
+  int src_x, src_y;
   int i, width, height, cx,cy;
   int ux = LEVELX(x), uy = LEVELY(y);
   int element, graphic;
@@ -1227,9 +1706,9 @@ void ErdreichAnbroeckeln(int x, int y)
 
   element = Feld[ux][uy];
 
-  if (element == EL_ERDREICH ||
+  if (element == EL_SAND ||
       element == EL_LANDMINE ||
-      element == EL_TRAP_INACTIVE ||
+      element == EL_TRAP ||
       element == EL_TRAP_ACTIVE)
   {
     if (!IN_SCR_FIELD(x, y))
@@ -1237,6 +1716,8 @@ void ErdreichAnbroeckeln(int x, int y)
 
     graphic = GFX_ERDENRAND;
 
+    getGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+
     for(i=0; i<4; i++)
     {
       int uxx, uyy;
@@ -1244,13 +1725,13 @@ void ErdreichAnbroeckeln(int x, int y)
       uxx = ux + xy[i][0];
       uyy = uy + xy[i][1];
       if (!IN_LEV_FIELD(uxx, uyy))
-	element = EL_BETON;
+	element = EL_STEELWALL;
       else
 	element = Feld[uxx][uyy];
 
-      if (element == EL_ERDREICH ||
+      if (element == EL_SAND ||
 	  element == EL_LANDMINE ||
-	  element == EL_TRAP_INACTIVE ||
+	  element == EL_TRAP ||
 	  element == EL_TRAP_ACTIVE)
 	continue;
 
@@ -1269,9 +1750,7 @@ void ErdreichAnbroeckeln(int x, int y)
 	cy = (i == 3 ? TILEY - snip : 0);
       }
 
-      BlitBitmap(pix[PIX_BACK], drawto_field,
-		 SX + (graphic % GFX_PER_LINE) * TILEX + cx,
-		 SY + (graphic / GFX_PER_LINE) * TILEY + cy,
+      BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
 		 width, height, FX + x * TILEX + cx, FY + y * TILEY + cy);
     }
 
@@ -1281,6 +1760,8 @@ void ErdreichAnbroeckeln(int x, int y)
   {
     graphic = GFX_ERDENRAND;
 
+    getGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
+
     for(i=0; i<4; i++)
     {
       int xx, yy, uxx, uyy;
@@ -1291,9 +1772,9 @@ void ErdreichAnbroeckeln(int x, int y)
       uyy = uy + xy[i][1];
 
       if (!IN_LEV_FIELD(uxx, uyy) ||
-	  (Feld[uxx][uyy] != EL_ERDREICH &&
+	  (Feld[uxx][uyy] != EL_SAND &&
 	   Feld[uxx][uyy] != EL_LANDMINE &&
-	   Feld[uxx][uyy] != EL_TRAP_INACTIVE &&
+	   Feld[uxx][uyy] != EL_TRAP &&
 	   Feld[uxx][uyy] != EL_TRAP_ACTIVE) ||
 	  !IN_SCR_FIELD(xx, yy))
 	continue;
@@ -1313,9 +1794,7 @@ void ErdreichAnbroeckeln(int x, int y)
 	cy = (i==0 ? TILEY-snip : 0);
       }
 
-      BlitBitmap(pix[PIX_BACK], drawto_field,
-		 SX + (graphic % GFX_PER_LINE) * TILEX + cx,
-		 SY + (graphic / GFX_PER_LINE) * TILEY + cy,
+      BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
 		 width, height, FX + xx * TILEX + cx, FY + yy * TILEY + cy);
 
       MarkTileDirty(xx, yy);
@@ -1329,12 +1808,24 @@ void DrawScreenElement(int x, int y, int element)
   ErdreichAnbroeckeln(x, y);
 }
 
+void DrawNewScreenElement(int x, int y, int element)
+{
+  DrawNewScreenElementExt(x, y, 0, 0, element, NO_CUTTING, NO_MASKING);
+  ErdreichAnbroeckeln(x, y);
+}
+
 void DrawLevelElement(int x, int y, int element)
 {
   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
     DrawScreenElement(SCREENX(x), SCREENY(y), element);
 }
 
+void DrawNewLevelElement(int x, int y, int element)
+{
+  if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+    DrawNewScreenElement(SCREENX(x), SCREENY(y), element);
+}
+
 void DrawScreenField(int x, int y)
 {
   int ux = LEVELX(x), uy = LEVELY(y);
@@ -1343,7 +1834,7 @@ void DrawScreenField(int x, int y)
   if (!IN_LEV_FIELD(ux, uy))
   {
     if (ux < -1 || ux > lev_fieldx || uy < -1 || uy > lev_fieldy)
-      element = EL_LEERRAUM;
+      element = EL_EMPTY;
     else
       element = BorderElement;
 
@@ -1361,18 +1852,18 @@ void DrawScreenField(int x, int y)
 
     if (element == EL_QUICKSAND_EMPTYING ||
 	element == EL_MAGIC_WALL_EMPTYING ||
-	element == EL_MAGIC_WALL_BD_EMPTYING ||
+	element == EL_BD_MAGIC_WALL_EMPTYING ||
 	element == EL_AMOEBA_DRIPPING)
       cut_mode = CUT_ABOVE;
     else if (element == EL_QUICKSAND_FILLING ||
 	     element == EL_MAGIC_WALL_FILLING ||
-	     element == EL_MAGIC_WALL_BD_FILLING)
+	     element == EL_BD_MAGIC_WALL_FILLING)
       cut_mode = CUT_BELOW;
 
     if (cut_mode == CUT_ABOVE)
       DrawScreenElementShifted(x, y, 0, 0, element, NO_CUTTING);
     else
-      DrawScreenElement(x, y, EL_LEERRAUM);
+      DrawScreenElement(x, y, EL_EMPTY);
 
     if (horiz_move)
       DrawScreenElementShifted(x, y, MovPos[ux][uy], 0, element, NO_CUTTING);
@@ -1381,8 +1872,8 @@ void DrawScreenField(int x, int y)
     else
       DrawScreenElementShifted(x, y, 0, MovPos[ux][uy], content, cut_mode);
 
-    if (content == EL_SALZSAEURE)
-      DrawLevelElementThruMask(ux, uy + 1, EL_SALZSAEURE);
+    if (content == EL_ACID)
+      DrawLevelElementThruMask(ux, uy + 1, EL_ACID);
   }
   else if (IS_BLOCKED(ux, uy))
   {
@@ -1403,11 +1894,11 @@ void DrawScreenField(int x, int y)
 
     if (element_old == EL_QUICKSAND_EMPTYING ||
 	element_old == EL_MAGIC_WALL_EMPTYING ||
-	element_old == EL_MAGIC_WALL_BD_EMPTYING ||
+	element_old == EL_BD_MAGIC_WALL_EMPTYING ||
 	element_old == EL_AMOEBA_DRIPPING)
       cut_mode = CUT_ABOVE;
 
-    DrawScreenElement(x, y, EL_LEERRAUM);
+    DrawScreenElement(x, y, EL_EMPTY);
 
     if (horiz_move)
       DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
@@ -1422,7 +1913,97 @@ void DrawScreenField(int x, int y)
   else if (IS_DRAWABLE(element))
     DrawScreenElement(x, y, element);
   else
-    DrawScreenElement(x, y, EL_LEERRAUM);
+    DrawScreenElement(x, y, EL_EMPTY);
+}
+
+void DrawNewScreenField(int x, int y)
+{
+  int ux = LEVELX(x), uy = LEVELY(y);
+  int element, content;
+
+  if (!IN_LEV_FIELD(ux, uy))
+  {
+    if (ux < -1 || ux > lev_fieldx || uy < -1 || uy > lev_fieldy)
+      element = EL_EMPTY;
+    else
+      element = BorderElement;
+
+    DrawNewScreenElement(x, y, element);
+    return;
+  }
+
+  element = Feld[ux][uy];
+  content = Store[ux][uy];
+
+  if (IS_MOVING(ux, uy))
+  {
+    int horiz_move = (MovDir[ux][uy] == MV_LEFT || MovDir[ux][uy] == MV_RIGHT);
+    boolean cut_mode = NO_CUTTING;
+
+    if (element == EL_QUICKSAND_EMPTYING ||
+	element == EL_MAGIC_WALL_EMPTYING ||
+	element == EL_BD_MAGIC_WALL_EMPTYING ||
+	element == EL_AMOEBA_DRIPPING)
+      cut_mode = CUT_ABOVE;
+    else if (element == EL_QUICKSAND_FILLING ||
+	     element == EL_MAGIC_WALL_FILLING ||
+	     element == EL_BD_MAGIC_WALL_FILLING)
+      cut_mode = CUT_BELOW;
+
+    if (cut_mode == CUT_ABOVE)
+      DrawNewScreenElementShifted(x, y, 0, 0, element, NO_CUTTING);
+    else
+      DrawNewScreenElement(x, y, EL_EMPTY);
+
+    if (horiz_move)
+      DrawNewScreenElementShifted(x, y, MovPos[ux][uy], 0, element, NO_CUTTING);
+    else if (cut_mode == NO_CUTTING)
+      DrawNewScreenElementShifted(x, y, 0, MovPos[ux][uy], element, cut_mode);
+    else
+      DrawNewScreenElementShifted(x, y, 0, MovPos[ux][uy], content, cut_mode);
+
+    if (content == EL_ACID)
+      DrawNewLevelElementThruMask(ux, uy + 1, EL_ACID);
+  }
+  else if (IS_BLOCKED(ux, uy))
+  {
+    int oldx, oldy;
+    int sx, sy;
+    int horiz_move;
+    boolean cut_mode = NO_CUTTING;
+    int element_old, content_old;
+
+    Blocked2Moving(ux, uy, &oldx, &oldy);
+    sx = SCREENX(oldx);
+    sy = SCREENY(oldy);
+    horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
+		  MovDir[oldx][oldy] == MV_RIGHT);
+
+    element_old = Feld[oldx][oldy];
+    content_old = Store[oldx][oldy];
+
+    if (element_old == EL_QUICKSAND_EMPTYING ||
+	element_old == EL_MAGIC_WALL_EMPTYING ||
+	element_old == EL_BD_MAGIC_WALL_EMPTYING ||
+	element_old == EL_AMOEBA_DRIPPING)
+      cut_mode = CUT_ABOVE;
+
+    DrawNewScreenElement(x, y, EL_EMPTY);
+
+    if (horiz_move)
+      DrawNewScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
+			       NO_CUTTING);
+    else if (cut_mode == NO_CUTTING)
+      DrawNewScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old,
+			       cut_mode);
+    else
+      DrawNewScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old,
+			       cut_mode);
+  }
+  else if (IS_DRAWABLE(element))
+    DrawNewScreenElement(x, y, element);
+  else
+    DrawNewScreenElement(x, y, EL_EMPTY);
 }
 
 void DrawLevelField(int x, int y)
@@ -1447,6 +2028,28 @@ void DrawLevelField(int x, int y)
   }
 }
 
+void DrawNewLevelField(int x, int y)
+{
+  if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+    DrawNewScreenField(SCREENX(x), SCREENY(y));
+  else if (IS_MOVING(x, y))
+  {
+    int newx,newy;
+
+    Moving2Blocked(x, y, &newx, &newy);
+    if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
+      DrawNewScreenField(SCREENX(newx), SCREENY(newy));
+  }
+  else if (IS_BLOCKED(x, y))
+  {
+    int oldx, oldy;
+
+    Blocked2Moving(x, y, &oldx, &oldy);
+    if (IN_SCR_FIELD(SCREENX(oldx), SCREENY(oldy)))
+      DrawNewScreenField(SCREENX(oldx), SCREENY(oldy));
+  }
+}
+
 void DrawMiniElement(int x, int y, int element)
 {
   int graphic;
@@ -1461,12 +2064,28 @@ void DrawMiniElement(int x, int y, int element)
   DrawMiniGraphic(x, y, graphic);
 }
 
+void DrawNewMiniElement(int x, int y, int element)
+{
+  int graphic;
+
+#if 0
+  if (!element)
+  {
+    DrawNewMiniGraphic(x, y, -1);
+    return;
+  }
+#endif
+
+  graphic = el2img(element);
+  DrawNewMiniGraphic(x, y, graphic);
+}
+
 void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
 {
   int x = sx + scroll_x, y = sy + scroll_y;
 
   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
-    DrawMiniElement(sx, sy, EL_LEERRAUM);
+    DrawMiniElement(sx, sy, EL_EMPTY);
   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
     DrawMiniElement(sx, sy, Feld[x][y]);
   else
@@ -1482,7 +2101,7 @@ void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
       { GFX_VSTEEL_HORIZONTAL,	GFX_ISTEEL_HORIZONTAL  }
     };
 
-    steel_type = (BorderElement == EL_BETON ? 0 : 1);
+    steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
     steel_position = (x == -1 && y == -1			? 0 :
 		      x == lev_fieldx && y == -1		? 1 :
 		      x == -1 && y == lev_fieldy		? 2 :
@@ -1495,11 +2114,45 @@ void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
   }
 }
 
+void DrawNewMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
+{
+  int x = sx + scroll_x, y = sy + scroll_y;
+
+  if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
+    DrawNewMiniElement(sx, sy, EL_EMPTY);
+  else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
+    DrawNewMiniElement(sx, sy, Feld[x][y]);
+  else
+  {
+    int steel_type, steel_position;
+    int border[6][2] =
+    {
+      { IMG_STEELWALL_TOPLEFT,		IMG_INVISIBLE_STEELWALL_TOPLEFT     },
+      { IMG_STEELWALL_TOPRIGHT,		IMG_INVISIBLE_STEELWALL_TOPRIGHT    },
+      { IMG_STEELWALL_BOTTOMLEFT,	IMG_INVISIBLE_STEELWALL_BOTTOMLEFT  },
+      { IMG_STEELWALL_BOTTOMRIGHT,	IMG_INVISIBLE_STEELWALL_BOTTOMRIGHT },
+      { IMG_STEELWALL_VERTICAL,		IMG_INVISIBLE_STEELWALL_VERTICAL    },
+      { IMG_STEELWALL_HORIZONTAL,	IMG_INVISIBLE_STEELWALL_HORIZONTAL  }
+    };
+
+    steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
+    steel_position = (x == -1 && y == -1			? 0 :
+		      x == lev_fieldx && y == -1		? 1 :
+		      x == -1 && y == lev_fieldy		? 2 :
+		      x == lev_fieldx && y == lev_fieldy	? 3 :
+		      x == -1 || x == lev_fieldx		? 4 :
+		      y == -1 || y == lev_fieldy		? 5 : -1);
+
+    if (steel_position != -1)
+      DrawNewMiniGraphic(sx, sy, border[steel_position][steel_type]);
+  }
+}
+
 void DrawMicroElement(int xpos, int ypos, int element)
 {
   int graphic;
 
-  if (element == EL_LEERRAUM)
+  if (element == EL_EMPTY)
     return;
 
   graphic = el2gfx(element);
@@ -1507,7 +2160,6 @@ void DrawMicroElement(int xpos, int ypos, int element)
   if (graphic >= GFX_START_ROCKSSP && graphic <= GFX_END_ROCKSSP)
   {
     graphic -= GFX_START_ROCKSSP;
-    graphic -= ((graphic / SP_PER_LINE) * SP_PER_LINE) / 2;
     BlitBitmap(pix[PIX_SP], drawto,
 	       MICRO_SP_STARTX + (graphic % MICRO_SP_PER_LINE) * MICRO_TILEX,
 	       MICRO_SP_STARTY + (graphic / MICRO_SP_PER_LINE) * MICRO_TILEY,
@@ -1529,8 +2181,16 @@ void DrawMicroElement(int xpos, int ypos, int element)
 	       MICRO_MORE_STARTY + (graphic / MICRO_MORE_PER_LINE)*MICRO_TILEY,
 	       MICRO_TILEX, MICRO_TILEY, xpos, ypos);
   }
+  else if (graphic >= GFX_CHAR_START && graphic <= GFX_CHAR_END)
+  {
+    graphic -= GFX_CHAR_START;
+    BlitBitmap(pix[PIX_FONT_EM], drawto,
+	       MICRO_FONT_STARTX + (graphic % MICRO_GFX_PER_LINE)* MICRO_TILEX,
+	       MICRO_FONT_STARTY + (graphic / MICRO_GFX_PER_LINE)* MICRO_TILEY,
+	       MICRO_TILEX, MICRO_TILEY, xpos, ypos);
+  }
   else
-    BlitBitmap(pix[PIX_BACK], drawto,
+    BlitBitmap(pix[PIX_ELEMENTS], drawto,
 	       MICRO_GFX_STARTX + (graphic % MICRO_GFX_PER_LINE) * MICRO_TILEX,
 	       MICRO_GFX_STARTY + (graphic / MICRO_GFX_PER_LINE) * MICRO_TILEY,
 	       MICRO_TILEX, MICRO_TILEY, xpos, ypos);
@@ -1544,7 +2204,7 @@ void DrawLevel()
 
   for(x=BX1; x<=BX2; x++)
     for(y=BY1; y<=BY2; y++)
-      DrawScreenField(x, y);
+      DrawNewScreenField(x, y);
 
   redraw_mask |= REDRAW_FIELD;
 }
@@ -1560,6 +2220,17 @@ void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
   redraw_mask |= REDRAW_FIELD;
 }
 
+void DrawNewMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
+{
+  int x,y;
+
+  for(x=0; x<size_x; x++)
+    for(y=0; y<size_y; y++)
+      DrawNewMiniElementOrWall(x, y, scroll_x, scroll_y);
+
+  redraw_mask |= REDRAW_FIELD;
+}
+
 static void DrawMicroLevelExt(int xpos, int ypos, int from_x, int from_y)
 {
   int x, y;
@@ -1730,6 +2401,9 @@ int REQ_in_range(int x, int y)
   return 0;
 }
 
+#define MAX_REQUEST_LINES		13
+#define MAX_REQUEST_LINE_LEN		7
+
 boolean Request(char *text, unsigned int req_state)
 {
   int mx, my, ty, result = -1;
@@ -1758,31 +2432,35 @@ boolean Request(char *text, unsigned int req_state)
   ClearRectangle(drawto, DX, DY, DXSIZE, DYSIZE);
 
   /* write text for request */
-  for(ty=0; ty<13; ty++)
+  for(ty=0; ty < MAX_REQUEST_LINES; ty++)
   {
+    char text_line[MAX_REQUEST_LINE_LEN + 1];
     int tx, tl, tc;
-    char txt[256];
 
     if (!*text)
       break;
 
-    for(tl=0,tx=0; tx<7; tl++,tx++)
+    for(tl=0,tx=0; tx < MAX_REQUEST_LINE_LEN; tl++,tx++)
     {
       tc = *(text + tx);
-      if (!tc || tc == 32)
+      if (!tc || tc == ' ')
 	break;
     }
+
     if (!tl)
     { 
       text++; 
       ty--; 
       continue; 
     }
-    sprintf(txt, text); 
-    txt[tl] = 0;
-    DrawTextExt(drawto, DX + 51 - (tl * 14)/2, DY + 8 + ty * 16,
-		txt, FS_SMALL, FC_YELLOW);
-    text += tl + (tc == 32 ? 1 : 0);
+
+    strncpy(text_line, text, tl);
+    text_line[tl] = 0;
+
+    DrawTextExt(drawto, DX + 50 - (tl * 14)/2, DY + 8 + ty * 16,
+		text_line, FS_SMALL, FC_YELLOW);
+
+    text += tl + (tc == ' ' ? 1 : 0);
   }
 
   if (req_state & REQ_ASK)
@@ -1914,7 +2592,7 @@ boolean Request(char *text, unsigned int req_state)
 	  break;
 
 	case EVENT_KEYRELEASE:
-	  key_joystick_mapping = 0;
+	  ClearPlayerAction();
 	  break;
 
 	default:
@@ -2002,7 +2680,12 @@ unsigned int CloseDoor(unsigned int door_state)
 
 unsigned int GetDoorState()
 {
-  return(MoveDoor(DOOR_GET_STATE));
+  return MoveDoor(DOOR_GET_STATE);
+}
+
+unsigned int SetDoorState(unsigned int door_state)
+{
+  return MoveDoor(door_state | DOOR_SET_STATE);
 }
 
 unsigned int MoveDoor(unsigned int door_state)
@@ -2016,6 +2699,16 @@ unsigned int MoveDoor(unsigned int door_state)
   if (door_state == DOOR_GET_STATE)
     return(door1 | door2);
 
+  if (door_state & DOOR_SET_STATE)
+  {
+    if (door_state & DOOR_ACTION_1)
+      door1 = door_state & DOOR_ACTION_1;
+    if (door_state & DOOR_ACTION_2)
+      door2 = door_state & DOOR_ACTION_2;
+
+    return(door1 | door2);
+  }
+
   if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
     door_state &= ~DOOR_OPEN_1;
   else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
@@ -2029,13 +2722,20 @@ unsigned int MoveDoor(unsigned int door_state)
   {
     stepsize = 20;
     door_delay_value = 0;
-    StopSound(SND_OEFFNEN);
+    StopSound(SND_MENU_DOOR_OPENING);
+    StopSound(SND_MENU_DOOR_CLOSING);
   }
 
   if (door_state & DOOR_ACTION)
   {
     if (!(door_state & DOOR_NO_DELAY))
-      PlaySoundStereo(SND_OEFFNEN, PSND_MAX_RIGHT);
+    {
+      /* opening door sound has priority over simultaneously closing door */
+      if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
+	PlaySoundStereo(SND_MENU_DOOR_OPENING, SOUND_MAX_RIGHT);
+      else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
+	PlaySoundStereo(SND_MENU_DOOR_CLOSING, SOUND_MAX_RIGHT);
+    }
 
     start = ((door_state & DOOR_NO_DELAY) ? DXSIZE : 0);
 
@@ -2130,7 +2830,10 @@ unsigned int MoveDoor(unsigned int door_state)
   }
 
   if (setup.quick_doors)
-    StopSound(SND_OEFFNEN);
+  {
+    StopSound(SND_MENU_DOOR_OPENING);
+    StopSound(SND_MENU_DOOR_CLOSING);
+  }
 
   if (door_state & DOOR_ACTION_1)
     door1 = door_state & DOOR_ACTION_1;
@@ -2348,279 +3051,293 @@ int get_next_element(int element)
 {
   switch(element)
   {
-    case EL_QUICKSAND_FILLING:		return EL_MORAST_VOLL;
-    case EL_QUICKSAND_EMPTYING:		return EL_MORAST_LEER;
+    case EL_QUICKSAND_FILLING:		return EL_QUICKSAND_FULL;
+    case EL_QUICKSAND_EMPTYING:		return EL_QUICKSAND_EMPTY;
     case EL_MAGIC_WALL_FILLING:		return EL_MAGIC_WALL_FULL;
-    case EL_MAGIC_WALL_EMPTYING:	return EL_MAGIC_WALL_EMPTY;
-    case EL_MAGIC_WALL_BD_FILLING:	return EL_MAGIC_WALL_BD_FULL;
-    case EL_MAGIC_WALL_BD_EMPTYING:	return EL_MAGIC_WALL_BD_EMPTY;
-    case EL_AMOEBA_DRIPPING:		return EL_AMOEBE_NASS;
+    case EL_MAGIC_WALL_EMPTYING:	return EL_MAGIC_WALL_ACTIVE;
+    case EL_BD_MAGIC_WALL_FILLING:	return EL_BD_MAGIC_WALL_FULL;
+    case EL_BD_MAGIC_WALL_EMPTYING:	return EL_BD_MAGIC_WALL_ACTIVE;
+    case EL_AMOEBA_DRIPPING:		return EL_AMOEBA_WET;
 
     default:				return element;
   }
 }
 
-int el2gfx(int element)
+int el2gfx_OLD(int element)
 {
   switch(element)
   {
-    case EL_LEERRAUM:		return -1;
-    case EL_ERDREICH:		return GFX_ERDREICH;
-    case EL_MAUERWERK:		return GFX_MAUERWERK;
-    case EL_FELSBODEN:		return GFX_FELSBODEN;
-    case EL_FELSBROCKEN:	return GFX_FELSBROCKEN;
-    case EL_SCHLUESSEL:		return GFX_SCHLUESSEL;
-    case EL_EDELSTEIN:		return GFX_EDELSTEIN;
-    case EL_AUSGANG_ZU:		return GFX_AUSGANG_ZU;
-    case EL_AUSGANG_ACT:	return GFX_AUSGANG_ACT;
-    case EL_AUSGANG_AUF:	return GFX_AUSGANG_AUF;
-    case EL_SPIELFIGUR:		return GFX_SPIELFIGUR;
-    case EL_SPIELER1:		return GFX_SPIELER1;
-    case EL_SPIELER2:		return GFX_SPIELER2;
-    case EL_SPIELER3:		return GFX_SPIELER3;
-    case EL_SPIELER4:		return GFX_SPIELER4;
-    case EL_KAEFER:		return GFX_KAEFER;
-    case EL_KAEFER_RIGHT:	return GFX_KAEFER_RIGHT;
-    case EL_KAEFER_UP:		return GFX_KAEFER_UP;
-    case EL_KAEFER_LEFT:	return GFX_KAEFER_LEFT;
-    case EL_KAEFER_DOWN:	return GFX_KAEFER_DOWN;
-    case EL_FLIEGER:		return GFX_FLIEGER;
-    case EL_FLIEGER_RIGHT:	return GFX_FLIEGER_RIGHT;
-    case EL_FLIEGER_UP:		return GFX_FLIEGER_UP;
-    case EL_FLIEGER_LEFT:	return GFX_FLIEGER_LEFT;
-    case EL_FLIEGER_DOWN:	return GFX_FLIEGER_DOWN;
-    case EL_BUTTERFLY:		return GFX_BUTTERFLY;
-    case EL_BUTTERFLY_RIGHT:	return GFX_BUTTERFLY_RIGHT;
-    case EL_BUTTERFLY_UP:	return GFX_BUTTERFLY_UP;
-    case EL_BUTTERFLY_LEFT:	return GFX_BUTTERFLY_LEFT;
-    case EL_BUTTERFLY_DOWN:	return GFX_BUTTERFLY_DOWN;
-    case EL_FIREFLY:		return GFX_FIREFLY;
-    case EL_FIREFLY_RIGHT:	return GFX_FIREFLY_RIGHT;
-    case EL_FIREFLY_UP:		return GFX_FIREFLY_UP;
-    case EL_FIREFLY_LEFT:	return GFX_FIREFLY_LEFT;
-    case EL_FIREFLY_DOWN:	return GFX_FIREFLY_DOWN;
-    case EL_MAMPFER:		return GFX_MAMPFER;
-    case EL_ROBOT:		return GFX_ROBOT;
-    case EL_BETON:		return GFX_BETON;
-    case EL_DIAMANT:		return GFX_DIAMANT;
-    case EL_MORAST_LEER:	return GFX_MORAST_LEER;
-    case EL_MORAST_VOLL:	return GFX_MORAST_VOLL;
-    case EL_QUICKSAND_EMPTYING:	return GFX_MORAST_LEER;
-    case EL_TROPFEN:		return GFX_TROPFEN;
-    case EL_BOMBE:		return GFX_BOMBE;
-    case EL_MAGIC_WALL_OFF:	return GFX_MAGIC_WALL_OFF;
-    case EL_MAGIC_WALL_EMPTY:	return GFX_MAGIC_WALL_EMPTY;
-    case EL_MAGIC_WALL_EMPTYING:return GFX_MAGIC_WALL_EMPTY;
-    case EL_MAGIC_WALL_FULL:	return GFX_MAGIC_WALL_FULL;
-    case EL_MAGIC_WALL_DEAD:	return GFX_MAGIC_WALL_DEAD;
-    case EL_SALZSAEURE:		return GFX_SALZSAEURE;
-    case EL_AMOEBE_TOT:		return GFX_AMOEBE_TOT;
-    case EL_AMOEBE_NASS:	return GFX_AMOEBE_NASS;
-    case EL_AMOEBE_NORM:	return GFX_AMOEBE_NORM;
-    case EL_AMOEBE_VOLL:	return GFX_AMOEBE_VOLL;
-    case EL_AMOEBE_BD:		return GFX_AMOEBE_BD;
-    case EL_AMOEBA2DIAM:	return GFX_AMOEBA2DIAM;
-    case EL_AMOEBA_DRIPPING:	return GFX_AMOEBE_NASS;
-    case EL_KOKOSNUSS:		return GFX_KOKOSNUSS;
-    case EL_LIFE:		return GFX_LIFE;
-    case EL_LIFE_ASYNC:		return GFX_LIFE_ASYNC;
-    case EL_DYNAMITE_ACTIVE:	return GFX_DYNAMIT;
-    case EL_BADEWANNE:		return GFX_BADEWANNE;
-    case EL_BADEWANNE1:		return GFX_BADEWANNE1;
-    case EL_BADEWANNE2:		return GFX_BADEWANNE2;
-    case EL_BADEWANNE3:		return GFX_BADEWANNE3;
-    case EL_BADEWANNE4:		return GFX_BADEWANNE4;
-    case EL_BADEWANNE5:		return GFX_BADEWANNE5;
-    case EL_ABLENK_AUS:		return GFX_ABLENK_AUS;
-    case EL_ABLENK_EIN:		return GFX_ABLENK_EIN;
-    case EL_SCHLUESSEL1:	return GFX_SCHLUESSEL1;
-    case EL_SCHLUESSEL2:	return GFX_SCHLUESSEL2;
-    case EL_SCHLUESSEL3:	return GFX_SCHLUESSEL3;
-    case EL_SCHLUESSEL4:	return GFX_SCHLUESSEL4;
-    case EL_PFORTE1:		return GFX_PFORTE1;
-    case EL_PFORTE2:		return GFX_PFORTE2;
-    case EL_PFORTE3:		return GFX_PFORTE3;
-    case EL_PFORTE4:		return GFX_PFORTE4;
-    case EL_PFORTE1X:		return GFX_PFORTE1X;
-    case EL_PFORTE2X:		return GFX_PFORTE2X;
-    case EL_PFORTE3X:		return GFX_PFORTE3X;
-    case EL_PFORTE4X:		return GFX_PFORTE4X;
-    case EL_DYNAMITE_INACTIVE:	return GFX_DYNAMIT_AUS;
-    case EL_PACMAN:		return GFX_PACMAN;
-    case EL_PACMAN_RIGHT:	return GFX_PACMAN_RIGHT;
-    case EL_PACMAN_UP:		return GFX_PACMAN_UP;
-    case EL_PACMAN_LEFT:	return GFX_PACMAN_LEFT;
-    case EL_PACMAN_DOWN:	return GFX_PACMAN_DOWN;
-    case EL_UNSICHTBAR:		return GFX_UNSICHTBAR;
-    case EL_ERZ_EDEL:		return GFX_ERZ_EDEL;
-    case EL_ERZ_DIAM:		return GFX_ERZ_DIAM;
-    case EL_BIRNE_AUS:		return GFX_BIRNE_AUS;
-    case EL_BIRNE_EIN:		return GFX_BIRNE_EIN;
-    case EL_ZEIT_VOLL:		return GFX_ZEIT_VOLL;
-    case EL_ZEIT_LEER:		return GFX_ZEIT_LEER;
-    case EL_MAUER_LEBT:		return GFX_MAUER_LEBT;
-    case EL_MAUER_X:		return GFX_MAUER_X;
-    case EL_MAUER_Y:		return GFX_MAUER_Y;
-    case EL_MAUER_XY:		return GFX_MAUER_XY;
-    case EL_EDELSTEIN_BD:	return GFX_EDELSTEIN_BD;
-    case EL_EDELSTEIN_GELB:	return GFX_EDELSTEIN_GELB;
-    case EL_EDELSTEIN_ROT:	return GFX_EDELSTEIN_ROT;
-    case EL_EDELSTEIN_LILA:	return GFX_EDELSTEIN_LILA;
-    case EL_ERZ_EDEL_BD:	return GFX_ERZ_EDEL_BD;
-    case EL_ERZ_EDEL_GELB:	return GFX_ERZ_EDEL_GELB;
-    case EL_ERZ_EDEL_ROT:	return GFX_ERZ_EDEL_ROT;
-    case EL_ERZ_EDEL_LILA:	return GFX_ERZ_EDEL_LILA;
-    case EL_MAMPFER2:		return GFX_MAMPFER2;
-    case EL_MAGIC_WALL_BD_OFF:	return GFX_MAGIC_WALL_BD_OFF;
-    case EL_MAGIC_WALL_BD_EMPTY:return GFX_MAGIC_WALL_BD_EMPTY;
-    case EL_MAGIC_WALL_BD_EMPTYING:return GFX_MAGIC_WALL_BD_EMPTY;
-    case EL_MAGIC_WALL_BD_FULL:	return GFX_MAGIC_WALL_BD_FULL;
-    case EL_MAGIC_WALL_BD_DEAD:	return GFX_MAGIC_WALL_BD_DEAD;
-    case EL_DYNABOMB_ACTIVE_1:	return GFX_DYNABOMB;
-    case EL_DYNABOMB_ACTIVE_2:	return GFX_DYNABOMB;
-    case EL_DYNABOMB_ACTIVE_3:	return GFX_DYNABOMB;
-    case EL_DYNABOMB_ACTIVE_4:	return GFX_DYNABOMB;
-    case EL_DYNABOMB_NR:	return GFX_DYNABOMB_NR;
-    case EL_DYNABOMB_SZ:	return GFX_DYNABOMB_SZ;
-    case EL_DYNABOMB_XL:	return GFX_DYNABOMB_XL;
-    case EL_SOKOBAN_OBJEKT:	return GFX_SOKOBAN_OBJEKT;
-    case EL_SOKOBAN_FELD_LEER:	return GFX_SOKOBAN_FELD_LEER;
-    case EL_SOKOBAN_FELD_VOLL:	return GFX_SOKOBAN_FELD_VOLL;
-    case EL_MOLE:		return GFX_MOLE;
-    case EL_PINGUIN:		return GFX_PINGUIN;
-    case EL_SCHWEIN:		return GFX_SCHWEIN;
-    case EL_DRACHE:		return GFX_DRACHE;
-    case EL_SONDE:		return GFX_SONDE;
-    case EL_PFEIL_LEFT:		return GFX_PFEIL_LEFT;
-    case EL_PFEIL_RIGHT:	return GFX_PFEIL_RIGHT;
-    case EL_PFEIL_UP:		return GFX_PFEIL_UP;
-    case EL_PFEIL_DOWN:		return GFX_PFEIL_DOWN;
-    case EL_SPEED_PILL:		return GFX_SPEED_PILL;
-    case EL_SP_TERMINAL_ACTIVE:	return GFX_SP_TERMINAL;
-    case EL_SP_BUG_ACTIVE:	return GFX_SP_BUG_ACTIVE;
-    case EL_SP_ZONK:		return GFX_SP_ZONK;
+    case EL_EMPTY:			return -1;
+    case EL_SAND:			return GFX_ERDREICH;
+    case EL_WALL:			return GFX_MAUERWERK;
+    case EL_WALL_CRUMBLED:		return GFX_FELSBODEN;
+    case EL_ROCK:			return GFX_FELSBROCKEN;
+    case EL_EMERALD:			return GFX_EDELSTEIN;
+    case EL_EXIT_CLOSED:		return GFX_AUSGANG_ZU;
+    case EL_EXIT_OPENING:		return GFX_AUSGANG_ACT;
+    case EL_EXIT_OPEN:			return GFX_AUSGANG_AUF;
+    case EL_SP_EXIT_OPEN:		return GFX_SP_EXIT;
+    case EL_PLAYER1:			return GFX_SPIELER1;
+    case EL_PLAYER2:			return GFX_SPIELER2;
+    case EL_PLAYER3:			return GFX_SPIELER3;
+    case EL_PLAYER4:			return GFX_SPIELER4;
+    case EL_BUG:			return GFX_KAEFER;
+    case EL_BUG_RIGHT:			return GFX_KAEFER_RIGHT;
+    case EL_BUG_UP:			return GFX_KAEFER_UP;
+    case EL_BUG_LEFT:			return GFX_KAEFER_LEFT;
+    case EL_BUG_DOWN:			return GFX_KAEFER_DOWN;
+    case EL_SPACESHIP:			return GFX_FLIEGER;
+    case EL_SPACESHIP_RIGHT:		return GFX_FLIEGER_RIGHT;
+    case EL_SPACESHIP_UP:		return GFX_FLIEGER_UP;
+    case EL_SPACESHIP_LEFT:		return GFX_FLIEGER_LEFT;
+    case EL_SPACESHIP_DOWN:		return GFX_FLIEGER_DOWN;
+    case EL_BD_BUTTERFLY:		return GFX_BUTTERFLY;
+    case EL_BD_BUTTERFLY_RIGHT:		return GFX_BUTTERFLY_RIGHT;
+    case EL_BD_BUTTERFLY_UP:		return GFX_BUTTERFLY_UP;
+    case EL_BD_BUTTERFLY_LEFT:		return GFX_BUTTERFLY_LEFT;
+    case EL_BD_BUTTERFLY_DOWN:		return GFX_BUTTERFLY_DOWN;
+    case EL_BD_FIREFLY:			return GFX_FIREFLY;
+    case EL_BD_FIREFLY_RIGHT:		return GFX_FIREFLY_RIGHT;
+    case EL_BD_FIREFLY_UP:		return GFX_FIREFLY_UP;
+    case EL_BD_FIREFLY_LEFT:		return GFX_FIREFLY_LEFT;
+    case EL_BD_FIREFLY_DOWN:		return GFX_FIREFLY_DOWN;
+    case EL_YAMYAM:			return GFX_MAMPFER;
+    case EL_ROBOT:			return GFX_ROBOT;
+    case EL_STEELWALL:			return GFX_BETON;
+    case EL_DIAMOND:			return GFX_DIAMANT;
+    case EL_QUICKSAND_EMPTY:		return GFX_MORAST_LEER;
+    case EL_QUICKSAND_FULL:		return GFX_MORAST_VOLL;
+    case EL_QUICKSAND_EMPTYING:		return GFX_MORAST_LEER;
+    case EL_AMOEBA_DROP:		return GFX_TROPFEN;
+    case EL_BOMB:			return GFX_BOMBE;
+    case EL_MAGIC_WALL:			return GFX_MAGIC_WALL_OFF;
+    case EL_MAGIC_WALL_ACTIVE:		return GFX_MAGIC_WALL_EMPTY;
+    case EL_MAGIC_WALL_EMPTYING:	return GFX_MAGIC_WALL_EMPTY;
+    case EL_MAGIC_WALL_FULL:		return GFX_MAGIC_WALL_FULL;
+    case EL_MAGIC_WALL_DEAD:		return GFX_MAGIC_WALL_DEAD;
+    case EL_ACID:			return GFX_SALZSAEURE;
+    case EL_AMOEBA_DEAD:		return GFX_AMOEBE_TOT;
+    case EL_AMOEBA_WET:			return GFX_AMOEBE_NASS;
+    case EL_AMOEBA_DRY:			return GFX_AMOEBE_NORM;
+    case EL_AMOEBA_FULL:		return GFX_AMOEBE_VOLL;
+    case EL_BD_AMOEBA:			return GFX_AMOEBE_BD;
+    case EL_AMOEBA_TO_DIAMOND:		return GFX_AMOEBA2DIAM;
+    case EL_AMOEBA_DRIPPING:		return GFX_AMOEBE_NASS;
+    case EL_NUT:			return GFX_KOKOSNUSS;
+    case EL_GAMEOFLIFE:			return GFX_LIFE;
+    case EL_BIOMAZE:			return GFX_LIFE_ASYNC;
+    case EL_DYNAMITE_ACTIVE:		return GFX_DYNAMIT;
+    case EL_STONEBLOCK:			return GFX_BADEWANNE;
+    case EL_ACIDPOOL_TOPLEFT:		return GFX_BADEWANNE1;
+    case EL_ACIDPOOL_TOPRIGHT:		return GFX_BADEWANNE2;
+    case EL_ACIDPOOL_BOTTOMLEFT:	return GFX_BADEWANNE3;
+    case EL_ACIDPOOL_BOTTOM:		return GFX_BADEWANNE4;
+    case EL_ACIDPOOL_BOTTOMRIGHT:	return GFX_BADEWANNE5;
+    case EL_ROBOT_WHEEL:		return GFX_ABLENK_AUS;
+    case EL_ROBOT_WHEEL_ACTIVE:		return GFX_ABLENK_EIN;
+    case EL_KEY1:			return GFX_SCHLUESSEL1;
+    case EL_KEY2:			return GFX_SCHLUESSEL2;
+    case EL_KEY3:			return GFX_SCHLUESSEL3;
+    case EL_KEY4:			return GFX_SCHLUESSEL4;
+    case EL_GATE1:			return GFX_PFORTE1;
+    case EL_GATE2:			return GFX_PFORTE2;
+    case EL_GATE3:			return GFX_PFORTE3;
+    case EL_GATE4:			return GFX_PFORTE4;
+    case EL_GATE1_GRAY:			return GFX_PFORTE1X;
+    case EL_GATE2_GRAY:			return GFX_PFORTE2X;
+    case EL_GATE3_GRAY:			return GFX_PFORTE3X;
+    case EL_GATE4_GRAY:			return GFX_PFORTE4X;
+    case EL_DYNAMITE:			return GFX_DYNAMIT_AUS;
+    case EL_PACMAN:			return GFX_PACMAN;
+    case EL_PACMAN_RIGHT:		return GFX_PACMAN_RIGHT;
+    case EL_PACMAN_UP:			return GFX_PACMAN_UP;
+    case EL_PACMAN_LEFT:		return GFX_PACMAN_LEFT;
+    case EL_PACMAN_DOWN:		return GFX_PACMAN_DOWN;
+    case EL_INVISIBLE_WALL:		return GFX_UNSICHTBAR;
+    case EL_INVISIBLE_WALL_ACTIVE:	return GFX_UNSICHTBAR_ON;
+    case EL_WALL_EMERALD:		return GFX_ERZ_EDEL;
+    case EL_WALL_DIAMOND:		return GFX_ERZ_DIAM;
+    case EL_LAMP:			return GFX_BIRNE_AUS;
+    case EL_LAMP_ACTIVE:		return GFX_BIRNE_EIN;
+    case EL_TIME_ORB_FULL:		return GFX_ZEIT_VOLL;
+    case EL_TIME_ORB_EMPTY:		return GFX_ZEIT_LEER;
+    case EL_WALL_GROWING:		return GFX_MAUER_LEBT;
+    case EL_WALL_GROWING_X:		return GFX_MAUER_X;
+    case EL_WALL_GROWING_Y:		return GFX_MAUER_Y;
+    case EL_WALL_GROWING_XY:		return GFX_MAUER_XY;
+    case EL_BD_DIAMOND:			return GFX_EDELSTEIN_BD;
+    case EL_EMERALD_YELLOW:		return GFX_EDELSTEIN_GELB;
+    case EL_EMERALD_RED:		return GFX_EDELSTEIN_ROT;
+    case EL_EMERALD_PURPLE:		return GFX_EDELSTEIN_LILA;
+    case EL_WALL_BD_DIAMOND:		return GFX_ERZ_EDEL_BD;
+    case EL_WALL_EMERALD_YELLOW:	return GFX_ERZ_EDEL_GELB;
+    case EL_WALL_EMERALD_RED:		return GFX_ERZ_EDEL_ROT;
+    case EL_WALL_EMERALD_PURPLE:	return GFX_ERZ_EDEL_LILA;
+    case EL_DARK_YAMYAM:		return GFX_MAMPFER2;
+    case EL_BD_MAGIC_WALL:		return GFX_MAGIC_WALL_BD_OFF;
+    case EL_BD_MAGIC_WALL_ACTIVE:	return GFX_MAGIC_WALL_BD_EMPTY;
+    case EL_BD_MAGIC_WALL_EMPTYING:	return GFX_MAGIC_WALL_BD_EMPTY;
+    case EL_BD_MAGIC_WALL_FULL:		return GFX_MAGIC_WALL_BD_FULL;
+    case EL_BD_MAGIC_WALL_DEAD:		return GFX_MAGIC_WALL_BD_DEAD;
+    case EL_DYNABOMB_PLAYER1_ACTIVE:	return GFX_DYNABOMB;
+    case EL_DYNABOMB_PLAYER2_ACTIVE:	return GFX_DYNABOMB;
+    case EL_DYNABOMB_PLAYER3_ACTIVE:	return GFX_DYNABOMB;
+    case EL_DYNABOMB_PLAYER4_ACTIVE:	return GFX_DYNABOMB;
+    case EL_DYNABOMB_NR:		return GFX_DYNABOMB_NR;
+    case EL_DYNABOMB_SZ:		return GFX_DYNABOMB_SZ;
+    case EL_DYNABOMB_XL:		return GFX_DYNABOMB_XL;
+    case EL_SOKOBAN_OBJECT:		return GFX_SOKOBAN_OBJEKT;
+    case EL_SOKOBAN_FIELD_EMPTY:	return GFX_SOKOBAN_FELD_LEER;
+    case EL_SOKOBAN_FIELD_FULL:		return GFX_SOKOBAN_FELD_VOLL;
+    case EL_MOLE:			return GFX_MOLE;
+    case EL_PENGUIN:			return GFX_PINGUIN;
+    case EL_PIG:			return GFX_SCHWEIN;
+    case EL_DRAGON:			return GFX_DRACHE;
+    case EL_SATELLITE:			return GFX_SONDE;
+    case EL_ARROW_BLUE_LEFT:		return GFX_PFEIL_LEFT;
+    case EL_ARROW_BLUE_RIGHT:		return GFX_PFEIL_RIGHT;
+    case EL_ARROW_BLUE_UP:		return GFX_PFEIL_UP;
+    case EL_ARROW_BLUE_DOWN:		return GFX_PFEIL_DOWN;
+    case EL_SPEED_PILL:			return GFX_SPEED_PILL;
+    case EL_SP_TERMINAL_ACTIVE:		return GFX_SP_TERMINAL;
+    case EL_SP_BUGGY_BASE_ACTIVE:	return GFX_SP_BUG_ACTIVE;
+    case EL_SP_ZONK:			return GFX_SP_ZONK;
       /* ^^^^^^^^^^ non-standard position in supaplex graphic set! */
-    case EL_INVISIBLE_STEEL:	return GFX_INVISIBLE_STEEL;
-    case EL_BLACK_ORB:		return GFX_BLACK_ORB;
-    case EL_EM_GATE_1:		return GFX_EM_GATE_1;
-    case EL_EM_GATE_2:		return GFX_EM_GATE_2;
-    case EL_EM_GATE_3:		return GFX_EM_GATE_3;
-    case EL_EM_GATE_4:		return GFX_EM_GATE_4;
-    case EL_EM_GATE_1X:		return GFX_EM_GATE_1X;
-    case EL_EM_GATE_2X:		return GFX_EM_GATE_2X;
-    case EL_EM_GATE_3X:		return GFX_EM_GATE_3X;
-    case EL_EM_GATE_4X:		return GFX_EM_GATE_4X;
-    case EL_EM_KEY_1_FILE:	return GFX_EM_KEY_1;
-    case EL_EM_KEY_2_FILE:	return GFX_EM_KEY_2;
-    case EL_EM_KEY_3_FILE:	return GFX_EM_KEY_3;
-    case EL_EM_KEY_4_FILE:	return GFX_EM_KEY_4;
-    case EL_EM_KEY_1:		return GFX_EM_KEY_1;
-    case EL_EM_KEY_2:		return GFX_EM_KEY_2;
-    case EL_EM_KEY_3:		return GFX_EM_KEY_3;
-    case EL_EM_KEY_4:		return GFX_EM_KEY_4;
-    case EL_PEARL:		return GFX_PEARL;
-    case EL_CRYSTAL:		return GFX_CRYSTAL;
-    case EL_WALL_PEARL:		return GFX_WALL_PEARL;
-    case EL_WALL_CRYSTAL:	return GFX_WALL_CRYSTAL;
-    case EL_DOOR_WHITE:		return GFX_DOOR_WHITE;
-    case EL_DOOR_WHITE_GRAY:	return GFX_DOOR_WHITE_GRAY;
-    case EL_KEY_WHITE:		return GFX_KEY_WHITE;
-    case EL_SHIELD_PASSIVE:	return GFX_SHIELD_PASSIVE;
-    case EL_SHIELD_ACTIVE:	return GFX_SHIELD_ACTIVE;
-    case EL_EXTRA_TIME:		return GFX_EXTRA_TIME;
-    case EL_SWITCHGATE_OPEN:	return GFX_SWITCHGATE_OPEN;
-    case EL_SWITCHGATE_CLOSED:	return GFX_SWITCHGATE_CLOSED;
-    case EL_SWITCHGATE_SWITCH_1:return GFX_SWITCHGATE_SWITCH_1;
-    case EL_SWITCHGATE_SWITCH_2:return GFX_SWITCHGATE_SWITCH_2;
-    case EL_BELT1_LEFT:		return GFX_BELT1_LEFT;
-    case EL_BELT1_MIDDLE:	return GFX_BELT1_MIDDLE;
-    case EL_BELT1_RIGHT:	return GFX_BELT1_RIGHT;
-    case EL_BELT1_SWITCH_LEFT:	return GFX_BELT1_SWITCH_LEFT;
-    case EL_BELT1_SWITCH_MIDDLE:return GFX_BELT1_SWITCH_MIDDLE;
-    case EL_BELT1_SWITCH_RIGHT:	return GFX_BELT1_SWITCH_RIGHT;
-    case EL_BELT2_LEFT:		return GFX_BELT2_LEFT;
-    case EL_BELT2_MIDDLE:	return GFX_BELT2_MIDDLE;
-    case EL_BELT2_RIGHT:	return GFX_BELT2_RIGHT;
-    case EL_BELT2_SWITCH_LEFT:	return GFX_BELT2_SWITCH_LEFT;
-    case EL_BELT2_SWITCH_MIDDLE:return GFX_BELT2_SWITCH_MIDDLE;
-    case EL_BELT2_SWITCH_RIGHT:	return GFX_BELT2_SWITCH_RIGHT;
-    case EL_BELT3_LEFT:		return GFX_BELT3_LEFT;
-    case EL_BELT3_MIDDLE:	return GFX_BELT3_MIDDLE;
-    case EL_BELT3_RIGHT:	return GFX_BELT3_RIGHT;
-    case EL_BELT3_SWITCH_LEFT:	return GFX_BELT3_SWITCH_LEFT;
-    case EL_BELT3_SWITCH_MIDDLE:return GFX_BELT3_SWITCH_MIDDLE;
-    case EL_BELT3_SWITCH_RIGHT:	return GFX_BELT3_SWITCH_RIGHT;
-    case EL_BELT4_LEFT:		return GFX_BELT4_LEFT;
-    case EL_BELT4_MIDDLE:	return GFX_BELT4_MIDDLE;
-    case EL_BELT4_RIGHT:	return GFX_BELT4_RIGHT;
-    case EL_BELT4_SWITCH_LEFT:	return GFX_BELT4_SWITCH_LEFT;
-    case EL_BELT4_SWITCH_MIDDLE:return GFX_BELT4_SWITCH_MIDDLE;
-    case EL_BELT4_SWITCH_RIGHT:	return GFX_BELT4_SWITCH_RIGHT;
-    case EL_LANDMINE:		return GFX_LANDMINE;
-    case EL_ENVELOPE:		return GFX_ENVELOPE;
-    case EL_LIGHT_SWITCH_OFF:	return GFX_LIGHT_SWITCH_OFF;
-    case EL_LIGHT_SWITCH_ON:	return GFX_LIGHT_SWITCH_ON;
-    case EL_SIGN_EXCLAMATION:	return GFX_SIGN_EXCLAMATION;
-    case EL_SIGN_RADIOACTIVITY:	return GFX_SIGN_RADIOACTIVITY;
-    case EL_SIGN_STOP:		return GFX_SIGN_STOP;
-    case EL_SIGN_WHEELCHAIR:	return GFX_SIGN_WHEELCHAIR;
-    case EL_SIGN_PARKING:	return GFX_SIGN_PARKING;
-    case EL_SIGN_ONEWAY:	return GFX_SIGN_ONEWAY;
-    case EL_SIGN_HEART:		return GFX_SIGN_HEART;
-    case EL_SIGN_TRIANGLE:	return GFX_SIGN_TRIANGLE;
-    case EL_SIGN_ROUND:		return GFX_SIGN_ROUND;
-    case EL_SIGN_EXIT:		return GFX_SIGN_EXIT;
-    case EL_SIGN_YINYANG:	return GFX_SIGN_YINYANG;
-    case EL_SIGN_OTHER:		return GFX_SIGN_OTHER;
-    case EL_MOLE_LEFT:		return GFX_MOLE_LEFT;
-    case EL_MOLE_RIGHT:		return GFX_MOLE_RIGHT;
-    case EL_MOLE_UP:		return GFX_MOLE_UP;
-    case EL_MOLE_DOWN:		return GFX_MOLE_DOWN;
-    case EL_STEEL_SLANTED:	return GFX_STEEL_SLANTED;
-    case EL_SAND_INVISIBLE:	return GFX_SAND_INVISIBLE;
-    case EL_DX_UNKNOWN_15:	return GFX_DX_UNKNOWN_15;
-    case EL_DX_UNKNOWN_42:	return GFX_DX_UNKNOWN_42;
-    case EL_TIMEGATE_OPEN:	return GFX_TIMEGATE_OPEN;
-    case EL_TIMEGATE_CLOSED:	return GFX_TIMEGATE_CLOSED;
-    case EL_TIMEGATE_SWITCH_ON:	return GFX_TIMEGATE_SWITCH;
-    case EL_TIMEGATE_SWITCH_OFF:return GFX_TIMEGATE_SWITCH;
-    case EL_BALLOON:		return GFX_BALLOON;
-    case EL_BALLOON_SEND_LEFT:	return GFX_BALLOON_SEND_LEFT;
-    case EL_BALLOON_SEND_RIGHT:	return GFX_BALLOON_SEND_RIGHT;
-    case EL_BALLOON_SEND_UP:	return GFX_BALLOON_SEND_UP;
-    case EL_BALLOON_SEND_DOWN:	return GFX_BALLOON_SEND_DOWN;
-    case EL_BALLOON_SEND_ANY:	return GFX_BALLOON_SEND_ANY;
-    case EL_EMC_STEEL_WALL_1:	return GFX_EMC_STEEL_WALL_1;
-    case EL_EMC_STEEL_WALL_2:	return GFX_EMC_STEEL_WALL_2;
-    case EL_EMC_STEEL_WALL_3:	return GFX_EMC_STEEL_WALL_3;
-    case EL_EMC_STEEL_WALL_4:	return GFX_EMC_STEEL_WALL_4;
-    case EL_EMC_WALL_1:		return GFX_EMC_WALL_1;
-    case EL_EMC_WALL_2:		return GFX_EMC_WALL_2;
-    case EL_EMC_WALL_3:		return GFX_EMC_WALL_3;
-    case EL_EMC_WALL_4:		return GFX_EMC_WALL_4;
-    case EL_EMC_WALL_5:		return GFX_EMC_WALL_5;
-    case EL_EMC_WALL_6:		return GFX_EMC_WALL_6;
-    case EL_EMC_WALL_7:		return GFX_EMC_WALL_7;
-    case EL_EMC_WALL_8:		return GFX_EMC_WALL_8;
-    case EL_TUBE_CROSS:		return GFX_TUBE_CROSS;
-    case EL_TUBE_VERTICAL:	return GFX_TUBE_VERTICAL;
-    case EL_TUBE_HORIZONTAL:	return GFX_TUBE_HORIZONTAL;
-    case EL_TUBE_VERT_LEFT:	return GFX_TUBE_VERT_LEFT;
-    case EL_TUBE_VERT_RIGHT:	return GFX_TUBE_VERT_RIGHT;
-    case EL_TUBE_HORIZ_UP:	return GFX_TUBE_HORIZ_UP;
-    case EL_TUBE_HORIZ_DOWN:	return GFX_TUBE_HORIZ_DOWN;
-    case EL_TUBE_LEFT_UP:	return GFX_TUBE_LEFT_UP;
-    case EL_TUBE_LEFT_DOWN:	return GFX_TUBE_LEFT_DOWN;
-    case EL_TUBE_RIGHT_UP:	return GFX_TUBE_RIGHT_UP;
-    case EL_TUBE_RIGHT_DOWN:	return GFX_TUBE_RIGHT_DOWN;
-    case EL_SPRING:		return GFX_SPRING;
-    case EL_SPRING_MOVING:	return GFX_SPRING;
-    case EL_TRAP_INACTIVE:	return GFX_TRAP_INACTIVE;
-    case EL_TRAP_ACTIVE:	return GFX_TRAP_ACTIVE;
-    case EL_BD_WALL:		return GFX_BD_WALL;
-    case EL_BD_ROCK:		return GFX_BD_ROCK;
-    case EL_DX_SUPABOMB:	return GFX_DX_SUPABOMB;
-    case EL_SP_MURPHY_CLONE:	return GFX_SP_MURPHY_CLONE;
+    case EL_INVISIBLE_STEELWALL:	return GFX_INVISIBLE_STEEL;
+    case EL_INVISIBLE_STEELWALL_ACTIVE:	return GFX_INVISIBLE_STEEL_ON;
+    case EL_BLACK_ORB:			return GFX_BLACK_ORB;
+    case EL_EM_GATE1:			return GFX_EM_GATE_1;
+    case EL_EM_GATE2:			return GFX_EM_GATE_2;
+    case EL_EM_GATE3:			return GFX_EM_GATE_3;
+    case EL_EM_GATE4:			return GFX_EM_GATE_4;
+    case EL_EM_GATE1_GRAY:		return GFX_EM_GATE_1X;
+    case EL_EM_GATE2_GRAY:		return GFX_EM_GATE_2X;
+    case EL_EM_GATE3_GRAY:		return GFX_EM_GATE_3X;
+    case EL_EM_GATE4_GRAY:		return GFX_EM_GATE_4X;
+    case EL_EM_KEY1_FILE:		return GFX_EM_KEY_1;
+    case EL_EM_KEY2_FILE:		return GFX_EM_KEY_2;
+    case EL_EM_KEY3_FILE:		return GFX_EM_KEY_3;
+    case EL_EM_KEY4_FILE:		return GFX_EM_KEY_4;
+    case EL_EM_KEY1:			return GFX_EM_KEY_1;
+    case EL_EM_KEY2:			return GFX_EM_KEY_2;
+    case EL_EM_KEY3:			return GFX_EM_KEY_3;
+    case EL_EM_KEY4:			return GFX_EM_KEY_4;
+    case EL_PEARL:			return GFX_PEARL;
+    case EL_CRYSTAL:			return GFX_CRYSTAL;
+    case EL_WALL_PEARL:			return GFX_WALL_PEARL;
+    case EL_WALL_CRYSTAL:		return GFX_WALL_CRYSTAL;
+    case EL_DOOR_WHITE:			return GFX_DOOR_WHITE;
+    case EL_DOOR_WHITE_GRAY:		return GFX_DOOR_WHITE_GRAY;
+    case EL_KEY_WHITE:			return GFX_KEY_WHITE;
+    case EL_SHIELD_NORMAL:		return GFX_SHIELD_PASSIVE;
+    case EL_SHIELD_DEADLY:		return GFX_SHIELD_ACTIVE;
+    case EL_EXTRA_TIME:			return GFX_EXTRA_TIME;
+    case EL_SWITCHGATE_OPEN:		return GFX_SWITCHGATE_OPEN;
+    case EL_SWITCHGATE_CLOSED:		return GFX_SWITCHGATE_CLOSED;
+    case EL_SWITCHGATE_SWITCH_UP:	return GFX_SWITCHGATE_SWITCH_1;
+    case EL_SWITCHGATE_SWITCH_DOWN:	return GFX_SWITCHGATE_SWITCH_2;
+    case EL_CONVEYOR_BELT1_LEFT:	return GFX_BELT1_LEFT;
+    case EL_CONVEYOR_BELT1_MIDDLE:	return GFX_BELT1_MIDDLE;
+    case EL_CONVEYOR_BELT1_RIGHT:	return GFX_BELT1_RIGHT;
+    case EL_CONVEYOR_BELT1_LEFT_ACTIVE:	return GFX_BELT1_LEFT;
+    case EL_CONVEYOR_BELT1_MIDDLE_ACTIVE:return GFX_BELT1_MIDDLE;
+    case EL_CONVEYOR_BELT1_RIGHT_ACTIVE:return GFX_BELT1_RIGHT;
+    case EL_CONVEYOR_BELT1_SWITCH_LEFT:	return GFX_BELT1_SWITCH_LEFT;
+    case EL_CONVEYOR_BELT1_SWITCH_MIDDLE:return GFX_BELT1_SWITCH_MIDDLE;
+    case EL_CONVEYOR_BELT1_SWITCH_RIGHT:return GFX_BELT1_SWITCH_RIGHT;
+    case EL_CONVEYOR_BELT2_LEFT:	return GFX_BELT2_LEFT;
+    case EL_CONVEYOR_BELT2_MIDDLE:	return GFX_BELT2_MIDDLE;
+    case EL_CONVEYOR_BELT2_RIGHT:	return GFX_BELT2_RIGHT;
+    case EL_CONVEYOR_BELT2_LEFT_ACTIVE:	return GFX_BELT2_LEFT;
+    case EL_CONVEYOR_BELT2_MIDDLE_ACTIVE:return GFX_BELT2_MIDDLE;
+    case EL_CONVEYOR_BELT2_RIGHT_ACTIVE:return GFX_BELT2_RIGHT;
+    case EL_CONVEYOR_BELT2_SWITCH_LEFT:	return GFX_BELT2_SWITCH_LEFT;
+    case EL_CONVEYOR_BELT2_SWITCH_MIDDLE:return GFX_BELT2_SWITCH_MIDDLE;
+    case EL_CONVEYOR_BELT2_SWITCH_RIGHT:return GFX_BELT2_SWITCH_RIGHT;
+    case EL_CONVEYOR_BELT3_LEFT:	return GFX_BELT3_LEFT;
+    case EL_CONVEYOR_BELT3_MIDDLE:	return GFX_BELT3_MIDDLE;
+    case EL_CONVEYOR_BELT3_RIGHT:	return GFX_BELT3_RIGHT;
+    case EL_CONVEYOR_BELT3_LEFT_ACTIVE:	return GFX_BELT3_LEFT;
+    case EL_CONVEYOR_BELT3_MIDDLE_ACTIVE:return GFX_BELT3_MIDDLE;
+    case EL_CONVEYOR_BELT3_RIGHT_ACTIVE:return GFX_BELT3_RIGHT;
+    case EL_CONVEYOR_BELT3_SWITCH_LEFT:	return GFX_BELT3_SWITCH_LEFT;
+    case EL_CONVEYOR_BELT3_SWITCH_MIDDLE:return GFX_BELT3_SWITCH_MIDDLE;
+    case EL_CONVEYOR_BELT3_SWITCH_RIGHT:return GFX_BELT3_SWITCH_RIGHT;
+    case EL_CONVEYOR_BELT4_LEFT:	return GFX_BELT4_LEFT;
+    case EL_CONVEYOR_BELT4_MIDDLE:	return GFX_BELT4_MIDDLE;
+    case EL_CONVEYOR_BELT4_RIGHT:	return GFX_BELT4_RIGHT;
+    case EL_CONVEYOR_BELT4_LEFT_ACTIVE:	return GFX_BELT4_LEFT;
+    case EL_CONVEYOR_BELT4_MIDDLE_ACTIVE:return GFX_BELT4_MIDDLE;
+    case EL_CONVEYOR_BELT4_RIGHT_ACTIVE:return GFX_BELT4_RIGHT;
+    case EL_CONVEYOR_BELT4_SWITCH_LEFT:	return GFX_BELT4_SWITCH_LEFT;
+    case EL_CONVEYOR_BELT4_SWITCH_MIDDLE:return GFX_BELT4_SWITCH_MIDDLE;
+    case EL_CONVEYOR_BELT4_SWITCH_RIGHT:return GFX_BELT4_SWITCH_RIGHT;
+    case EL_LANDMINE:			return GFX_LANDMINE;
+    case EL_ENVELOPE:			return GFX_ENVELOPE;
+    case EL_LIGHT_SWITCH:		return GFX_LIGHT_SWITCH_OFF;
+    case EL_LIGHT_SWITCH_ACTIVE:	return GFX_LIGHT_SWITCH_ON;
+    case EL_SIGN_EXCLAMATION:		return GFX_SIGN_EXCLAMATION;
+    case EL_SIGN_RADIOACTIVITY:		return GFX_SIGN_RADIOACTIVITY;
+    case EL_SIGN_STOP:			return GFX_SIGN_STOP;
+    case EL_SIGN_WHEELCHAIR:		return GFX_SIGN_WHEELCHAIR;
+    case EL_SIGN_PARKING:		return GFX_SIGN_PARKING;
+    case EL_SIGN_ONEWAY:		return GFX_SIGN_ONEWAY;
+    case EL_SIGN_HEART:			return GFX_SIGN_HEART;
+    case EL_SIGN_TRIANGLE:		return GFX_SIGN_TRIANGLE;
+    case EL_SIGN_ROUND:			return GFX_SIGN_ROUND;
+    case EL_SIGN_EXIT:			return GFX_SIGN_EXIT;
+    case EL_SIGN_YINYANG:		return GFX_SIGN_YINYANG;
+    case EL_SIGN_OTHER:			return GFX_SIGN_OTHER;
+    case EL_MOLE_LEFT:			return GFX_MOLE_LEFT;
+    case EL_MOLE_RIGHT:			return GFX_MOLE_RIGHT;
+    case EL_MOLE_UP:			return GFX_MOLE_UP;
+    case EL_MOLE_DOWN:			return GFX_MOLE_DOWN;
+    case EL_STEELWALL_SLANTED:		return GFX_STEEL_SLANTED;
+    case EL_INVISIBLE_SAND:		return GFX_SAND_INVISIBLE;
+    case EL_INVISIBLE_SAND_ACTIVE:	return GFX_SAND_INVISIBLE_ON;
+    case EL_DX_UNKNOWN_15:		return GFX_DX_UNKNOWN_15;
+    case EL_DX_UNKNOWN_42:		return GFX_DX_UNKNOWN_42;
+    case EL_TIMEGATE_OPEN:		return GFX_TIMEGATE_OPEN;
+    case EL_TIMEGATE_CLOSED:		return GFX_TIMEGATE_CLOSED;
+    case EL_TIMEGATE_SWITCH_ACTIVE:	return GFX_TIMEGATE_SWITCH;
+    case EL_TIMEGATE_SWITCH:		return GFX_TIMEGATE_SWITCH;
+    case EL_BALLOON:			return GFX_BALLOON;
+    case EL_BALLOON_SEND_LEFT:		return GFX_BALLOON_SEND_LEFT;
+    case EL_BALLOON_SEND_RIGHT:		return GFX_BALLOON_SEND_RIGHT;
+    case EL_BALLOON_SEND_UP:		return GFX_BALLOON_SEND_UP;
+    case EL_BALLOON_SEND_DOWN:		return GFX_BALLOON_SEND_DOWN;
+    case EL_BALLOON_SEND_ANY_DIRECTION:	return GFX_BALLOON_SEND_ANY;
+    case EL_EMC_STEELWALL1:		return GFX_EMC_STEEL_WALL_1;
+    case EL_EMC_STEELWALL2:		return GFX_EMC_STEEL_WALL_2;
+    case EL_EMC_STEELWALL3:		return GFX_EMC_STEEL_WALL_3;
+    case EL_EMC_STEELWALL4:		return GFX_EMC_STEEL_WALL_4;
+    case EL_EMC_WALL_PILLAR_UPPER:	return GFX_EMC_WALL_1;
+    case EL_EMC_WALL_PILLAR_MIDDLE:	return GFX_EMC_WALL_2;
+    case EL_EMC_WALL_PILLAR_LOWER:	return GFX_EMC_WALL_3;
+    case EL_EMC_WALL4:			return GFX_EMC_WALL_4;
+    case EL_EMC_WALL5:			return GFX_EMC_WALL_5;
+    case EL_EMC_WALL6:			return GFX_EMC_WALL_6;
+    case EL_EMC_WALL7:			return GFX_EMC_WALL_7;
+    case EL_EMC_WALL8:			return GFX_EMC_WALL_8;
+    case EL_TUBE_ALL:			return GFX_TUBE_CROSS;
+    case EL_TUBE_VERTICAL:		return GFX_TUBE_VERTICAL;
+    case EL_TUBE_HORIZONTAL:		return GFX_TUBE_HORIZONTAL;
+    case EL_TUBE_VERTICAL_LEFT:		return GFX_TUBE_VERT_LEFT;
+    case EL_TUBE_VERTICAL_RIGHT:	return GFX_TUBE_VERT_RIGHT;
+    case EL_TUBE_HORIZONTAL_UP:		return GFX_TUBE_HORIZ_UP;
+    case EL_TUBE_HORIZONTAL_DOWN:	return GFX_TUBE_HORIZ_DOWN;
+    case EL_TUBE_LEFT_UP:		return GFX_TUBE_LEFT_UP;
+    case EL_TUBE_LEFT_DOWN:		return GFX_TUBE_LEFT_DOWN;
+    case EL_TUBE_RIGHT_UP:		return GFX_TUBE_RIGHT_UP;
+    case EL_TUBE_RIGHT_DOWN:		return GFX_TUBE_RIGHT_DOWN;
+    case EL_SPRING:			return GFX_SPRING;
+    case EL_SPRING_MOVING:		return GFX_SPRING;
+    case EL_TRAP:			return GFX_TRAP_INACTIVE;
+    case EL_TRAP_ACTIVE:		return GFX_TRAP_ACTIVE;
+    case EL_BD_WALL:			return GFX_BD_WALL;
+    case EL_BD_ROCK:			return GFX_BD_ROCK;
+    case EL_DX_SUPABOMB:		return GFX_DX_SUPABOMB;
+    case EL_SP_MURPHY_CLONE:		return GFX_SP_MURPHY_CLONE;
 
     default:
     {
@@ -2641,3 +3358,73 @@ int el2gfx(int element)
     }
   }
 }
+
+int el2gfx(int element)
+{
+#if 1
+  int graphic_OLD = el2gfx_OLD(element);
+
+  return graphic_OLD;
+#else
+
+  int graphic_NEW = element_info[element].graphic[GFX_ACTION_DEFAULT];
+
+#if DEBUG
+  int graphic_OLD = el2gfx_OLD(element);
+
+  if (element >= MAX_ELEMENTS)
+  {
+    Error(ERR_WARN, "el2gfx: element == %d >= MAX_ELEMENTS", element);
+  }
+
+  if (graphic_NEW != graphic_OLD)
+  {
+    Error(ERR_WARN, "el2gfx: graphic_NEW (%d) != graphic_OLD (%d)",
+	  graphic_NEW, graphic_OLD);
+  }
+#endif
+
+  return graphic_NEW;
+#endif
+}
+
+int el2img(int element)
+{
+#if 1
+  int graphic_NEW = element_info[element].graphic[GFX_ACTION_DEFAULT];
+
+#if DEBUG
+  if (graphic_NEW < 0)
+    Error(ERR_WARN, "element %d -> graphic %d -- probably crashing now...",
+	  element, graphic_NEW);
+#endif
+
+  return graphic_NEW;
+#else
+
+  switch(element)
+  {
+    case EL_BD_BUTTERFLY:	return IMG_BD_BUTTERFLY;
+    case EL_BD_FIREFLY:		return IMG_BD_FIREFLY;
+    case EL_SP_ELECTRON:	return IMG_SP_ELECTRON;
+
+    default:
+      break;
+  }
+
+  return IMG_EMPTY;
+#endif
+}
+
+int el_dir2img(int element, int direction)
+{
+  return el_dir_act2img(element, direction, GFX_ACTION_DEFAULT);
+}
+
+int el_dir_act2img(int element, int direction, int action)
+{
+  action = graphics_action_mapping[action];
+  direction = MV_DIR_BIT(direction);
+
+  return element_info[element].direction_graphic[action][direction];
+}