src/tools.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * tools.c                                                  *
  12 ***********************************************************/
  13
  14 #include "libgame/libgame.h"
  15
  16 #include "tools.h"
  17 #include "game.h"
  18 #include "events.h"
  19 #include "cartoons.h"
  20 #include "network.h"
  21 #include "tape.h"
  22
  23 /* tool button identifiers */
  24 #define TOOL_CTRL_ID_YES        0
  25 #define TOOL_CTRL_ID_NO         1
  26 #define TOOL_CTRL_ID_CONFIRM    2
  27 #define TOOL_CTRL_ID_PLAYER_1   3
  28 #define TOOL_CTRL_ID_PLAYER_2   4
  29 #define TOOL_CTRL_ID_PLAYER_3   5
  30 #define TOOL_CTRL_ID_PLAYER_4   6
  31
  32 #define NUM_TOOL_BUTTONS        7
  33
  34 /* forward declaration for internal use */
  35 static void UnmapToolButtons();
  36 static void HandleToolButtons(struct GadgetInfo *);
  37 static int el_act_dir2crm(int, int, int);
  38
  39 static struct GadgetInfo *tool_gadget[NUM_TOOL_BUTTONS];
  40 static int request_gadget_id = -1;
  41
  42 void SetDrawtoField(int mode)
  43 {
  44   if (mode == DRAW_BUFFERED && setup.soft_scrolling)
  45   {
  46     FX = TILEX;
  47     FY = TILEY;
  48     BX1 = -1;
  49     BY1 = -1;
  50     BX2 = SCR_FIELDX;
  51     BY2 = SCR_FIELDY;
  52     redraw_x1 = 1;
  53     redraw_y1 = 1;
  54
  55     drawto_field = fieldbuffer;
  56   }
  57   else  /* DRAW_DIRECT, DRAW_BACKBUFFER */
  58   {
  59     FX = SX;
  60     FY = SY;
  61     BX1 = 0;
  62     BY1 = 0;
  63     BX2 = SCR_FIELDX - 1;
  64     BY2 = SCR_FIELDY - 1;
  65     redraw_x1 = 0;
  66     redraw_y1 = 0;
  67
  68     drawto_field = (mode == DRAW_DIRECT ? window :  backbuffer);
  69   }
  70 }
  71
  72 void RedrawPlayfield(boolean force_redraw, int x, int y, int width, int height)
  73 {
  74   if (game_status == GAME_MODE_PLAYING)
  75   {
  76     if (force_redraw)
  77     {
  78       x = gfx.sx - TILEX;
  79       y = gfx.sy - TILEY;
  80       width = gfx.sxsize + 2 * TILEX;
  81       height = gfx.sysize + 2 * TILEY;
  82     }
  83
  84     if (force_redraw || setup.direct_draw)
  85     {
  86       int xx, yy;
  87       int x1 = (x - SX) / TILEX, y1 = (y - SY) / TILEY;
  88       int x2 = (x - SX + width) / TILEX, y2 = (y - SY + height) / TILEY;
  89
  90       if (setup.direct_draw)
  91         SetDrawtoField(DRAW_BACKBUFFER);
  92
  93       for(xx=BX1; xx<=BX2; xx++)
  94         for(yy=BY1; yy<=BY2; yy++)
  95           if (xx >= x1 && xx <= x2 && yy >= y1 && yy <= y2)
  96             DrawScreenField(xx, yy);
  97       DrawAllPlayers();
  98
  99       if (setup.direct_draw)
 100         SetDrawtoField(DRAW_DIRECT);
 101     }
 102
 103     if (setup.soft_scrolling)
 104     {
 105       int fx = FX, fy = FY;
 106
 107       fx += (ScreenMovDir & (MV_LEFT|MV_RIGHT) ? ScreenGfxPos : 0);
 108       fy += (ScreenMovDir & (MV_UP|MV_DOWN)    ? ScreenGfxPos : 0);
 109
 110       BlitBitmap(fieldbuffer, backbuffer, fx,fy, SXSIZE,SYSIZE, SX,SY);
 111     }
 112   }
 113
 114   BlitBitmap(drawto, window, x, y, width, height, x, y);
 115 }
 116
 117 void BackToFront()
 118 {
 119   int x,y;
 120   DrawBuffer *buffer = (drawto_field == window ? backbuffer : drawto_field);
 121
 122   if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
 123     redraw_mask &= ~REDRAW_MAIN;
 124
 125   if (redraw_mask & REDRAW_TILES && redraw_tiles > REDRAWTILES_THRESHOLD)
 126     redraw_mask |= REDRAW_FIELD;
 127
 128   if (redraw_mask & REDRAW_FIELD)
 129     redraw_mask &= ~REDRAW_TILES;
 130
 131   if (redraw_mask == REDRAW_NONE)
 132     return;
 133
 134   if (global.fps_slowdown && game_status == GAME_MODE_PLAYING)
 135   {
 136     static boolean last_frame_skipped = FALSE;
 137     boolean skip_even_when_not_scrolling = TRUE;
 138     boolean just_scrolling = (ScreenMovDir != 0);
 139     boolean verbose = FALSE;
 140
 141     if (global.fps_slowdown_factor > 1 &&
 142         (FrameCounter % global.fps_slowdown_factor) &&
 143         (just_scrolling || skip_even_when_not_scrolling))
 144     {
 145       redraw_mask &= ~REDRAW_MAIN;
 146
 147       last_frame_skipped = TRUE;
 148
 149       if (verbose)
 150         printf("FRAME SKIPPED\n");
 151     }
 152     else
 153     {
 154       if (last_frame_skipped)
 155         redraw_mask |= REDRAW_FIELD;
 156
 157       last_frame_skipped = FALSE;
 158
 159       if (verbose)
 160         printf("frame not skipped\n");
 161     }
 162   }
 163
 164   /* synchronize X11 graphics at this point; if we would synchronize the
 165      display immediately after the buffer switching (after the XFlush),
 166      this could mean that we have to wait for the graphics to complete,
 167      although we could go on doing calculations for the next frame */
 168
 169   SyncDisplay();
 170
 171   if (redraw_mask & REDRAW_ALL)
 172   {
 173     BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
 174     redraw_mask = 0;
 175   }
 176
 177   if (redraw_mask & REDRAW_FIELD)
 178   {
 179     if (game_status != GAME_MODE_PLAYING ||
 180         redraw_mask & REDRAW_FROM_BACKBUFFER)
 181     {
 182       BlitBitmap(backbuffer, window,
 183                  REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
 184     }
 185     else
 186     {
 187       int fx = FX, fy = FY;
 188
 189       if (setup.soft_scrolling)
 190       {
 191         fx += (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0);
 192         fy += (ScreenMovDir & (MV_UP | MV_DOWN)    ? ScreenGfxPos : 0);
 193       }
 194
 195       if (setup.soft_scrolling ||
 196           ABS(ScreenMovPos) + ScrollStepSize == TILEX ||
 197           ABS(ScreenMovPos) == ScrollStepSize ||
 198           redraw_tiles > REDRAWTILES_THRESHOLD)
 199       {
 200         BlitBitmap(buffer, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
 201
 202 #ifdef DEBUG
 203 #if 0
 204         printf("redrawing all (ScreenGfxPos == %d) because %s\n",
 205                ScreenGfxPos,
 206                (setup.soft_scrolling ?
 207                 "setup.soft_scrolling" :
 208                 ABS(ScreenGfxPos) + ScrollStepSize == TILEX ?
 209                 "ABS(ScreenGfxPos) + ScrollStepSize == TILEX" :
 210                 ABS(ScreenGfxPos) == ScrollStepSize ?
 211                 "ABS(ScreenGfxPos) == ScrollStepSize" :
 212                 "redraw_tiles > REDRAWTILES_THRESHOLD"));
 213 #endif
 214 #endif
 215       }
 216     }
 217
 218     redraw_mask &= ~REDRAW_MAIN;
 219   }
 220
 221   if (redraw_mask & REDRAW_DOORS)
 222   {
 223     if (redraw_mask & REDRAW_DOOR_1)
 224       BlitBitmap(backbuffer, window, DX, DY, DXSIZE, DYSIZE, DX, DY);
 225     if (redraw_mask & REDRAW_DOOR_2)
 226     {
 227       if ((redraw_mask & REDRAW_DOOR_2) == REDRAW_DOOR_2)
 228         BlitBitmap(backbuffer, window, VX,VY, VXSIZE,VYSIZE, VX,VY);
 229       else
 230       {
 231         if (redraw_mask & REDRAW_VIDEO_1)
 232           BlitBitmap(backbuffer, window,
 233                      VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS,
 234                      VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE,
 235                      VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS);
 236         if (redraw_mask & REDRAW_VIDEO_2)
 237           BlitBitmap(backbuffer, window,
 238                      VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS,
 239                      VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE,
 240                      VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS);
 241         if (redraw_mask & REDRAW_VIDEO_3)
 242           BlitBitmap(backbuffer, window,
 243                      VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS,
 244                      VIDEO_CONTROL_XSIZE,VIDEO_CONTROL_YSIZE,
 245                      VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS);
 246       }
 247     }
 248
 249     if (redraw_mask & REDRAW_DOOR_3)
 250       BlitBitmap(backbuffer, window, EX, EY, EXSIZE, EYSIZE, EX, EY);
 251
 252     redraw_mask &= ~REDRAW_DOORS;
 253   }
 254
 255   if (redraw_mask & REDRAW_MICROLEVEL)
 256   {
 257     BlitBitmap(backbuffer, window, SX, SY + 10 * TILEY, SXSIZE, 7 * TILEY,
 258                SX, SY + 10 * TILEY);
 259
 260     redraw_mask &= ~REDRAW_MICROLEVEL;
 261   }
 262
 263   if (redraw_mask & REDRAW_TILES)
 264   {
 265     for(x=0; x<SCR_FIELDX; x++)
 266       for(y=0; y<SCR_FIELDY; y++)
 267         if (redraw[redraw_x1 + x][redraw_y1 + y])
 268           BlitBitmap(buffer, window,
 269                      FX + x * TILEX, FX + y * TILEY, TILEX, TILEY,
 270                      SX + x * TILEX, SY + y * TILEY);
 271   }
 272
 273   if (redraw_mask & REDRAW_FPS)         /* display frames per second */
 274   {
 275     char text[100];
 276     char info1[100];
 277
 278     sprintf(info1, " (only every %d. frame)", global.fps_slowdown_factor);
 279     if (!global.fps_slowdown)
 280       info1[0] = '\0';
 281
 282     sprintf(text, "%.1f fps%s", global.frames_per_second, info1);
 283     DrawTextExt(window, SX, SY, text, FONT_TEXT_2, BLIT_OPAQUE);
 284   }
 285
 286   FlushDisplay();
 287
 288   for(x=0; x<MAX_BUF_XSIZE; x++)
 289     for(y=0; y<MAX_BUF_YSIZE; y++)
 290       redraw[x][y] = 0;
 291   redraw_tiles = 0;
 292   redraw_mask = REDRAW_NONE;
 293 }
 294
 295 void FadeToFront()
 296 {
 297 #if 0
 298   long fading_delay = 300;
 299
 300   if (setup.fading && (redraw_mask & REDRAW_FIELD))
 301   {
 302 #endif
 303
 304 #if 0
 305     int x,y;
 306
 307     ClearRectangle(window, REAL_SX,REAL_SY,FULL_SXSIZE,FULL_SYSIZE);
 308     FlushDisplay();
 309
 310     for(i=0;i<2*FULL_SYSIZE;i++)
 311     {
 312       for(y=0;y<FULL_SYSIZE;y++)
 313       {
 314         BlitBitmap(backbuffer, window,
 315                    REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
 316       }
 317       FlushDisplay();
 318       Delay(10);
 319     }
 320 #endif
 321
 322 #if 0
 323     for(i=1;i<FULL_SYSIZE;i+=2)
 324       BlitBitmap(backbuffer, window,
 325                  REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
 326     FlushDisplay();
 327     Delay(fading_delay);
 328 #endif
 329
 330 #if 0
 331     SetClipOrigin(clip_gc[PIX_FADEMASK], 0, 0);
 332     BlitBitmapMasked(backbuffer, window,
 333                      REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
 334                      REAL_SX,REAL_SY);
 335     FlushDisplay();
 336     Delay(fading_delay);
 337
 338     SetClipOrigin(clip_gc[PIX_FADEMASK], -1, -1);
 339     BlitBitmapMasked(backbuffer, window,
 340                      REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
 341                      REAL_SX,REAL_SY);
 342     FlushDisplay();
 343     Delay(fading_delay);
 344
 345     SetClipOrigin(clip_gc[PIX_FADEMASK], 0, -1);
 346     BlitBitmapMasked(backbuffer, window,
 347                      REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
 348                      REAL_SX,REAL_SY);
 349     FlushDisplay();
 350     Delay(fading_delay);
 351
 352     SetClipOrigin(clip_gc[PIX_FADEMASK], -1, 0);
 353     BlitBitmapMasked(backbuffer, window,
 354                      REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
 355                      REAL_SX,REAL_SY);
 356     FlushDisplay();
 357     Delay(fading_delay);
 358
 359     redraw_mask &= ~REDRAW_MAIN;
 360   }
 361 #endif
 362
 363   BackToFront();
 364 }
 365
 366 void SetMainBackgroundImage(int graphic)
 367 {
 368   SetMainBackgroundBitmap(graphic == IMG_UNDEFINED ? NULL :
 369                           graphic_info[graphic].bitmap ?
 370                           graphic_info[graphic].bitmap :
 371                           graphic_info[IMG_BACKGROUND].bitmap);
 372 }
 373
 374 void SetDoorBackgroundImage(int graphic)
 375 {
 376   SetDoorBackgroundBitmap(graphic == IMG_UNDEFINED ? NULL :
 377                           graphic_info[graphic].bitmap ?
 378                           graphic_info[graphic].bitmap :
 379                           graphic_info[IMG_BACKGROUND].bitmap);
 380 }
 381
 382 void DrawBackground(int dest_x, int dest_y, int width, int height)
 383 {
 384   ClearRectangleOnBackground(backbuffer, dest_x, dest_y, width, height);
 385
 386   redraw_mask |= REDRAW_FIELD;
 387 }
 388
 389 void ClearWindow()
 390 {
 391   DrawBackground(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
 392
 393   if (setup.soft_scrolling && game_status == GAME_MODE_PLAYING)
 394   {
 395     ClearRectangle(fieldbuffer, 0, 0, FXSIZE, FYSIZE);
 396     SetDrawtoField(DRAW_BUFFERED);
 397   }
 398   else
 399     SetDrawtoField(DRAW_BACKBUFFER);
 400
 401   if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
 402   {
 403     ClearRectangle(window, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
 404     SetDrawtoField(DRAW_DIRECT);
 405   }
 406 }
 407
 408 void MarkTileDirty(int x, int y)
 409 {
 410   int xx = redraw_x1 + x;
 411   int yy = redraw_y1 + y;
 412
 413   if (!redraw[xx][yy])
 414     redraw_tiles++;
 415
 416   redraw[xx][yy] = TRUE;
 417   redraw_mask |= REDRAW_TILES;
 418 }
 419
 420 void SetBorderElement()
 421 {
 422   int x, y;
 423
 424   BorderElement = EL_EMPTY;
 425
 426   for(y=0; y<lev_fieldy && BorderElement == EL_EMPTY; y++)
 427   {
 428     for(x=0; x<lev_fieldx; x++)
 429     {
 430       if (!IS_INDESTRUCTIBLE(Feld[x][y]))
 431         BorderElement = EL_STEELWALL;
 432
 433       if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
 434         x = lev_fieldx - 2;
 435     }
 436   }
 437 }
 438
 439 void SetRandomAnimationValue(int x, int y)
 440 {
 441   gfx.anim_random_frame = GfxRandom[x][y];
 442 }
 443
 444 inline int getGraphicAnimationFrame(int graphic, int sync_frame)
 445 {
 446   /* animation synchronized with global frame counter, not move position */
 447   if (graphic_info[graphic].anim_global_sync || sync_frame < 0)
 448     sync_frame = FrameCounter;
 449
 450   return getAnimationFrame(graphic_info[graphic].anim_frames,
 451                            graphic_info[graphic].anim_delay,
 452                            graphic_info[graphic].anim_mode,
 453                            graphic_info[graphic].anim_start_frame,
 454                            sync_frame);
 455 }
 456
 457 inline void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
 458                                     int graphic, int sync_frame, int mask_mode)
 459 {
 460   int frame = getGraphicAnimationFrame(graphic, sync_frame);
 461
 462   if (mask_mode == USE_MASKING)
 463     DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
 464   else
 465     DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
 466 }
 467
 468 inline void DrawGraphicAnimation(int x, int y, int graphic)
 469 {
 470   int lx = LEVELX(x), ly = LEVELY(y);
 471
 472   if (!IN_SCR_FIELD(x, y))
 473     return;
 474
 475   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
 476                           graphic, GfxFrame[lx][ly], NO_MASKING);
 477   MarkTileDirty(x, y);
 478 }
 479
 480 void DrawLevelGraphicAnimation(int x, int y, int graphic)
 481 {
 482   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
 483 }
 484
 485 void DrawLevelElementAnimation(int x, int y, int element)
 486 {
 487 #if 1
 488   int graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
 489
 490   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
 491 #else
 492   DrawGraphicAnimation(SCREENX(x), SCREENY(y), el2img(element));
 493 #endif
 494 }
 495
 496 inline void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
 497 {
 498   int sx = SCREENX(x), sy = SCREENY(y);
 499
 500   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
 501     return;
 502
 503   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
 504     return;
 505
 506   DrawGraphicAnimation(sx, sy, graphic);
 507
 508   if (CAN_BE_CRUMBLED(Feld[x][y]))
 509     DrawLevelFieldCrumbledSand(x, y);
 510 }
 511
 512 void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
 513 {
 514   int sx = SCREENX(x), sy = SCREENY(y);
 515   int graphic;
 516
 517   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
 518     return;
 519
 520   graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
 521
 522   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
 523     return;
 524
 525   DrawGraphicAnimation(sx, sy, graphic);
 526
 527   if (CAN_BE_CRUMBLED(element))
 528     DrawLevelFieldCrumbledSand(x, y);
 529 }
 530
 531 void DrawAllPlayers()
 532 {
 533   int i;
 534
 535   for(i=0; i<MAX_PLAYERS; i++)
 536     if (stored_player[i].active)
 537       DrawPlayer(&stored_player[i]);
 538 }
 539
 540 void DrawPlayerField(int x, int y)
 541 {
 542   if (!IS_PLAYER(x, y))
 543     return;
 544
 545   DrawPlayer(PLAYERINFO(x, y));
 546 }
 547
 548 void DrawPlayer(struct PlayerInfo *player)
 549 {
 550 #if 0
 551   int jx = player->jx, jy = player->jy;
 552   int last_jx = player->last_jx, last_jy = player->last_jy;
 553   int next_jx = jx + (jx - last_jx), next_jy = jy + (jy - last_jy);
 554   int sx = SCREENX(jx), sy = SCREENY(jy);
 555   int sxx = 0, syy = 0;
 556   int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
 557   int graphic;
 558   int frame = 0;
 559   boolean player_is_moving = (last_jx != jx || last_jy != jy ? TRUE : FALSE);
 560   int move_dir = player->MovDir;
 561   int action = ACTION_DEFAULT;
 562 #else
 563   int jx = player->jx, jy = player->jy;
 564   int move_dir = player->MovDir;
 565   int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
 566   int dy = (move_dir == MV_UP   ? -1 : move_dir == MV_DOWN  ? +1 : 0);
 567   int last_jx = (player->is_moving ? jx - dx : jx);
 568   int last_jy = (player->is_moving ? jy - dy : jy);
 569   int next_jx = jx + dx;
 570   int next_jy = jy + dy;
 571   int sx = SCREENX(jx), sy = SCREENY(jy);
 572   int sxx = 0, syy = 0;
 573   int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
 574   int graphic;
 575   int frame = 0;
 576   boolean player_is_moving = (player->MovPos ? TRUE : FALSE);
 577   int action = ACTION_DEFAULT;
 578 #endif
 579
 580   if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
 581     return;
 582
 583 #if DEBUG
 584   if (!IN_LEV_FIELD(jx,jy))
 585   {
 586     printf("DrawPlayerField(): x = %d, y = %d\n",jx,jy);
 587     printf("DrawPlayerField(): sx = %d, sy = %d\n",sx,sy);
 588     printf("DrawPlayerField(): This should never happen!\n");
 589     return;
 590   }
 591 #endif
 592
 593   if (element == EL_EXPLOSION)
 594     return;
 595
 596   action = (player->Pushing ? ACTION_PUSHING :
 597             player->is_digging ? ACTION_DIGGING :
 598             player->is_collecting ? ACTION_COLLECTING :
 599             player->is_moving ? ACTION_MOVING :
 600             player->snapped ? ACTION_SNAPPING : ACTION_DEFAULT);
 601
 602 #if 0
 603   printf("::: '%s'\n", element_action_info[action].suffix);
 604 #endif
 605
 606   InitPlayerGfxAnimation(player, action, move_dir);
 607
 608   /* ----------------------------------------------------------------------- */
 609   /* draw things in the field the player is leaving, if needed               */
 610   /* ----------------------------------------------------------------------- */
 611
 612 #if 1
 613   if (player->is_moving)
 614 #else
 615   if (player_is_moving)
 616 #endif
 617   {
 618     if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
 619     {
 620       DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
 621
 622       if (last_element == EL_DYNAMITE_ACTIVE ||
 623           last_element == EL_SP_DISK_RED_ACTIVE)
 624         DrawDynamite(last_jx, last_jy);
 625       else
 626         DrawLevelFieldThruMask(last_jx, last_jy);
 627     }
 628     else if (last_element == EL_DYNAMITE_ACTIVE ||
 629              last_element == EL_SP_DISK_RED_ACTIVE)
 630       DrawDynamite(last_jx, last_jy);
 631     else
 632       DrawLevelField(last_jx, last_jy);
 633
 634     if (player->Pushing && IN_SCR_FIELD(SCREENX(next_jx), SCREENY(next_jy)))
 635     {
 636 #if 1
 637 #if 1
 638       DrawLevelElement(next_jx, next_jy, EL_EMPTY);
 639 #else
 640       if (player->GfxPos)
 641       {
 642         if (Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL)
 643           DrawLevelElement(next_jx, next_jy, EL_SOKOBAN_FIELD_EMPTY);
 644         else
 645           DrawLevelElement(next_jx, next_jy, EL_EMPTY);
 646       }
 647       else
 648         DrawLevelField(next_jx, next_jy);
 649 #endif
 650 #endif
 651     }
 652   }
 653
 654   if (!IN_SCR_FIELD(sx, sy))
 655     return;
 656
 657   if (setup.direct_draw)
 658     SetDrawtoField(DRAW_BUFFERED);
 659
 660   /* ----------------------------------------------------------------------- */
 661   /* draw things behind the player, if needed                                */
 662   /* ----------------------------------------------------------------------- */
 663
 664   if (Back[jx][jy])
 665     DrawLevelElement(jx, jy, Back[jx][jy]);
 666   else if (IS_ACTIVE_BOMB(element))
 667     DrawLevelElement(jx, jy, EL_EMPTY);
 668   else
 669   {
 670     if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
 671     {
 672 #if 1
 673       if (CAN_BE_CRUMBLED(GfxElement[jx][jy]))
 674         DrawLevelFieldCrumbledSandDigging(jx, jy, move_dir, player->StepFrame);
 675 #else
 676       if (GfxElement[jx][jy] == EL_SAND)
 677         DrawLevelFieldCrumbledSandDigging(jx, jy, move_dir, player->StepFrame);
 678 #endif
 679       else
 680       {
 681         int old_element = GfxElement[jx][jy];
 682         int old_graphic = el_act_dir2img(old_element, action, move_dir);
 683         int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
 684
 685         DrawGraphic(sx, sy, old_graphic, frame);
 686       }
 687     }
 688     else
 689     {
 690       GfxElement[jx][jy] = EL_UNDEFINED;
 691
 692       DrawLevelField(jx, jy);
 693     }
 694   }
 695
 696   /* ----------------------------------------------------------------------- */
 697   /* draw player himself                                                     */
 698   /* ----------------------------------------------------------------------- */
 699
 700   if (player->use_murphy_graphic)
 701   {
 702     static int last_horizontal_dir = MV_LEFT;
 703     int direction;
 704
 705     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
 706       last_horizontal_dir = move_dir;
 707
 708     direction = (player->snapped ? move_dir : last_horizontal_dir);
 709
 710     graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
 711   }
 712   else
 713     graphic = el_act_dir2img(player->element_nr, player->GfxAction, move_dir);
 714
 715   frame = getGraphicAnimationFrame(graphic, player->Frame);
 716
 717   if (player->GfxPos)
 718   {
 719     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
 720       sxx = player->GfxPos;
 721     else
 722       syy = player->GfxPos;
 723   }
 724
 725   if (!setup.soft_scrolling && ScreenMovPos)
 726     sxx = syy = 0;
 727
 728   DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
 729
 730   if (SHIELD_ON(player))
 731   {
 732     int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
 733                    IMG_SHIELD_NORMAL_ACTIVE);
 734     int frame = getGraphicAnimationFrame(graphic, -1);
 735
 736     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
 737   }
 738
 739   /* ----------------------------------------------------------------------- */
 740   /* draw things the player is pushing, if needed                            */
 741   /* ----------------------------------------------------------------------- */
 742
 743 #if 0
 744   printf("::: %d, %d [%d, %d] [%d]\n",
 745          player->Pushing, player_is_moving, player->GfxAction,
 746          player->is_moving, player_is_moving);
 747 #endif
 748
 749 #if 1
 750   if (player->Pushing && player->is_moving)
 751 #else
 752   if (player->Pushing && player_is_moving)
 753 #endif
 754   {
 755     int px = SCREENX(next_jx), py = SCREENY(next_jy);
 756
 757     if (Back[next_jx][next_jy])
 758       DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
 759
 760 #if 1
 761     if ((sxx || syy) && element == EL_SOKOBAN_OBJECT)
 762       DrawGraphicShiftedThruMask(px, py, sxx, syy, IMG_SOKOBAN_OBJECT, 0,
 763                                  NO_CUTTING);
 764 #else
 765     if ((sxx || syy) &&
 766         (element == EL_SOKOBAN_FIELD_EMPTY ||
 767          Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL))
 768       DrawGraphicShiftedThruMask(px, py, sxx, syy, IMG_SOKOBAN_OBJECT, 0,
 769                                  NO_CUTTING);
 770 #endif
 771     else
 772     {
 773 #if 1
 774       int element = MovingOrBlocked2Element(next_jx, next_jy);
 775 #else
 776 #if 1
 777       int element = Feld[jx][jy];
 778 #else
 779       int element = Feld[next_jx][next_jy];
 780 #endif
 781 #endif
 782
 783 #if 1
 784       int graphic = el2img(element);
 785       int frame = 0;
 786
 787 #if 0
 788       if ((sxx || syy) && IS_PUSHABLE(element))
 789 #endif
 790       {
 791         graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
 792         frame = getGraphicAnimationFrame(graphic, player->Frame);
 793       }
 794
 795 #if 0
 796       printf("::: pushing %d: %d ...\n", sxx, frame);
 797 #endif
 798
 799       DrawGraphicShifted(px, py, sxx, syy, graphic, frame,
 800                          NO_CUTTING, NO_MASKING);
 801 #endif
 802     }
 803   }
 804
 805   /* ----------------------------------------------------------------------- */
 806   /* draw things in front of player (active dynamite or dynabombs)           */
 807   /* ----------------------------------------------------------------------- */
 808
 809   if (IS_ACTIVE_BOMB(element))
 810   {
 811     graphic = el2img(element);
 812     frame = getGraphicAnimationFrame(graphic, GfxFrame[jx][jy]);
 813
 814     if (game.emulation == EMU_SUPAPLEX)
 815       DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
 816     else
 817       DrawGraphicThruMask(sx, sy, graphic, frame);
 818   }
 819
 820   if (player_is_moving && last_element == EL_EXPLOSION)
 821   {
 822 #if 1
 823     int graphic = el_act2img(GfxElement[last_jx][last_jy], ACTION_EXPLODING);
 824 #else
 825     int stored = Store[last_jx][last_jy];
 826     int graphic = (game.emulation != EMU_SUPAPLEX ? IMG_EXPLOSION :
 827                    stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
 828                    IMG_SP_EXPLOSION);
 829 #endif
 830     int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
 831     int phase = ExplodePhase[last_jx][last_jy] - 1;
 832     int frame = getGraphicAnimationFrame(graphic, phase - delay);
 833
 834     if (phase >= delay)
 835       DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
 836   }
 837
 838   /* ----------------------------------------------------------------------- */
 839   /* draw elements the player is just walking/passing through/under          */
 840   /* ----------------------------------------------------------------------- */
 841
 842   /* handle the field the player is leaving ... */
 843   if (player_is_moving && IS_ACCESSIBLE_INSIDE(last_element))
 844     DrawLevelField(last_jx, last_jy);
 845   else if (player_is_moving && IS_ACCESSIBLE_UNDER(last_element))
 846     DrawLevelFieldThruMask(last_jx, last_jy);
 847
 848   /* ... and the field the player is entering */
 849   if (IS_ACCESSIBLE_INSIDE(element))
 850     DrawLevelField(jx, jy);
 851   else if (IS_ACCESSIBLE_UNDER(element))
 852     DrawLevelFieldThruMask(jx, jy);
 853
 854   if (setup.direct_draw)
 855   {
 856     int dest_x = SX + SCREENX(MIN(jx, last_jx)) * TILEX;
 857     int dest_y = SY + SCREENY(MIN(jy, last_jy)) * TILEY;
 858     int x_size = TILEX * (1 + ABS(jx - last_jx));
 859     int y_size = TILEY * (1 + ABS(jy - last_jy));
 860
 861     BlitBitmap(drawto_field, window,
 862                dest_x, dest_y, x_size, y_size, dest_x, dest_y);
 863     SetDrawtoField(DRAW_DIRECT);
 864   }
 865
 866   MarkTileDirty(sx,sy);
 867 }
 868
 869 void getGraphicSource(int graphic, int frame, Bitmap **bitmap, int *x, int *y)
 870 {
 871   struct GraphicInfo *g = &graphic_info[graphic];
 872
 873   *bitmap = g->bitmap;
 874
 875   if (g->offset_y == 0)         /* frames are ordered horizontally */
 876   {
 877     int max_width = g->anim_frames_per_line * g->width;
 878
 879     *x = (g->src_x + frame * g->offset_x) % max_width;
 880     *y = g->src_y + (g->src_x + frame * g->offset_x) / max_width * g->height;
 881   }
 882   else if (g->offset_x == 0)    /* frames are ordered vertically */
 883   {
 884     int max_height = g->anim_frames_per_line * g->height;
 885
 886     *x = g->src_x + (g->src_y + frame * g->offset_y) / max_height * g->width;
 887     *y = (g->src_y + frame * g->offset_y) % max_height;
 888   }
 889   else                          /* frames are ordered diagonally */
 890   {
 891     *x = g->src_x + frame * g->offset_x;
 892     *y = g->src_y + frame * g->offset_y;
 893   }
 894 }
 895
 896 void DrawGraphic(int x, int y, int graphic, int frame)
 897 {
 898 #if DEBUG
 899   if (!IN_SCR_FIELD(x, y))
 900   {
 901     printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n", x, y, graphic);
 902     printf("DrawGraphic(): This should never happen!\n");
 903     return;
 904   }
 905 #endif
 906
 907   DrawGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic, frame);
 908   MarkTileDirty(x, y);
 909 }
 910
 911 void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
 912                     int frame)
 913 {
 914   Bitmap *src_bitmap;
 915   int src_x, src_y;
 916
 917   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
 918   BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
 919 }
 920
 921 void DrawGraphicThruMask(int x, int y, int graphic, int frame)
 922 {
 923 #if DEBUG
 924   if (!IN_SCR_FIELD(x, y))
 925   {
 926     printf("DrawGraphicThruMask(): x = %d,y = %d, graphic = %d\n",x,y,graphic);
 927     printf("DrawGraphicThruMask(): This should never happen!\n");
 928     return;
 929   }
 930 #endif
 931
 932   DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y *TILEY, graphic,
 933                          frame);
 934   MarkTileDirty(x, y);
 935 }
 936
 937 void DrawGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y, int graphic,
 938                             int frame)
 939 {
 940 #if 1
 941   Bitmap *src_bitmap;
 942   int src_x, src_y;
 943   GC drawing_gc;
 944
 945   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
 946   drawing_gc = src_bitmap->stored_clip_gc;
 947 #else
 948   GC drawing_gc = src_bitmap->stored_clip_gc;
 949   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
 950   int src_x = graphic_info[graphic].src_x;
 951   int src_y = graphic_info[graphic].src_y;
 952   int offset_x = graphic_info[graphic].offset_x;
 953   int offset_y = graphic_info[graphic].offset_y;
 954
 955   src_x += frame * offset_x;
 956   src_y += frame * offset_y;
 957
 958 #endif
 959
 960   SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
 961   BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dest_x, dest_y);
 962 }
 963
 964 void DrawMiniGraphic(int x, int y, int graphic)
 965 {
 966   DrawMiniGraphicExt(drawto, SX + x * MINI_TILEX,SY + y * MINI_TILEY, graphic);
 967   MarkTileDirty(x / 2, y / 2);
 968 }
 969
 970 void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
 971 {
 972   struct GraphicInfo *g = &graphic_info[graphic];
 973   int mini_startx = 0;
 974   int mini_starty = g->bitmap->height * 2 / 3;
 975
 976   *bitmap = g->bitmap;
 977   *x = mini_startx + g->src_x / 2;
 978   *y = mini_starty + g->src_y / 2;
 979 }
 980
 981 void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
 982 {
 983   Bitmap *src_bitmap;
 984   int src_x, src_y;
 985
 986   getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
 987   BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
 988 }
 989
 990 void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, int frame,
 991                         int cut_mode, int mask_mode)
 992 {
 993   Bitmap *src_bitmap;
 994   GC drawing_gc;
 995   int src_x, src_y;
 996   int width = TILEX, height = TILEY;
 997   int cx = 0, cy = 0;
 998   int dest_x, dest_y;
 999
1000   if (graphic < 0)
1001   {
1002     DrawGraphic(x, y, graphic, frame);
1003     return;
1004   }
1005
1006   if (dx || dy)                 /* shifted graphic */
1007   {
1008     if (x < BX1)                /* object enters playfield from the left */
1009     {
1010       x = BX1;
1011       width = dx;
1012       cx = TILEX - dx;
1013       dx = 0;
1014     }
1015     else if (x > BX2)           /* object enters playfield from the right */
1016     {
1017       x = BX2;
1018       width = -dx;
1019       dx = TILEX + dx;
1020     }
1021     else if (x==BX1 && dx < 0)  /* object leaves playfield to the left */
1022     {
1023       width += dx;
1024       cx = -dx;
1025       dx = 0;
1026     }
1027     else if (x==BX2 && dx > 0)  /* object leaves playfield to the right */
1028       width -= dx;
1029     else if (dx)                /* general horizontal movement */
1030       MarkTileDirty(x + SIGN(dx), y);
1031
1032     if (y < BY1)                /* object enters playfield from the top */
1033     {
1034       if (cut_mode==CUT_BELOW)  /* object completely above top border */
1035         return;
1036
1037       y = BY1;
1038       height = dy;
1039       cy = TILEY - dy;
1040       dy = 0;
1041     }
1042     else if (y > BY2)           /* object enters playfield from the bottom */
1043     {
1044       y = BY2;
1045       height = -dy;
1046       dy = TILEY + dy;
1047     }
1048     else if (y==BY1 && dy < 0)  /* object leaves playfield to the top */
1049     {
1050       height += dy;
1051       cy = -dy;
1052       dy = 0;
1053     }
1054     else if (dy > 0 && cut_mode == CUT_ABOVE)
1055     {
1056       if (y == BY2)             /* object completely above bottom border */
1057         return;
1058
1059       height = dy;
1060       cy = TILEY - dy;
1061       dy = TILEY;
1062       MarkTileDirty(x, y + 1);
1063     }                           /* object leaves playfield to the bottom */
1064     else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
1065       height -= dy;
1066     else if (dy)                /* general vertical movement */
1067       MarkTileDirty(x, y + SIGN(dy));
1068   }
1069
1070 #if 1
1071   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1072 #else
1073   src_bitmap = graphic_info[graphic].bitmap;
1074   src_x = graphic_info[graphic].src_x;
1075   src_y = graphic_info[graphic].src_y;
1076   offset_x = graphic_info[graphic].offset_x;
1077   offset_y = graphic_info[graphic].offset_y;
1078
1079   src_x += frame * offset_x;
1080   src_y += frame * offset_y;
1081 #endif
1082
1083   drawing_gc = src_bitmap->stored_clip_gc;
1084
1085   src_x += cx;
1086   src_y += cy;
1087
1088   dest_x = FX + x * TILEX + dx;
1089   dest_y = FY + y * TILEY + dy;
1090
1091 #if DEBUG
1092   if (!IN_SCR_FIELD(x,y))
1093   {
1094     printf("DrawGraphicShifted(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
1095     printf("DrawGraphicShifted(): This should never happen!\n");
1096     return;
1097   }
1098 #endif
1099
1100   if (mask_mode == USE_MASKING)
1101   {
1102     SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
1103     BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1104                      dest_x, dest_y);
1105   }
1106   else
1107     BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1108                dest_x, dest_y);
1109
1110   MarkTileDirty(x,y);
1111 }
1112
1113 void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy, int graphic,
1114                                 int frame, int cut_mode)
1115 {
1116   DrawGraphicShifted(x,y, dx,dy, graphic, frame, cut_mode, USE_MASKING);
1117 }
1118
1119 void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
1120                           int cut_mode, int mask_mode)
1121 {
1122   int lx = LEVELX(x), ly = LEVELY(y);
1123   int graphic;
1124   int frame;
1125
1126   if (IN_LEV_FIELD(lx, ly))
1127   {
1128     SetRandomAnimationValue(lx, ly);
1129
1130     graphic = el_act_dir2img(element, GfxAction[lx][ly], MovDir[lx][ly]);
1131     frame = getGraphicAnimationFrame(graphic, GfxFrame[lx][ly]);
1132   }
1133   else  /* border element */
1134   {
1135     graphic = el2img(element);
1136     frame = getGraphicAnimationFrame(graphic, -1);
1137   }
1138
1139   if (element == EL_EXPANDABLE_WALL)
1140   {
1141     boolean left_stopped = FALSE, right_stopped = FALSE;
1142
1143     if (!IN_LEV_FIELD(lx - 1, ly) || IS_WALL(Feld[lx - 1][ly]))
1144       left_stopped = TRUE;
1145     if (!IN_LEV_FIELD(lx + 1, ly) || IS_WALL(Feld[lx + 1][ly]))
1146       right_stopped = TRUE;
1147
1148     if (left_stopped && right_stopped)
1149       graphic = IMG_WALL;
1150     else if (left_stopped)
1151     {
1152       graphic = IMG_EXPANDABLE_WALL_GROWING_RIGHT;
1153       frame = graphic_info[graphic].anim_frames - 1;
1154     }
1155     else if (right_stopped)
1156     {
1157       graphic = IMG_EXPANDABLE_WALL_GROWING_LEFT;
1158       frame = graphic_info[graphic].anim_frames - 1;
1159     }
1160   }
1161
1162   if (dx || dy)
1163     DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
1164   else if (mask_mode == USE_MASKING)
1165     DrawGraphicThruMask(x, y, graphic, frame);
1166   else
1167     DrawGraphic(x, y, graphic, frame);
1168 }
1169
1170 void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
1171                          int cut_mode, int mask_mode)
1172 {
1173   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
1174     DrawScreenElementExt(SCREENX(x), SCREENY(y), dx, dy, element,
1175                          cut_mode, mask_mode);
1176 }
1177
1178 void DrawScreenElementShifted(int x, int y, int dx, int dy, int element,
1179                               int cut_mode)
1180 {
1181   DrawScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
1182 }
1183
1184 void DrawLevelElementShifted(int x, int y, int dx, int dy, int element,
1185                              int cut_mode)
1186 {
1187   DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
1188 }
1189
1190 void DrawLevelElementThruMask(int x, int y, int element)
1191 {
1192   DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
1193 }
1194
1195 void DrawLevelFieldThruMask(int x, int y)
1196 {
1197   DrawLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
1198 }
1199
1200 static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
1201 {
1202   Bitmap *src_bitmap;
1203   int src_x, src_y;
1204   int sx = SCREENX(x), sy = SCREENY(y);
1205   int element;
1206   int width, height, cx, cy, i;
1207   int snip = TILEX / 8; /* number of border pixels from "crumbled graphic" */
1208   static int xy[4][2] =
1209   {
1210     { 0, -1 },
1211     { -1, 0 },
1212     { +1, 0 },
1213     { 0, +1 }
1214   };
1215
1216   if (!IN_LEV_FIELD(x, y))
1217     return;
1218
1219   element = (GfxElement[x][y] != EL_UNDEFINED && Feld[x][y] != EL_EXPLOSION ?
1220              GfxElement[x][y] : Feld[x][y]);
1221
1222   /* crumble field itself */
1223   if (CAN_BE_CRUMBLED(element) && !IS_MOVING(x, y))
1224   {
1225     if (!IN_SCR_FIELD(sx, sy))
1226       return;
1227
1228     getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1229
1230     for(i=0; i<4; i++)
1231     {
1232       int xx = x + xy[i][0];
1233       int yy = y + xy[i][1];
1234
1235       element = (IN_LEV_FIELD(xx, yy) ? Feld[xx][yy] : BorderElement);
1236
1237       /* check if neighbour field is of same type */
1238       if (CAN_BE_CRUMBLED(element) && !IS_MOVING(xx, yy))
1239         continue;
1240
1241 #if 0
1242       if (Feld[x][y] == EL_CUSTOM_START + 123)
1243         printf("::: crumble [%d] THE CHAOS ENGINE (%d, %d): %d, %d\n",
1244                i, Feld[x][y], element,
1245                CAN_BE_CRUMBLED(element), IS_MOVING(x, y));
1246 #endif
1247
1248       if (i == 1 || i == 2)
1249       {
1250         width = snip;
1251         height = TILEY;
1252         cx = (i == 2 ? TILEX - snip : 0);
1253         cy = 0;
1254       }
1255       else
1256       {
1257         width = TILEX;
1258         height = snip;
1259         cx = 0;
1260         cy = (i == 3 ? TILEY - snip : 0);
1261       }
1262
1263       BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
1264                  width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy);
1265     }
1266
1267     MarkTileDirty(sx, sy);
1268   }
1269   else          /* crumble neighbour fields */
1270   {
1271     getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1272
1273     for(i=0; i<4; i++)
1274     {
1275       int xx = x + xy[i][0];
1276       int yy = y + xy[i][1];
1277       int sxx = sx + xy[i][0];
1278       int syy = sy + xy[i][1];
1279
1280       if (!IN_LEV_FIELD(xx, yy) ||
1281           !IN_SCR_FIELD(sxx, syy) ||
1282           !CAN_BE_CRUMBLED(Feld[xx][yy]) ||
1283           IS_MOVING(xx, yy))
1284         continue;
1285
1286       if (i == 1 || i == 2)
1287       {
1288         width = snip;
1289         height = TILEY;
1290         cx = (i == 1 ? TILEX - snip : 0);
1291         cy = 0;
1292       }
1293       else
1294       {
1295         width = TILEX;
1296         height = snip;
1297         cx = 0;
1298         cy = (i==0 ? TILEY-snip : 0);
1299       }
1300
1301       BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
1302                  width, height, FX + sxx * TILEX + cx, FY + syy * TILEY + cy);
1303
1304       MarkTileDirty(sxx, syy);
1305     }
1306   }
1307 }
1308
1309 void DrawLevelFieldCrumbledSand(int x, int y)
1310 {
1311   DrawLevelFieldCrumbledSandExt(x, y, IMG_SAND_CRUMBLED, 0);
1312 }
1313
1314 void DrawLevelFieldCrumbledSandDigging(int x, int y, int direction,
1315                                        int step_frame)
1316 {
1317 #if 1
1318   int graphic1 = el_act_dir2img(GfxElement[x][y], ACTION_DIGGING, direction);
1319   int graphic2 = el_act_dir2crm(GfxElement[x][y], ACTION_DIGGING, direction);
1320 #else
1321   int graphic1 = el_act_dir2img(EL_SAND,          ACTION_DIGGING, direction);
1322   int graphic2 = el_act_dir2img(EL_SAND_CRUMBLED, ACTION_DIGGING, direction);
1323 #endif
1324   int frame1 = getGraphicAnimationFrame(graphic1, step_frame);
1325   int frame2 = getGraphicAnimationFrame(graphic2, step_frame);
1326   int sx = SCREENX(x), sy = SCREENY(y);
1327
1328   DrawGraphic(sx, sy, graphic1, frame1);
1329   DrawLevelFieldCrumbledSandExt(x, y, graphic2, frame2);
1330 }
1331
1332 void DrawLevelFieldCrumbledSandNeighbours(int x, int y)
1333 {
1334   int sx = SCREENX(x), sy = SCREENY(y);
1335   static int xy[4][2] =
1336   {
1337     { 0, -1 },
1338     { -1, 0 },
1339     { +1, 0 },
1340     { 0, +1 }
1341   };
1342   int i;
1343
1344   for(i=0; i<4; i++)
1345   {
1346     int xx = x + xy[i][0];
1347     int yy = y + xy[i][1];
1348     int sxx = sx + xy[i][0];
1349     int syy = sy + xy[i][1];
1350
1351     if (!IN_LEV_FIELD(xx, yy) ||
1352         !IN_SCR_FIELD(sxx, syy) ||
1353         !CAN_BE_CRUMBLED(Feld[xx][yy]) ||
1354         IS_MOVING(xx, yy))
1355       continue;
1356
1357     DrawLevelField(xx, yy);
1358   }
1359 }
1360
1361 static int getBorderElement(int x, int y)
1362 {
1363   int border[7][2] =
1364   {
1365     { EL_STEELWALL_TOPLEFT,             EL_INVISIBLE_STEELWALL_TOPLEFT     },
1366     { EL_STEELWALL_TOPRIGHT,            EL_INVISIBLE_STEELWALL_TOPRIGHT    },
1367     { EL_STEELWALL_BOTTOMLEFT,          EL_INVISIBLE_STEELWALL_BOTTOMLEFT  },
1368     { EL_STEELWALL_BOTTOMRIGHT,         EL_INVISIBLE_STEELWALL_BOTTOMRIGHT },
1369     { EL_STEELWALL_VERTICAL,            EL_INVISIBLE_STEELWALL_VERTICAL    },
1370     { EL_STEELWALL_HORIZONTAL,          EL_INVISIBLE_STEELWALL_HORIZONTAL  },
1371     { EL_STEELWALL,                     EL_INVISIBLE_STEELWALL             }
1372   };
1373   int steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
1374   int steel_position = (x == -1 && y == -1                      ? 0 :
1375                         x == lev_fieldx && y == -1              ? 1 :
1376                         x == -1 && y == lev_fieldy              ? 2 :
1377                         x == lev_fieldx && y == lev_fieldy      ? 3 :
1378                         x == -1 || x == lev_fieldx              ? 4 :
1379                         y == -1 || y == lev_fieldy              ? 5 : 6);
1380
1381   return border[steel_position][steel_type];
1382 }
1383
1384 void DrawScreenElement(int x, int y, int element)
1385 {
1386   DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, NO_MASKING);
1387   DrawLevelFieldCrumbledSand(LEVELX(x), LEVELY(y));
1388 }
1389
1390 void DrawLevelElement(int x, int y, int element)
1391 {
1392   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
1393     DrawScreenElement(SCREENX(x), SCREENY(y), element);
1394 }
1395
1396 void DrawScreenField(int x, int y)
1397 {
1398   int lx = LEVELX(x), ly = LEVELY(y);
1399   int element, content;
1400
1401   if (!IN_LEV_FIELD(lx, ly))
1402   {
1403     if (lx < -1 || lx > lev_fieldx || ly < -1 || ly > lev_fieldy)
1404       element = EL_EMPTY;
1405     else
1406       element = getBorderElement(lx, ly);
1407
1408     DrawScreenElement(x, y, element);
1409     return;
1410   }
1411
1412   element = Feld[lx][ly];
1413   content = Store[lx][ly];
1414
1415   if (IS_MOVING(lx, ly))
1416   {
1417     int horiz_move = (MovDir[lx][ly] == MV_LEFT || MovDir[lx][ly] == MV_RIGHT);
1418     boolean cut_mode = NO_CUTTING;
1419
1420     if (element == EL_QUICKSAND_EMPTYING ||
1421         element == EL_MAGIC_WALL_EMPTYING ||
1422         element == EL_BD_MAGIC_WALL_EMPTYING ||
1423         element == EL_AMOEBA_DROPPING)
1424       cut_mode = CUT_ABOVE;
1425     else if (element == EL_QUICKSAND_FILLING ||
1426              element == EL_MAGIC_WALL_FILLING ||
1427              element == EL_BD_MAGIC_WALL_FILLING)
1428       cut_mode = CUT_BELOW;
1429
1430     if (cut_mode == CUT_ABOVE)
1431       DrawScreenElementShifted(x, y, 0, 0, element, NO_CUTTING);
1432     else
1433       DrawScreenElement(x, y, EL_EMPTY);
1434
1435     if (horiz_move)
1436       DrawScreenElementShifted(x, y, MovPos[lx][ly], 0, element, NO_CUTTING);
1437     else if (cut_mode == NO_CUTTING)
1438       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
1439     else
1440       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
1441
1442     if (content == EL_ACID)
1443       DrawLevelElementThruMask(lx, ly + 1, EL_ACID);
1444   }
1445   else if (IS_BLOCKED(lx, ly))
1446   {
1447     int oldx, oldy;
1448     int sx, sy;
1449     int horiz_move;
1450     boolean cut_mode = NO_CUTTING;
1451     int element_old, content_old;
1452
1453     Blocked2Moving(lx, ly, &oldx, &oldy);
1454     sx = SCREENX(oldx);
1455     sy = SCREENY(oldy);
1456     horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
1457                   MovDir[oldx][oldy] == MV_RIGHT);
1458
1459     element_old = Feld[oldx][oldy];
1460     content_old = Store[oldx][oldy];
1461
1462     if (element_old == EL_QUICKSAND_EMPTYING ||
1463         element_old == EL_MAGIC_WALL_EMPTYING ||
1464         element_old == EL_BD_MAGIC_WALL_EMPTYING ||
1465         element_old == EL_AMOEBA_DROPPING)
1466       cut_mode = CUT_ABOVE;
1467
1468     DrawScreenElement(x, y, EL_EMPTY);
1469
1470     if (horiz_move)
1471       DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
1472                                NO_CUTTING);
1473     else if (cut_mode == NO_CUTTING)
1474       DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old,
1475                                cut_mode);
1476     else
1477       DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old,
1478                                cut_mode);
1479   }
1480   else if (IS_DRAWABLE(element))
1481     DrawScreenElement(x, y, element);
1482   else
1483     DrawScreenElement(x, y, EL_EMPTY);
1484 }
1485
1486 void DrawLevelField(int x, int y)
1487 {
1488   if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
1489     DrawScreenField(SCREENX(x), SCREENY(y));
1490   else if (IS_MOVING(x, y))
1491   {
1492     int newx,newy;
1493
1494     Moving2Blocked(x, y, &newx, &newy);
1495     if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
1496       DrawScreenField(SCREENX(newx), SCREENY(newy));
1497   }
1498   else if (IS_BLOCKED(x, y))
1499   {
1500     int oldx, oldy;
1501
1502     Blocked2Moving(x, y, &oldx, &oldy);
1503     if (IN_SCR_FIELD(SCREENX(oldx), SCREENY(oldy)))
1504       DrawScreenField(SCREENX(oldx), SCREENY(oldy));
1505   }
1506 }
1507
1508 void DrawMiniElement(int x, int y, int element)
1509 {
1510   int graphic;
1511
1512   graphic = el2edimg(element);
1513   DrawMiniGraphic(x, y, graphic);
1514 }
1515
1516 void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
1517 {
1518   int x = sx + scroll_x, y = sy + scroll_y;
1519
1520   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
1521     DrawMiniElement(sx, sy, EL_EMPTY);
1522   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
1523     DrawMiniElement(sx, sy, Feld[x][y]);
1524   else
1525     DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
1526 }
1527
1528 void getMicroGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
1529 {
1530   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
1531   int mini_startx = src_bitmap->width * 3 / 4;
1532   int mini_starty = src_bitmap->height * 2 / 3;
1533   int src_x = mini_startx + graphic_info[graphic].src_x / 8;
1534   int src_y = mini_starty + graphic_info[graphic].src_y / 8;
1535
1536   *bitmap = src_bitmap;
1537   *x = src_x;
1538   *y = src_y;
1539 }
1540
1541 void DrawMicroElement(int xpos, int ypos, int element)
1542 {
1543   Bitmap *src_bitmap;
1544   int src_x, src_y;
1545   int graphic = el2preimg(element);
1546
1547   getMicroGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
1548   BlitBitmap(src_bitmap, drawto, src_x, src_y, MICRO_TILEX, MICRO_TILEY,
1549              xpos, ypos);
1550 }
1551
1552 void DrawLevel()
1553 {
1554   int x,y;
1555
1556   SetDrawBackgroundMask(REDRAW_NONE);
1557   ClearWindow();
1558
1559   for(x=BX1; x<=BX2; x++)
1560     for(y=BY1; y<=BY2; y++)
1561       DrawScreenField(x, y);
1562
1563   redraw_mask |= REDRAW_FIELD;
1564 }
1565
1566 void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
1567 {
1568   int x,y;
1569
1570   for(x=0; x<size_x; x++)
1571     for(y=0; y<size_y; y++)
1572       DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
1573
1574   redraw_mask |= REDRAW_FIELD;
1575 }
1576
1577 static void DrawMicroLevelExt(int xpos, int ypos, int from_x, int from_y)
1578 {
1579   int x, y;
1580
1581   DrawBackground(xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE);
1582
1583   if (lev_fieldx < STD_LEV_FIELDX)
1584     xpos += (STD_LEV_FIELDX - lev_fieldx) / 2 * MICRO_TILEX;
1585   if (lev_fieldy < STD_LEV_FIELDY)
1586     ypos += (STD_LEV_FIELDY - lev_fieldy) / 2 * MICRO_TILEY;
1587
1588   xpos += MICRO_TILEX;
1589   ypos += MICRO_TILEY;
1590
1591   for(x=-1; x<=STD_LEV_FIELDX; x++)
1592   {
1593     for(y=-1; y<=STD_LEV_FIELDY; y++)
1594     {
1595       int lx = from_x + x, ly = from_y + y;
1596
1597       if (lx >= 0 && lx < lev_fieldx && ly >= 0 && ly < lev_fieldy)
1598         DrawMicroElement(xpos + x * MICRO_TILEX, ypos + y * MICRO_TILEY,
1599                          level.field[lx][ly]);
1600       else if (lx >= -1 && lx < lev_fieldx+1 && ly >= -1 && ly < lev_fieldy+1
1601                && BorderElement != EL_EMPTY)
1602         DrawMicroElement(xpos + x * MICRO_TILEX, ypos + y * MICRO_TILEY,
1603                          getBorderElement(lx, ly));
1604     }
1605   }
1606
1607   redraw_mask |= REDRAW_MICROLEVEL;
1608 }
1609
1610 #define MICROLABEL_EMPTY                0
1611 #define MICROLABEL_LEVEL_NAME           1
1612 #define MICROLABEL_CREATED_BY           2
1613 #define MICROLABEL_LEVEL_AUTHOR         3
1614 #define MICROLABEL_IMPORTED_FROM        4
1615 #define MICROLABEL_LEVEL_IMPORT_INFO    5
1616
1617 static void DrawMicroLevelLabelExt(int mode)
1618 {
1619   char label_text[MAX_OUTPUT_LINESIZE + 1];
1620   int max_len_label_text;
1621   int font_nr = FONT_TEXT_2;
1622
1623   if (mode == MICROLABEL_CREATED_BY || mode == MICROLABEL_IMPORTED_FROM)
1624     font_nr = FONT_TEXT_3;
1625
1626   max_len_label_text = SXSIZE / getFontWidth(font_nr);
1627
1628   DrawBackground(SX, MICROLABEL_YPOS, SXSIZE, getFontHeight(font_nr));
1629
1630   strncpy(label_text, (mode == MICROLABEL_LEVEL_NAME ? level.name :
1631                        mode == MICROLABEL_CREATED_BY ? "created by" :
1632                        mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
1633                        mode == MICROLABEL_IMPORTED_FROM ? "imported from" :
1634                        mode == MICROLABEL_LEVEL_IMPORT_INFO ?
1635                        leveldir_current->imported_from : ""),
1636           max_len_label_text);
1637   label_text[max_len_label_text] = '\0';
1638
1639   if (strlen(label_text) > 0)
1640   {
1641     int lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
1642     int lypos = MICROLABEL_YPOS;
1643
1644     DrawText(lxpos, lypos, label_text, font_nr);
1645   }
1646
1647   redraw_mask |= REDRAW_MICROLEVEL;
1648 }
1649
1650 void DrawMicroLevel(int xpos, int ypos, boolean restart)
1651 {
1652   static unsigned long scroll_delay = 0;
1653   static unsigned long label_delay = 0;
1654   static int from_x, from_y, scroll_direction;
1655   static int label_state, label_counter;
1656   int last_game_status = game_status;   /* save current game status */
1657
1658   /* force PREVIEW font on preview level */
1659   game_status = GAME_MODE_PSEUDO_PREVIEW;
1660
1661   if (restart)
1662   {
1663     from_x = from_y = 0;
1664     scroll_direction = MV_RIGHT;
1665     label_state = 1;
1666     label_counter = 0;
1667
1668     DrawMicroLevelExt(xpos, ypos, from_x, from_y);
1669     DrawMicroLevelLabelExt(label_state);
1670
1671     /* initialize delay counters */
1672     DelayReached(&scroll_delay, 0);
1673     DelayReached(&label_delay, 0);
1674
1675     if (leveldir_current->name)
1676     {
1677       int text_width = getTextWidth(leveldir_current->name, FONT_TEXT_1);
1678       int lxpos = SX + (SXSIZE - text_width) / 2;
1679       int lypos = SY + 352;
1680
1681       DrawText(lxpos, lypos, leveldir_current->name, FONT_TEXT_1);
1682     }
1683
1684     game_status = last_game_status;     /* restore current game status */
1685
1686     return;
1687   }
1688
1689   /* scroll micro level, if needed */
1690   if ((lev_fieldx > STD_LEV_FIELDX || lev_fieldy > STD_LEV_FIELDY) &&
1691       DelayReached(&scroll_delay, MICROLEVEL_SCROLL_DELAY))
1692   {
1693     switch (scroll_direction)
1694     {
1695       case MV_LEFT:
1696         if (from_x > 0)
1697           from_x--;
1698         else
1699           scroll_direction = MV_UP;
1700         break;
1701
1702       case MV_RIGHT:
1703         if (from_x < lev_fieldx - STD_LEV_FIELDX)
1704           from_x++;
1705         else
1706           scroll_direction = MV_DOWN;
1707         break;
1708
1709       case MV_UP:
1710         if (from_y > 0)
1711           from_y--;
1712         else
1713           scroll_direction = MV_RIGHT;
1714         break;
1715
1716       case MV_DOWN:
1717         if (from_y < lev_fieldy - STD_LEV_FIELDY)
1718           from_y++;
1719         else
1720           scroll_direction = MV_LEFT;
1721         break;
1722
1723       default:
1724         break;
1725     }
1726
1727     DrawMicroLevelExt(xpos, ypos, from_x, from_y);
1728   }
1729
1730   /* redraw micro level label, if needed */
1731   if (strcmp(level.name, NAMELESS_LEVEL_NAME) != 0 &&
1732       strcmp(level.author, ANONYMOUS_NAME) != 0 &&
1733       strcmp(level.author, leveldir_current->name) != 0 &&
1734       DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
1735   {
1736     int max_label_counter = 23;
1737
1738     if (leveldir_current->imported_from != NULL)
1739       max_label_counter += 14;
1740
1741     label_counter = (label_counter + 1) % max_label_counter;
1742     label_state = (label_counter >= 0 && label_counter <= 7 ?
1743                    MICROLABEL_LEVEL_NAME :
1744                    label_counter >= 9 && label_counter <= 12 ?
1745                    MICROLABEL_CREATED_BY :
1746                    label_counter >= 14 && label_counter <= 21 ?
1747                    MICROLABEL_LEVEL_AUTHOR :
1748                    label_counter >= 23 && label_counter <= 26 ?
1749                    MICROLABEL_IMPORTED_FROM :
1750                    label_counter >= 28 && label_counter <= 35 ?
1751                    MICROLABEL_LEVEL_IMPORT_INFO : MICROLABEL_EMPTY);
1752     DrawMicroLevelLabelExt(label_state);
1753   }
1754
1755   game_status = last_game_status;       /* restore current game status */
1756 }
1757
1758 int REQ_in_range(int x, int y)
1759 {
1760   if (y > DY+249 && y < DY+278)
1761   {
1762     if (x > DX+1 && x < DX+48)
1763       return 1;
1764     else if (x > DX+51 && x < DX+98)
1765       return 2;
1766   }
1767   return 0;
1768 }
1769
1770 #define MAX_REQUEST_LINES               13
1771 #define MAX_REQUEST_LINE_LEN            7
1772
1773 boolean Request(char *text, unsigned int req_state)
1774 {
1775   int mx, my, ty, result = -1;
1776   unsigned int old_door_state;
1777   int last_game_status = game_status;   /* save current game status */
1778
1779 #if defined(PLATFORM_UNIX)
1780   /* pause network game while waiting for request to answer */
1781   if (options.network &&
1782       game_status == GAME_MODE_PLAYING &&
1783       req_state & REQUEST_WAIT_FOR)
1784     SendToServer_PausePlaying();
1785 #endif
1786
1787   old_door_state = GetDoorState();
1788
1789   /* simulate releasing mouse button over last gadget, if still pressed */
1790   if (button_status)
1791     HandleGadgets(-1, -1, 0);
1792
1793   UnmapAllGadgets();
1794
1795   CloseDoor(DOOR_CLOSE_1);
1796
1797   /* save old door content */
1798   BlitBitmap(bitmap_db_door, bitmap_db_door,
1799              DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
1800              DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1);
1801
1802   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
1803
1804   /* clear door drawing field */
1805   DrawBackground(DX, DY, DXSIZE, DYSIZE);
1806
1807   /* force DOOR font on preview level */
1808   game_status = GAME_MODE_PSEUDO_DOOR;
1809
1810   /* write text for request */
1811   for(ty=0; ty < MAX_REQUEST_LINES; ty++)
1812   {
1813     char text_line[MAX_REQUEST_LINE_LEN + 1];
1814     int tx, tl, tc;
1815
1816     if (!*text)
1817       break;
1818
1819     for(tl=0,tx=0; tx < MAX_REQUEST_LINE_LEN; tl++,tx++)
1820     {
1821       tc = *(text + tx);
1822       if (!tc || tc == ' ')
1823         break;
1824     }
1825
1826     if (!tl)
1827     {
1828       text++;
1829       ty--;
1830       continue;
1831     }
1832
1833     strncpy(text_line, text, tl);
1834     text_line[tl] = 0;
1835
1836     DrawText(DX + (DXSIZE - tl * getFontWidth(FONT_TEXT_2)) / 2,
1837              DY + 8 + ty * (getFontHeight(FONT_TEXT_2) + 2),
1838              text_line, FONT_TEXT_2);
1839
1840     text += tl + (tc == ' ' ? 1 : 0);
1841   }
1842
1843   game_status = last_game_status;       /* restore current game status */
1844
1845   if (req_state & REQ_ASK)
1846   {
1847     MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
1848     MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
1849   }
1850   else if (req_state & REQ_CONFIRM)
1851   {
1852     MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
1853   }
1854   else if (req_state & REQ_PLAYER)
1855   {
1856     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
1857     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
1858     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
1859     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
1860   }
1861
1862   /* copy request gadgets to door backbuffer */
1863   BlitBitmap(drawto, bitmap_db_door,
1864              DX, DY, DXSIZE, DYSIZE,
1865              DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
1866
1867   OpenDoor(DOOR_OPEN_1);
1868
1869 #if 0
1870   ClearEventQueue();
1871 #endif
1872
1873   if (!(req_state & REQUEST_WAIT_FOR))
1874   {
1875     SetDrawBackgroundMask(REDRAW_FIELD);
1876
1877     return FALSE;
1878   }
1879
1880   if (game_status != GAME_MODE_MAIN)
1881     InitAnimation();
1882
1883   button_status = MB_RELEASED;
1884
1885   request_gadget_id = -1;
1886
1887   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
1888
1889   SetMouseCursor(CURSOR_DEFAULT);
1890
1891   while(result < 0)
1892   {
1893     if (PendingEvent())
1894     {
1895       Event event;
1896
1897       NextEvent(&event);
1898
1899       switch(event.type)
1900       {
1901         case EVENT_BUTTONPRESS:
1902         case EVENT_BUTTONRELEASE:
1903         case EVENT_MOTIONNOTIFY:
1904         {
1905           if (event.type == EVENT_MOTIONNOTIFY)
1906           {
1907             if (!PointerInWindow(window))
1908               continue; /* window and pointer are on different screens */
1909
1910             if (!button_status)
1911               continue;
1912
1913             motion_status = TRUE;
1914             mx = ((MotionEvent *) &event)->x;
1915             my = ((MotionEvent *) &event)->y;
1916           }
1917           else
1918           {
1919             motion_status = FALSE;
1920             mx = ((ButtonEvent *) &event)->x;
1921             my = ((ButtonEvent *) &event)->y;
1922             if (event.type == EVENT_BUTTONPRESS)
1923               button_status = ((ButtonEvent *) &event)->button;
1924             else
1925               button_status = MB_RELEASED;
1926           }
1927
1928           /* this sets 'request_gadget_id' */
1929           HandleGadgets(mx, my, button_status);
1930
1931           switch(request_gadget_id)
1932           {
1933             case TOOL_CTRL_ID_YES:
1934               result = TRUE;
1935               break;
1936             case TOOL_CTRL_ID_NO:
1937               result = FALSE;
1938               break;
1939             case TOOL_CTRL_ID_CONFIRM:
1940               result = TRUE | FALSE;
1941               break;
1942
1943             case TOOL_CTRL_ID_PLAYER_1:
1944               result = 1;
1945               break;
1946             case TOOL_CTRL_ID_PLAYER_2:
1947               result = 2;
1948               break;
1949             case TOOL_CTRL_ID_PLAYER_3:
1950               result = 3;
1951               break;
1952             case TOOL_CTRL_ID_PLAYER_4:
1953               result = 4;
1954               break;
1955
1956             default:
1957               break;
1958           }
1959
1960           break;
1961         }
1962
1963         case EVENT_KEYPRESS:
1964           switch(GetEventKey((KeyEvent *)&event, TRUE))
1965           {
1966             case KSYM_Return:
1967               result = 1;
1968               break;
1969
1970             case KSYM_Escape:
1971               result = 0;
1972               break;
1973
1974             default:
1975               break;
1976           }
1977           if (req_state & REQ_PLAYER)
1978             result = 0;
1979           break;
1980
1981         case EVENT_KEYRELEASE:
1982           ClearPlayerAction();
1983           break;
1984
1985         default:
1986           HandleOtherEvents(&event);
1987           break;
1988       }
1989     }
1990     else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
1991     {
1992       int joy = AnyJoystick();
1993
1994       if (joy & JOY_BUTTON_1)
1995         result = 1;
1996       else if (joy & JOY_BUTTON_2)
1997         result = 0;
1998     }
1999
2000     DoAnimation();
2001
2002     /* don't eat all CPU time */
2003     Delay(10);
2004   }
2005
2006   if (game_status != GAME_MODE_MAIN)
2007     StopAnimation();
2008
2009   UnmapToolButtons();
2010
2011   if (!(req_state & REQ_STAY_OPEN))
2012   {
2013     CloseDoor(DOOR_CLOSE_1);
2014
2015     if (!(req_state & REQ_STAY_CLOSED) && (old_door_state & DOOR_OPEN_1))
2016     {
2017       BlitBitmap(bitmap_db_door, bitmap_db_door,
2018                  DOOR_GFX_PAGEX2,DOOR_GFX_PAGEY1, DXSIZE,DYSIZE,
2019                  DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY1);
2020       OpenDoor(DOOR_OPEN_1);
2021     }
2022   }
2023
2024   RemapAllGadgets();
2025
2026   SetDrawBackgroundMask(REDRAW_FIELD);
2027
2028 #if defined(PLATFORM_UNIX)
2029   /* continue network game after request */
2030   if (options.network &&
2031       game_status == GAME_MODE_PLAYING &&
2032       req_state & REQUEST_WAIT_FOR)
2033     SendToServer_ContinuePlaying();
2034 #endif
2035
2036   return result;
2037 }
2038
2039 unsigned int OpenDoor(unsigned int door_state)
2040 {
2041   unsigned int new_door_state;
2042
2043   if (door_state & DOOR_COPY_BACK)
2044   {
2045     BlitBitmap(bitmap_db_door, bitmap_db_door,
2046                DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE + VYSIZE,
2047                DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
2048     door_state &= ~DOOR_COPY_BACK;
2049   }
2050
2051   new_door_state = MoveDoor(door_state);
2052
2053   return(new_door_state);
2054 }
2055
2056 unsigned int CloseDoor(unsigned int door_state)
2057 {
2058   unsigned int new_door_state;
2059
2060   BlitBitmap(backbuffer, bitmap_db_door,
2061              DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
2062   BlitBitmap(backbuffer, bitmap_db_door,
2063              VX, VY, VXSIZE, VYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2);
2064
2065   new_door_state = MoveDoor(door_state);
2066
2067   return(new_door_state);
2068 }
2069
2070 unsigned int GetDoorState()
2071 {
2072   return MoveDoor(DOOR_GET_STATE);
2073 }
2074
2075 unsigned int SetDoorState(unsigned int door_state)
2076 {
2077   return MoveDoor(door_state | DOOR_SET_STATE);
2078 }
2079
2080 unsigned int MoveDoor(unsigned int door_state)
2081 {
2082   static int door1 = DOOR_OPEN_1;
2083   static int door2 = DOOR_CLOSE_2;
2084   static unsigned long door_delay = 0;
2085   int x, start, stepsize = door.step_offset;
2086   unsigned long door_delay_value = door.step_delay;
2087
2088   if (door_state == DOOR_GET_STATE)
2089     return(door1 | door2);
2090
2091   if (door_state & DOOR_SET_STATE)
2092   {
2093     if (door_state & DOOR_ACTION_1)
2094       door1 = door_state & DOOR_ACTION_1;
2095     if (door_state & DOOR_ACTION_2)
2096       door2 = door_state & DOOR_ACTION_2;
2097
2098     return(door1 | door2);
2099   }
2100
2101   if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
2102     door_state &= ~DOOR_OPEN_1;
2103   else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
2104     door_state &= ~DOOR_CLOSE_1;
2105   if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
2106     door_state &= ~DOOR_OPEN_2;
2107   else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
2108     door_state &= ~DOOR_CLOSE_2;
2109
2110   if (setup.quick_doors)
2111   {
2112     stepsize = 20;
2113     door_delay_value = 0;
2114
2115     StopSound(SND_DOOR_OPENING);
2116     StopSound(SND_DOOR_CLOSING);
2117   }
2118
2119   if (global.autoplay_leveldir)
2120   {
2121     door_state |= DOOR_NO_DELAY;
2122     door_state &= ~DOOR_CLOSE_ALL;
2123   }
2124
2125   if (door_state & DOOR_ACTION)
2126   {
2127     if (!(door_state & DOOR_NO_DELAY))
2128     {
2129       /* opening door sound has priority over simultaneously closing door */
2130       if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
2131         PlaySoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
2132       else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
2133         PlaySoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
2134     }
2135
2136     start = ((door_state & DOOR_NO_DELAY) ? DXSIZE : 0);
2137
2138     for(x=start; x<=DXSIZE; x+=stepsize)
2139     {
2140       Bitmap *bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2141       GC gc = bitmap->stored_clip_gc;
2142
2143       if (!(door_state & DOOR_NO_DELAY))
2144         WaitUntilDelayReached(&door_delay, door_delay_value);
2145
2146       if (door_state & DOOR_ACTION_1)
2147       {
2148         int i = (door_state & DOOR_OPEN_1 ? DXSIZE-x : x);
2149         int j = (DXSIZE - i) / 3;
2150
2151         BlitBitmap(bitmap_db_door, drawto,
2152                    DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1 + i/2,
2153                    DXSIZE,DYSIZE - i/2, DX, DY);
2154
2155         ClearRectangle(drawto, DX, DY + DYSIZE - i/2, DXSIZE,i/2);
2156
2157         SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
2158         BlitBitmapMasked(bitmap, drawto,
2159                          DXSIZE, DOOR_GFX_PAGEY1, i, 77,
2160                          DX + DXSIZE - i, DY + j);
2161         BlitBitmapMasked(bitmap, drawto,
2162                          DXSIZE, DOOR_GFX_PAGEY1 + 140, i, 63,
2163                          DX + DXSIZE - i, DY + 140 + j);
2164         SetClipOrigin(bitmap, gc, DX - DXSIZE + i, DY - (DOOR_GFX_PAGEY1 + j));
2165         BlitBitmapMasked(bitmap, drawto,
2166                          DXSIZE - i, DOOR_GFX_PAGEY1 + j, i, 77 - j,
2167                          DX, DY);
2168         BlitBitmapMasked(bitmap, drawto,
2169                          DXSIZE-i, DOOR_GFX_PAGEY1 + 140, i, 63,
2170                          DX, DY + 140 - j);
2171
2172         BlitBitmapMasked(bitmap, drawto,
2173                          DXSIZE - i, DOOR_GFX_PAGEY1 + 77, i, 63,
2174                          DX, DY + 77 - j);
2175         BlitBitmapMasked(bitmap, drawto,
2176                          DXSIZE - i, DOOR_GFX_PAGEY1 + 203, i, 77,
2177                          DX, DY + 203 - j);
2178         SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
2179         BlitBitmapMasked(bitmap, drawto,
2180                          DXSIZE, DOOR_GFX_PAGEY1 + 77, i, 63,
2181                          DX + DXSIZE - i, DY + 77 + j);
2182         BlitBitmapMasked(bitmap, drawto,
2183                          DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j,
2184                          DX + DXSIZE - i, DY + 203 + j);
2185
2186         redraw_mask |= REDRAW_DOOR_1;
2187       }
2188
2189       if (door_state & DOOR_ACTION_2)
2190       {
2191         int i = (door_state & DOOR_OPEN_2 ? VXSIZE - x : x);
2192         int j = (VXSIZE - i) / 3;
2193
2194         BlitBitmap(bitmap_db_door, drawto,
2195                    DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2 + i/2,
2196                    VXSIZE, VYSIZE - i/2, VX, VY);
2197
2198         ClearRectangle(drawto, VX, VY + VYSIZE-i/2, VXSIZE, i/2);
2199
2200         SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
2201         BlitBitmapMasked(bitmap, drawto,
2202                          VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2,
2203                          VX + VXSIZE-i, VY+j);
2204         SetClipOrigin(bitmap, gc,
2205                       VX - VXSIZE + i, VY - (DOOR_GFX_PAGEY2 + j));
2206         BlitBitmapMasked(bitmap, drawto,
2207                          VXSIZE - i, DOOR_GFX_PAGEY2 + j, i, VYSIZE / 2 - j,
2208                          VX, VY);
2209
2210         BlitBitmapMasked(bitmap, drawto,
2211                          VXSIZE - i, DOOR_GFX_PAGEY2 + VYSIZE / 2,
2212                          i, VYSIZE / 2, VX, VY + VYSIZE / 2 - j);
2213         SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
2214         BlitBitmapMasked(bitmap, drawto,
2215                          VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2,
2216                          i, VYSIZE / 2 - j,
2217                          VX + VXSIZE - i, VY + VYSIZE / 2 + j);
2218
2219         redraw_mask |= REDRAW_DOOR_2;
2220       }
2221
2222       BackToFront();
2223
2224       if (game_status == GAME_MODE_MAIN)
2225         DoAnimation();
2226     }
2227   }
2228
2229   if (setup.quick_doors)
2230   {
2231     StopSound(SND_DOOR_OPENING);
2232     StopSound(SND_DOOR_CLOSING);
2233   }
2234
2235   if (door_state & DOOR_ACTION_1)
2236     door1 = door_state & DOOR_ACTION_1;
2237   if (door_state & DOOR_ACTION_2)
2238     door2 = door_state & DOOR_ACTION_2;
2239
2240   return (door1 | door2);
2241 }
2242
2243 void DrawSpecialEditorDoor()
2244 {
2245   /* draw bigger toolbox window */
2246   BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
2247              DOOR_GFX_PAGEX7, 0, EXSIZE + 8, 8,
2248              EX - 4, EY - 12);
2249   BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
2250              EX - 4, VY - 4, EXSIZE + 8, EYSIZE - VYSIZE + 4,
2251              EX - 4, EY - 4);
2252
2253   redraw_mask |= REDRAW_ALL;
2254 }
2255
2256 void UndrawSpecialEditorDoor()
2257 {
2258   /* draw normal tape recorder window */
2259   BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
2260              EX - 4, EY - 12, EXSIZE + 8, EYSIZE - VYSIZE + 12,
2261              EX - 4, EY - 12);
2262
2263   redraw_mask |= REDRAW_ALL;
2264 }
2265
2266
2267 /* ---------- new tool button stuff ---------------------------------------- */
2268
2269 /* graphic position values for tool buttons */
2270 #define TOOL_BUTTON_YES_XPOS            2
2271 #define TOOL_BUTTON_YES_YPOS            250
2272 #define TOOL_BUTTON_YES_GFX_YPOS        0
2273 #define TOOL_BUTTON_YES_XSIZE           46
2274 #define TOOL_BUTTON_YES_YSIZE           28
2275 #define TOOL_BUTTON_NO_XPOS             52
2276 #define TOOL_BUTTON_NO_YPOS             TOOL_BUTTON_YES_YPOS
2277 #define TOOL_BUTTON_NO_GFX_YPOS         TOOL_BUTTON_YES_GFX_YPOS
2278 #define TOOL_BUTTON_NO_XSIZE            TOOL_BUTTON_YES_XSIZE
2279 #define TOOL_BUTTON_NO_YSIZE            TOOL_BUTTON_YES_YSIZE
2280 #define TOOL_BUTTON_CONFIRM_XPOS        TOOL_BUTTON_YES_XPOS
2281 #define TOOL_BUTTON_CONFIRM_YPOS        TOOL_BUTTON_YES_YPOS
2282 #define TOOL_BUTTON_CONFIRM_GFX_YPOS    30
2283 #define TOOL_BUTTON_CONFIRM_XSIZE       96
2284 #define TOOL_BUTTON_CONFIRM_YSIZE       TOOL_BUTTON_YES_YSIZE
2285 #define TOOL_BUTTON_PLAYER_XSIZE        30
2286 #define TOOL_BUTTON_PLAYER_YSIZE        30
2287 #define TOOL_BUTTON_PLAYER_GFX_XPOS     5
2288 #define TOOL_BUTTON_PLAYER_GFX_YPOS     185
2289 #define TOOL_BUTTON_PLAYER_XPOS         (5 + TOOL_BUTTON_PLAYER_XSIZE / 2)
2290 #define TOOL_BUTTON_PLAYER_YPOS         (215 - TOOL_BUTTON_PLAYER_YSIZE / 2)
2291 #define TOOL_BUTTON_PLAYER1_XPOS        (TOOL_BUTTON_PLAYER_XPOS \
2292                                          + 0 * TOOL_BUTTON_PLAYER_XSIZE)
2293 #define TOOL_BUTTON_PLAYER2_XPOS        (TOOL_BUTTON_PLAYER_XPOS \
2294                                          + 1 * TOOL_BUTTON_PLAYER_XSIZE)
2295 #define TOOL_BUTTON_PLAYER3_XPOS        (TOOL_BUTTON_PLAYER_XPOS \
2296                                          + 0 * TOOL_BUTTON_PLAYER_XSIZE)
2297 #define TOOL_BUTTON_PLAYER4_XPOS        (TOOL_BUTTON_PLAYER_XPOS \
2298                                          + 1 * TOOL_BUTTON_PLAYER_XSIZE)
2299 #define TOOL_BUTTON_PLAYER1_YPOS        (TOOL_BUTTON_PLAYER_YPOS \
2300                                          + 0 * TOOL_BUTTON_PLAYER_YSIZE)
2301 #define TOOL_BUTTON_PLAYER2_YPOS        (TOOL_BUTTON_PLAYER_YPOS \
2302                                          + 0 * TOOL_BUTTON_PLAYER_YSIZE)
2303 #define TOOL_BUTTON_PLAYER3_YPOS        (TOOL_BUTTON_PLAYER_YPOS \
2304                                          + 1 * TOOL_BUTTON_PLAYER_YSIZE)
2305 #define TOOL_BUTTON_PLAYER4_YPOS        (TOOL_BUTTON_PLAYER_YPOS \
2306                                          + 1 * TOOL_BUTTON_PLAYER_YSIZE)
2307
2308 static struct
2309 {
2310   int xpos, ypos;
2311   int x, y;
2312   int width, height;
2313   int gadget_id;
2314   char *infotext;
2315 } toolbutton_info[NUM_TOOL_BUTTONS] =
2316 {
2317   {
2318     TOOL_BUTTON_YES_XPOS,       TOOL_BUTTON_YES_GFX_YPOS,
2319     TOOL_BUTTON_YES_XPOS,       TOOL_BUTTON_YES_YPOS,
2320     TOOL_BUTTON_YES_XSIZE,      TOOL_BUTTON_YES_YSIZE,
2321     TOOL_CTRL_ID_YES,
2322     "yes"
2323   },
2324   {
2325     TOOL_BUTTON_NO_XPOS,        TOOL_BUTTON_NO_GFX_YPOS,
2326     TOOL_BUTTON_NO_XPOS,        TOOL_BUTTON_NO_YPOS,
2327     TOOL_BUTTON_NO_XSIZE,       TOOL_BUTTON_NO_YSIZE,
2328     TOOL_CTRL_ID_NO,
2329     "no"
2330   },
2331   {
2332     TOOL_BUTTON_CONFIRM_XPOS,   TOOL_BUTTON_CONFIRM_GFX_YPOS,
2333     TOOL_BUTTON_CONFIRM_XPOS,   TOOL_BUTTON_CONFIRM_YPOS,
2334     TOOL_BUTTON_CONFIRM_XSIZE,  TOOL_BUTTON_CONFIRM_YSIZE,
2335     TOOL_CTRL_ID_CONFIRM,
2336     "confirm"
2337   },
2338   {
2339     TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
2340     TOOL_BUTTON_PLAYER1_XPOS,   TOOL_BUTTON_PLAYER1_YPOS,
2341     TOOL_BUTTON_PLAYER_XSIZE,   TOOL_BUTTON_PLAYER_YSIZE,
2342     TOOL_CTRL_ID_PLAYER_1,
2343     "player 1"
2344   },
2345   {
2346     TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
2347     TOOL_BUTTON_PLAYER2_XPOS,   TOOL_BUTTON_PLAYER2_YPOS,
2348     TOOL_BUTTON_PLAYER_XSIZE,   TOOL_BUTTON_PLAYER_YSIZE,
2349     TOOL_CTRL_ID_PLAYER_2,
2350     "player 2"
2351   },
2352   {
2353     TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
2354     TOOL_BUTTON_PLAYER3_XPOS,   TOOL_BUTTON_PLAYER3_YPOS,
2355     TOOL_BUTTON_PLAYER_XSIZE,   TOOL_BUTTON_PLAYER_YSIZE,
2356     TOOL_CTRL_ID_PLAYER_3,
2357     "player 3"
2358   },
2359   {
2360     TOOL_BUTTON_PLAYER_GFX_XPOS,TOOL_BUTTON_PLAYER_GFX_YPOS,
2361     TOOL_BUTTON_PLAYER4_XPOS,   TOOL_BUTTON_PLAYER4_YPOS,
2362     TOOL_BUTTON_PLAYER_XSIZE,   TOOL_BUTTON_PLAYER_YSIZE,
2363     TOOL_CTRL_ID_PLAYER_4,
2364     "player 4"
2365   }
2366 };
2367
2368 void CreateToolButtons()
2369 {
2370   int i;
2371
2372   for (i=0; i<NUM_TOOL_BUTTONS; i++)
2373   {
2374     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
2375     Bitmap *deco_bitmap = None;
2376     int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
2377     struct GadgetInfo *gi;
2378     unsigned long event_mask;
2379     int gd_xoffset, gd_yoffset;
2380     int gd_x1, gd_x2, gd_y;
2381     int id = i;
2382
2383     event_mask = GD_EVENT_RELEASED;
2384
2385     gd_xoffset = toolbutton_info[i].xpos;
2386     gd_yoffset = toolbutton_info[i].ypos;
2387     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
2388     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
2389     gd_y = DOOR_GFX_PAGEY1 + gd_yoffset;
2390
2391     if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
2392     {
2393       int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
2394
2395       getMiniGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr),
2396                            &deco_bitmap, &deco_x, &deco_y);
2397       deco_xpos = (toolbutton_info[i].width - MINI_TILEX) / 2;
2398       deco_ypos = (toolbutton_info[i].height - MINI_TILEY) / 2;
2399     }
2400
2401     gi = CreateGadget(GDI_CUSTOM_ID, id,
2402                       GDI_INFO_TEXT, toolbutton_info[i].infotext,
2403                       GDI_X, DX + toolbutton_info[i].x,
2404                       GDI_Y, DY + toolbutton_info[i].y,
2405                       GDI_WIDTH, toolbutton_info[i].width,
2406                       GDI_HEIGHT, toolbutton_info[i].height,
2407                       GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
2408                       GDI_STATE, GD_BUTTON_UNPRESSED,
2409                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y,
2410                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y,
2411                       GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
2412                       GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
2413                       GDI_DECORATION_SIZE, MINI_TILEX, MINI_TILEY,
2414                       GDI_DECORATION_SHIFTING, 1, 1,
2415                       GDI_EVENT_MASK, event_mask,
2416                       GDI_CALLBACK_ACTION, HandleToolButtons,
2417                       GDI_END);
2418
2419     if (gi == NULL)
2420       Error(ERR_EXIT, "cannot create gadget");
2421
2422     tool_gadget[id] = gi;
2423   }
2424 }
2425
2426 void FreeToolButtons()
2427 {
2428   int i;
2429
2430   for (i=0; i<NUM_TOOL_BUTTONS; i++)
2431     FreeGadget(tool_gadget[i]);
2432 }
2433
2434 static void UnmapToolButtons()
2435 {
2436   int i;
2437
2438   for (i=0; i<NUM_TOOL_BUTTONS; i++)
2439     UnmapGadget(tool_gadget[i]);
2440 }
2441
2442 static void HandleToolButtons(struct GadgetInfo *gi)
2443 {
2444   request_gadget_id = gi->custom_id;
2445 }
2446
2447 int get_next_element(int element)
2448 {
2449   switch(element)
2450   {
2451     case EL_QUICKSAND_FILLING:          return EL_QUICKSAND_FULL;
2452     case EL_QUICKSAND_EMPTYING:         return EL_QUICKSAND_EMPTY;
2453     case EL_MAGIC_WALL_FILLING:         return EL_MAGIC_WALL_FULL;
2454     case EL_MAGIC_WALL_EMPTYING:        return EL_MAGIC_WALL_ACTIVE;
2455     case EL_BD_MAGIC_WALL_FILLING:      return EL_BD_MAGIC_WALL_FULL;
2456     case EL_BD_MAGIC_WALL_EMPTYING:     return EL_BD_MAGIC_WALL_ACTIVE;
2457     case EL_AMOEBA_DROPPING:            return EL_AMOEBA_WET;
2458
2459     default:                            return element;
2460   }
2461 }
2462
2463 int el_act_dir2img(int element, int action, int direction)
2464 {
2465   element = GFX_ELEMENT(element);
2466   direction = MV_DIR_BIT(direction);
2467
2468   return element_info[element].direction_graphic[action][direction];
2469 }
2470
2471 static int el_act_dir2crm(int element, int action, int direction)
2472 {
2473   element = GFX_ELEMENT(element);
2474   direction = MV_DIR_BIT(direction);
2475
2476   return element_info[element].direction_crumbled[action][direction];
2477 }
2478
2479 int el_act2img(int element, int action)
2480 {
2481   element = GFX_ELEMENT(element);
2482
2483   return element_info[element].graphic[action];
2484 }
2485
2486 int el_dir2img(int element, int direction)
2487 {
2488   element = GFX_ELEMENT(element);
2489
2490   return el_act_dir2img(element, ACTION_DEFAULT, direction);
2491 }
2492
2493 int el2img(int element)
2494 {
2495   element = GFX_ELEMENT(element);
2496
2497   return element_info[element].graphic[ACTION_DEFAULT];
2498 }
2499
2500 int el2edimg(int element)
2501 {
2502   element = GFX_ELEMENT(element);
2503
2504   return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
2505 }
2506
2507 int el2preimg(int element)
2508 {
2509   element = GFX_ELEMENT(element);
2510
2511   return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
2512 }