src/tools.c

   1 // ============================================================================
   2 // Rocks'n'Diamonds - McDuffin Strikes Back!
   3 // ----------------------------------------------------------------------------
   4 // (c) 1995-2014 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  http://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // tools.c
  10 // ============================================================================
  11
  12 #include <math.h>
  13
  14 #include "libgame/libgame.h"
  15
  16 #include "tools.h"
  17 #include "init.h"
  18 #include "game.h"
  19 #include "events.h"
  20 #include "anim.h"
  21 #include "network.h"
  22 #include "tape.h"
  23 #include "screens.h"
  24
  25
  26 /* select level set with EMC X11 graphics before activating EM GFX debugging */
  27 #define DEBUG_EM_GFX            FALSE
  28 #define DEBUG_FRAME_TIME        FALSE
  29
  30 /* tool button identifiers */
  31 #define TOOL_CTRL_ID_YES        0
  32 #define TOOL_CTRL_ID_NO         1
  33 #define TOOL_CTRL_ID_CONFIRM    2
  34 #define TOOL_CTRL_ID_PLAYER_1   3
  35 #define TOOL_CTRL_ID_PLAYER_2   4
  36 #define TOOL_CTRL_ID_PLAYER_3   5
  37 #define TOOL_CTRL_ID_PLAYER_4   6
  38
  39 #define NUM_TOOL_BUTTONS        7
  40
  41 /* constants for number of doors and door parts */
  42 #define NUM_DOORS               2
  43 #define NUM_PANELS              NUM_DOORS
  44 // #define NUM_PANELS           0
  45 #define MAX_PARTS_PER_DOOR      8
  46 #define MAX_DOOR_PARTS          (NUM_DOORS * MAX_PARTS_PER_DOOR + NUM_PANELS)
  47 #define DOOR_PART_IS_PANEL(i)   ((i) >= NUM_DOORS * MAX_PARTS_PER_DOOR)
  48
  49
  50 struct DoorPartOrderInfo
  51 {
  52   int nr;
  53   int sort_priority;
  54 };
  55
  56 static struct DoorPartOrderInfo door_part_order[MAX_DOOR_PARTS];
  57
  58 struct DoorPartControlInfo
  59 {
  60   int door_token;
  61   int graphic;
  62   struct DoorPartPosInfo *pos;
  63 };
  64
  65 static struct DoorPartControlInfo door_part_controls[] =
  66 {
  67   {
  68     DOOR_1,
  69     IMG_GFX_DOOR_1_PART_1,
  70     &door_1.part_1
  71   },
  72   {
  73     DOOR_1,
  74     IMG_GFX_DOOR_1_PART_2,
  75     &door_1.part_2
  76   },
  77   {
  78     DOOR_1,
  79     IMG_GFX_DOOR_1_PART_3,
  80     &door_1.part_3
  81   },
  82   {
  83     DOOR_1,
  84     IMG_GFX_DOOR_1_PART_4,
  85     &door_1.part_4
  86   },
  87   {
  88     DOOR_1,
  89     IMG_GFX_DOOR_1_PART_5,
  90     &door_1.part_5
  91   },
  92   {
  93     DOOR_1,
  94     IMG_GFX_DOOR_1_PART_6,
  95     &door_1.part_6
  96   },
  97   {
  98     DOOR_1,
  99     IMG_GFX_DOOR_1_PART_7,
 100     &door_1.part_7
 101   },
 102   {
 103     DOOR_1,
 104     IMG_GFX_DOOR_1_PART_8,
 105     &door_1.part_8
 106   },
 107
 108   {
 109     DOOR_2,
 110     IMG_GFX_DOOR_2_PART_1,
 111     &door_2.part_1
 112   },
 113   {
 114     DOOR_2,
 115     IMG_GFX_DOOR_2_PART_2,
 116     &door_2.part_2
 117   },
 118   {
 119     DOOR_2,
 120     IMG_GFX_DOOR_2_PART_3,
 121     &door_2.part_3
 122   },
 123   {
 124     DOOR_2,
 125     IMG_GFX_DOOR_2_PART_4,
 126     &door_2.part_4
 127   },
 128   {
 129     DOOR_2,
 130     IMG_GFX_DOOR_2_PART_5,
 131     &door_2.part_5
 132   },
 133   {
 134     DOOR_2,
 135     IMG_GFX_DOOR_2_PART_6,
 136     &door_2.part_6
 137   },
 138   {
 139     DOOR_2,
 140     IMG_GFX_DOOR_2_PART_7,
 141     &door_2.part_7
 142   },
 143   {
 144     DOOR_2,
 145     IMG_GFX_DOOR_2_PART_8,
 146     &door_2.part_8
 147   },
 148
 149   {
 150     DOOR_1,
 151     IMG_BACKGROUND_PANEL,
 152     &door_1.panel
 153   },
 154   {
 155     DOOR_2,
 156     IMG_BACKGROUND_TAPE,
 157     &door_2.panel
 158   },
 159
 160   {
 161     -1,
 162     -1,
 163     NULL
 164   }
 165 };
 166
 167
 168 /* forward declaration for internal use */
 169 static void UnmapToolButtons();
 170 static void HandleToolButtons(struct GadgetInfo *);
 171 static int el_act_dir2crm(int, int, int);
 172 static int el_act2crm(int, int);
 173
 174 static struct GadgetInfo *tool_gadget[NUM_TOOL_BUTTONS];
 175 static int request_gadget_id = -1;
 176
 177 static char *print_if_not_empty(int element)
 178 {
 179   static char *s = NULL;
 180   char *token_name = element_info[element].token_name;
 181
 182   if (s != NULL)
 183     free(s);
 184
 185   s = checked_malloc(strlen(token_name) + 10 + 1);
 186
 187   if (element != EL_EMPTY)
 188     sprintf(s, "%d\t['%s']", element, token_name);
 189   else
 190     sprintf(s, "%d", element);
 191
 192   return s;
 193 }
 194
 195 int correctLevelPosX_EM(int lx)
 196 {
 197   lx -= 1;
 198   lx -= (BorderElement != EL_EMPTY ? 1 : 0);
 199
 200   return lx;
 201 }
 202
 203 int correctLevelPosY_EM(int ly)
 204 {
 205   ly -= 1;
 206   ly -= (BorderElement != EL_EMPTY ? 1 : 0);
 207
 208   return ly;
 209 }
 210
 211 static int getFieldbufferOffsetX_RND()
 212 {
 213   int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
 214   int dx = (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0);
 215   int dx_var = dx * TILESIZE_VAR / TILESIZE;
 216   int fx = FX;
 217
 218   if (EVEN(SCR_FIELDX))
 219   {
 220     int ffx = (scroll_x - SBX_Left)  * TILEX_VAR + dx_var;
 221
 222     if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + TILEX_VAR)
 223       fx += dx_var - MIN(ffx, TILEX_VAR / 2) + TILEX_VAR;
 224     else
 225       fx += (dx_var > 0 ? TILEX_VAR : 0);
 226   }
 227   else
 228   {
 229     fx += dx_var;
 230   }
 231
 232   if (full_lev_fieldx <= SCR_FIELDX)
 233   {
 234     if (EVEN(SCR_FIELDX))
 235       fx = 2 * TILEX_VAR - (ODD(lev_fieldx)  ? TILEX_VAR / 2 : 0);
 236     else
 237       fx = 2 * TILEX_VAR - (EVEN(lev_fieldx) ? TILEX_VAR / 2 : 0);
 238   }
 239
 240   return fx;
 241 }
 242
 243 static int getFieldbufferOffsetY_RND()
 244 {
 245   int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
 246   int dy = (ScreenMovDir & (MV_UP | MV_DOWN)    ? ScreenGfxPos : 0);
 247   int dy_var = dy * TILESIZE_VAR / TILESIZE;
 248   int fy = FY;
 249
 250   if (EVEN(SCR_FIELDY))
 251   {
 252     int ffy = (scroll_y - SBY_Upper) * TILEY_VAR + dy_var;
 253
 254     if (ffy < SBY_Lower * TILEY_VAR + TILEY_VAR / 2 + TILEY_VAR)
 255       fy += dy_var - MIN(ffy, TILEY_VAR / 2) + TILEY_VAR;
 256     else
 257       fy += (dy_var > 0 ? TILEY_VAR : 0);
 258   }
 259   else
 260   {
 261     fy += dy_var;
 262   }
 263
 264   if (full_lev_fieldy <= SCR_FIELDY)
 265   {
 266     if (EVEN(SCR_FIELDY))
 267       fy = 2 * TILEY_VAR - (ODD(lev_fieldy)  ? TILEY_VAR / 2 : 0);
 268     else
 269       fy = 2 * TILEY_VAR - (EVEN(lev_fieldy) ? TILEY_VAR / 2 : 0);
 270   }
 271
 272   return fy;
 273 }
 274
 275 static int getLevelFromScreenX_RND(int sx)
 276 {
 277   int fx = getFieldbufferOffsetX_RND();
 278   int dx = fx - FX;
 279   int px = sx - SX;
 280   int lx = LEVELX((px + dx) / TILESIZE_VAR);
 281
 282   return lx;
 283 }
 284
 285 static int getLevelFromScreenY_RND(int sy)
 286 {
 287   int fy = getFieldbufferOffsetY_RND();
 288   int dy = fy - FY;
 289   int py = sy - SY;
 290   int ly = LEVELY((py + dy) / TILESIZE_VAR);
 291
 292   return ly;
 293 }
 294
 295 static int getLevelFromScreenX_EM(int sx)
 296 {
 297   int level_xsize = level.native_em_level->lev->width;
 298   int full_xsize = level_xsize * TILESIZE_VAR;
 299
 300   sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
 301
 302   int fx = getFieldbufferOffsetX_EM();
 303   int dx = fx;
 304   int px = sx - SX;
 305   int lx = LEVELX((px + dx) / TILESIZE_VAR);
 306
 307   lx = correctLevelPosX_EM(lx);
 308
 309   return lx;
 310 }
 311
 312 static int getLevelFromScreenY_EM(int sy)
 313 {
 314   int level_ysize = level.native_em_level->lev->height;
 315   int full_ysize = level_ysize * TILESIZE_VAR;
 316
 317   sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
 318
 319   int fy = getFieldbufferOffsetY_EM();
 320   int dy = fy;
 321   int py = sy - SY;
 322   int ly = LEVELY((py + dy) / TILESIZE_VAR);
 323
 324   ly = correctLevelPosY_EM(ly);
 325
 326   return ly;
 327 }
 328
 329 static int getLevelFromScreenX_SP(int sx)
 330 {
 331   int menBorder = setup.sp_show_border_elements;
 332   int level_xsize = level.native_sp_level->width;
 333   int full_xsize = (level_xsize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
 334
 335   sx += (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
 336
 337   int fx = getFieldbufferOffsetX_SP();
 338   int dx = fx - FX;
 339   int px = sx - SX;
 340   int lx = LEVELX((px + dx) / TILESIZE_VAR);
 341
 342   return lx;
 343 }
 344
 345 static int getLevelFromScreenY_SP(int sy)
 346 {
 347   int menBorder = setup.sp_show_border_elements;
 348   int level_ysize = level.native_sp_level->height;
 349   int full_ysize = (level_ysize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
 350
 351   sy += (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
 352
 353   int fy = getFieldbufferOffsetY_SP();
 354   int dy = fy - FY;
 355   int py = sy - SY;
 356   int ly = LEVELY((py + dy) / TILESIZE_VAR);
 357
 358   return ly;
 359 }
 360
 361 static int getLevelFromScreenX_MM(int sx)
 362 {
 363 #if 0
 364   int level_xsize = level.native_mm_level->fieldx;
 365   int full_xsize = level_xsize * TILESIZE_VAR;
 366
 367   sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
 368 #endif
 369
 370   int px = sx - SX;
 371   int lx = px / TILESIZE_VAR;
 372
 373   return lx;
 374 }
 375
 376 static int getLevelFromScreenY_MM(int sy)
 377 {
 378 #if 0
 379   int level_ysize = level.native_mm_level->fieldy;
 380   int full_ysize = level_ysize * TILESIZE_VAR;
 381
 382   sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
 383 #endif
 384
 385   int py = sy - SY;
 386   int ly = py / TILESIZE_VAR;
 387
 388   return ly;
 389 }
 390
 391 int getLevelFromScreenX(int x)
 392 {
 393   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 394     return getLevelFromScreenX_EM(x);
 395   if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 396     return getLevelFromScreenX_SP(x);
 397   if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 398     return getLevelFromScreenX_MM(x);
 399   else
 400     return getLevelFromScreenX_RND(x);
 401 }
 402
 403 int getLevelFromScreenY(int y)
 404 {
 405   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 406     return getLevelFromScreenY_EM(y);
 407   if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 408     return getLevelFromScreenY_SP(y);
 409   if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 410     return getLevelFromScreenY_MM(y);
 411   else
 412     return getLevelFromScreenY_RND(y);
 413 }
 414
 415 void DumpTile(int x, int y)
 416 {
 417   int sx = SCREENX(x);
 418   int sy = SCREENY(y);
 419   char *token_name;
 420
 421   printf_line("-", 79);
 422   printf("Field Info: SCREEN(%d, %d), LEVEL(%d, %d)\n", sx, sy, x, y);
 423   printf_line("-", 79);
 424
 425   if (!IN_LEV_FIELD(x, y))
 426   {
 427     printf("(not in level field)\n");
 428     printf("\n");
 429
 430     return;
 431   }
 432
 433   token_name = element_info[Feld[x][y]].token_name;
 434
 435   printf("  Feld:        %d\t['%s']\n", Feld[x][y], token_name);
 436   printf("  Back:        %s\n", print_if_not_empty(Back[x][y]));
 437   printf("  Store:       %s\n", print_if_not_empty(Store[x][y]));
 438   printf("  Store2:      %s\n", print_if_not_empty(Store2[x][y]));
 439   printf("  StorePlayer: %s\n", print_if_not_empty(StorePlayer[x][y]));
 440   printf("  MovPos:      %d\n", MovPos[x][y]);
 441   printf("  MovDir:      %d\n", MovDir[x][y]);
 442   printf("  MovDelay:    %d\n", MovDelay[x][y]);
 443   printf("  ChangeDelay: %d\n", ChangeDelay[x][y]);
 444   printf("  CustomValue: %d\n", CustomValue[x][y]);
 445   printf("  GfxElement:  %d\n", GfxElement[x][y]);
 446   printf("  GfxAction:   %d\n", GfxAction[x][y]);
 447   printf("  GfxFrame:    %d [%d]\n", GfxFrame[x][y], FrameCounter);
 448   printf("  Player x/y:  %d, %d\n", local_player->jx, local_player->jy);
 449   printf("\n");
 450 }
 451
 452 void DumpTileFromScreen(int sx, int sy)
 453 {
 454   int lx = getLevelFromScreenX(sx);
 455   int ly = getLevelFromScreenY(sy);
 456
 457   DumpTile(lx, ly);
 458 }
 459
 460 void SetDrawtoField(int mode)
 461 {
 462   if (mode == DRAW_TO_FIELDBUFFER)
 463   {
 464     FX = 2 * TILEX_VAR;
 465     FY = 2 * TILEY_VAR;
 466     BX1 = -2;
 467     BY1 = -2;
 468     BX2 = SCR_FIELDX + 1;
 469     BY2 = SCR_FIELDY + 1;
 470
 471     drawto_field = fieldbuffer;
 472   }
 473   else  /* DRAW_TO_BACKBUFFER */
 474   {
 475     FX = SX;
 476     FY = SY;
 477     BX1 = 0;
 478     BY1 = 0;
 479     BX2 = SCR_FIELDX - 1;
 480     BY2 = SCR_FIELDY - 1;
 481
 482     drawto_field = backbuffer;
 483   }
 484 }
 485
 486 static void RedrawPlayfield_RND()
 487 {
 488   if (game.envelope_active)
 489     return;
 490
 491   DrawLevel(REDRAW_ALL);
 492   DrawAllPlayers();
 493 }
 494
 495 void RedrawPlayfield()
 496 {
 497   if (game_status != GAME_MODE_PLAYING)
 498     return;
 499
 500   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 501     RedrawPlayfield_EM(TRUE);
 502   else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 503     RedrawPlayfield_SP(TRUE);
 504   else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 505     RedrawPlayfield_MM();
 506   else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
 507     RedrawPlayfield_RND();
 508
 509   BlitScreenToBitmap(backbuffer);
 510
 511   BlitBitmap(drawto, window, gfx.sx, gfx.sy, gfx.sxsize, gfx.sysize,
 512              gfx.sx, gfx.sy);
 513 }
 514
 515 static void DrawMaskedBorderExt_Rect(int x, int y, int width, int height,
 516                                      int draw_target)
 517 {
 518   Bitmap *src_bitmap = getGlobalBorderBitmapFromStatus(global.border_status);
 519   Bitmap *dst_bitmap = gfx.masked_border_bitmap_ptr;
 520
 521   if (x == -1 && y == -1)
 522     return;
 523
 524   if (draw_target == DRAW_TO_SCREEN)
 525     BlitToScreenMasked(src_bitmap, x, y, width, height, x, y);
 526   else
 527     BlitBitmapMasked(src_bitmap, dst_bitmap, x, y, width, height, x, y);
 528 }
 529
 530 static void DrawMaskedBorderExt_FIELD(int draw_target)
 531 {
 532   if (global.border_status >= GAME_MODE_MAIN &&
 533       global.border_status <= GAME_MODE_PLAYING &&
 534       border.draw_masked[global.border_status])
 535     DrawMaskedBorderExt_Rect(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
 536                              draw_target);
 537 }
 538
 539 static void DrawMaskedBorderExt_DOOR_1(int draw_target)
 540 {
 541   // when drawing to backbuffer, never draw border over open doors
 542   if (draw_target == DRAW_TO_BACKBUFFER &&
 543       (GetDoorState() & DOOR_OPEN_1))
 544     return;
 545
 546   if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
 547       (global.border_status != GAME_MODE_EDITOR ||
 548        border.draw_masked[GFX_SPECIAL_ARG_EDITOR]))
 549     DrawMaskedBorderExt_Rect(DX, DY, DXSIZE, DYSIZE, draw_target);
 550 }
 551
 552 static void DrawMaskedBorderExt_DOOR_2(int draw_target)
 553 {
 554   // when drawing to backbuffer, never draw border over open doors
 555   if (draw_target == DRAW_TO_BACKBUFFER &&
 556       (GetDoorState() & DOOR_OPEN_2))
 557     return;
 558
 559   if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
 560       global.border_status != GAME_MODE_EDITOR)
 561     DrawMaskedBorderExt_Rect(VX, VY, VXSIZE, VYSIZE, draw_target);
 562 }
 563
 564 static void DrawMaskedBorderExt_DOOR_3(int draw_target)
 565 {
 566   /* currently not available */
 567 }
 568
 569 static void DrawMaskedBorderExt_ALL(int draw_target)
 570 {
 571   DrawMaskedBorderExt_FIELD(draw_target);
 572   DrawMaskedBorderExt_DOOR_1(draw_target);
 573   DrawMaskedBorderExt_DOOR_2(draw_target);
 574   DrawMaskedBorderExt_DOOR_3(draw_target);
 575 }
 576
 577 static void DrawMaskedBorderExt(int redraw_mask, int draw_target)
 578 {
 579   /* never draw masked screen borders on borderless screens */
 580   if (global.border_status == GAME_MODE_LOADING ||
 581       global.border_status == GAME_MODE_TITLE)
 582     return;
 583
 584   if (redraw_mask & REDRAW_ALL)
 585     DrawMaskedBorderExt_ALL(draw_target);
 586   else
 587   {
 588     if (redraw_mask & REDRAW_FIELD)
 589       DrawMaskedBorderExt_FIELD(draw_target);
 590     if (redraw_mask & REDRAW_DOOR_1)
 591       DrawMaskedBorderExt_DOOR_1(draw_target);
 592     if (redraw_mask & REDRAW_DOOR_2)
 593       DrawMaskedBorderExt_DOOR_2(draw_target);
 594     if (redraw_mask & REDRAW_DOOR_3)
 595       DrawMaskedBorderExt_DOOR_3(draw_target);
 596   }
 597 }
 598
 599 void DrawMaskedBorder_FIELD()
 600 {
 601   DrawMaskedBorderExt_FIELD(DRAW_TO_BACKBUFFER);
 602 }
 603
 604 void DrawMaskedBorder(int redraw_mask)
 605 {
 606   DrawMaskedBorderExt(redraw_mask, DRAW_TO_BACKBUFFER);
 607 }
 608
 609 void DrawMaskedBorderToTarget(int draw_target)
 610 {
 611   if (draw_target == DRAW_TO_BACKBUFFER ||
 612       draw_target == DRAW_TO_SCREEN)
 613   {
 614     DrawMaskedBorderExt(REDRAW_ALL, draw_target);
 615   }
 616   else
 617   {
 618     int last_border_status = global.border_status;
 619
 620     if (draw_target == DRAW_TO_FADE_SOURCE)
 621     {
 622       global.border_status = gfx.fade_border_source_status;
 623       gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_source;
 624     }
 625     else if (draw_target == DRAW_TO_FADE_TARGET)
 626     {
 627       global.border_status = gfx.fade_border_target_status;
 628       gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_target;
 629     }
 630
 631     DrawMaskedBorderExt(REDRAW_ALL, draw_target);
 632
 633     global.border_status = last_border_status;
 634     gfx.masked_border_bitmap_ptr = backbuffer;
 635   }
 636 }
 637
 638 void BlitScreenToBitmap_RND(Bitmap *target_bitmap)
 639 {
 640   int fx = getFieldbufferOffsetX_RND();
 641   int fy = getFieldbufferOffsetY_RND();
 642
 643   BlitBitmap(drawto_field, target_bitmap, fx, fy, SXSIZE, SYSIZE, SX, SY);
 644 }
 645
 646 void BlitScreenToBitmap(Bitmap *target_bitmap)
 647 {
 648   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 649     BlitScreenToBitmap_EM(target_bitmap);
 650   else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 651     BlitScreenToBitmap_SP(target_bitmap);
 652   else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 653     BlitScreenToBitmap_MM(target_bitmap);
 654   else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
 655     BlitScreenToBitmap_RND(target_bitmap);
 656
 657   redraw_mask |= REDRAW_FIELD;
 658 }
 659
 660 void DrawFramesPerSecond()
 661 {
 662   char text[100];
 663   int font_nr = FONT_TEXT_2;
 664   int font_width = getFontWidth(font_nr);
 665   int draw_deactivation_mask = GetDrawDeactivationMask();
 666   boolean draw_masked = (draw_deactivation_mask == REDRAW_NONE);
 667
 668   /* draw FPS with leading space (needed if field buffer deactivated) */
 669   sprintf(text, " %04.1f fps", global.frames_per_second);
 670
 671   /* override draw deactivation mask (required for invisible warp mode) */
 672   SetDrawDeactivationMask(REDRAW_NONE);
 673
 674   /* draw opaque FPS if field buffer deactivated, else draw masked FPS */
 675   DrawTextExt(backbuffer, SX + SXSIZE - font_width * strlen(text), SY, text,
 676               font_nr, (draw_masked ? BLIT_MASKED : BLIT_OPAQUE));
 677
 678   /* set draw deactivation mask to previous value */
 679   SetDrawDeactivationMask(draw_deactivation_mask);
 680
 681   /* force full-screen redraw in this frame */
 682   redraw_mask = REDRAW_ALL;
 683 }
 684
 685 #if DEBUG_FRAME_TIME
 686 static void PrintFrameTimeDebugging()
 687 {
 688   static unsigned int last_counter = 0;
 689   unsigned int counter = Counter();
 690   int diff_1 = counter - last_counter;
 691   int diff_2 = diff_1 - GAME_FRAME_DELAY;
 692   int diff_2_max = 20;
 693   int diff_2_cut = MIN(ABS(diff_2), diff_2_max);
 694   char diff_bar[2 * diff_2_max + 5];
 695   int pos = 0;
 696   int i;
 697
 698   diff_bar[pos++] = (diff_2 < -diff_2_max ? '<' : ' ');
 699
 700   for (i = 0; i < diff_2_max; i++)
 701     diff_bar[pos++] = (diff_2 >= 0 ? ' ' :
 702                        i >= diff_2_max - diff_2_cut ? '-' : ' ');
 703
 704   diff_bar[pos++] = '|';
 705
 706   for (i = 0; i < diff_2_max; i++)
 707     diff_bar[pos++] = (diff_2 <= 0 ? ' ' : i < diff_2_cut ? '+' : ' ');
 708
 709   diff_bar[pos++] = (diff_2 > diff_2_max ? '>' : ' ');
 710
 711   diff_bar[pos++] = '\0';
 712
 713   Error(ERR_INFO, "%06d [%02d] [%c%02d] %s",
 714         counter,
 715         diff_1,
 716         (diff_2 < 0 ? '-' : diff_2 > 0 ? '+' : ' '), ABS(diff_2),
 717         diff_bar);
 718
 719   last_counter = counter;
 720 }
 721 #endif
 722
 723 static int unifiedRedrawMask(int mask)
 724 {
 725   if (mask & REDRAW_ALL)
 726     return REDRAW_ALL;
 727
 728   if (mask & REDRAW_FIELD && mask & REDRAW_DOORS)
 729     return REDRAW_ALL;
 730
 731   return mask;
 732 }
 733
 734 static boolean equalRedrawMasks(int mask_1, int mask_2)
 735 {
 736   return unifiedRedrawMask(mask_1) == unifiedRedrawMask(mask_2);
 737 }
 738
 739 void BackToFront()
 740 {
 741   static int last_redraw_mask = REDRAW_NONE;
 742
 743   // force screen redraw in every frame to continue drawing global animations
 744   // (but always use the last redraw mask to prevent unwanted side effects)
 745   if (redraw_mask == REDRAW_NONE)
 746     redraw_mask = last_redraw_mask;
 747
 748   last_redraw_mask = redraw_mask;
 749
 750 #if 1
 751   // masked border now drawn immediately when blitting backbuffer to window
 752 #else
 753   // draw masked border to all viewports, if defined
 754   DrawMaskedBorder(redraw_mask);
 755 #endif
 756
 757   // draw frames per second (only if debug mode is enabled)
 758   if (redraw_mask & REDRAW_FPS)
 759     DrawFramesPerSecond();
 760
 761   // remove playfield redraw before potentially merging with doors redraw
 762   if (DrawingDeactivated(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE))
 763     redraw_mask &= ~REDRAW_FIELD;
 764
 765   // redraw complete window if both playfield and (some) doors need redraw
 766   if (redraw_mask & REDRAW_FIELD && redraw_mask & REDRAW_DOORS)
 767     redraw_mask = REDRAW_ALL;
 768
 769   /* although redrawing the whole window would be fine for normal gameplay,
 770      being able to only redraw the playfield is required for deactivating
 771      certain drawing areas (mainly playfield) to work, which is needed for
 772      warp-forward to be fast enough (by skipping redraw of most frames) */
 773
 774   if (redraw_mask & REDRAW_ALL)
 775   {
 776     BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
 777   }
 778   else if (redraw_mask & REDRAW_FIELD)
 779   {
 780     BlitBitmap(backbuffer, window,
 781                REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
 782   }
 783   else if (redraw_mask & REDRAW_DOORS)
 784   {
 785     // merge door areas to prevent calling screen redraw more than once
 786     int x1 = WIN_XSIZE;
 787     int y1 = WIN_YSIZE;
 788     int x2 = 0;
 789     int y2 = 0;
 790
 791     if (redraw_mask & REDRAW_DOOR_1)
 792     {
 793       x1 = MIN(x1, DX);
 794       y1 = MIN(y1, DY);
 795       x2 = MAX(x2, DX + DXSIZE);
 796       y2 = MAX(y2, DY + DYSIZE);
 797     }
 798
 799     if (redraw_mask & REDRAW_DOOR_2)
 800     {
 801       x1 = MIN(x1, VX);
 802       y1 = MIN(y1, VY);
 803       x2 = MAX(x2, VX + VXSIZE);
 804       y2 = MAX(y2, VY + VYSIZE);
 805     }
 806
 807     if (redraw_mask & REDRAW_DOOR_3)
 808     {
 809       x1 = MIN(x1, EX);
 810       y1 = MIN(y1, EY);
 811       x2 = MAX(x2, EX + EXSIZE);
 812       y2 = MAX(y2, EY + EYSIZE);
 813     }
 814
 815     // make sure that at least one pixel is blitted, and inside the screen
 816     // (else nothing is blitted, causing the animations not to be updated)
 817     x1 = MIN(MAX(0, x1), WIN_XSIZE - 1);
 818     y1 = MIN(MAX(0, y1), WIN_YSIZE - 1);
 819     x2 = MIN(MAX(1, x2), WIN_XSIZE);
 820     y2 = MIN(MAX(1, y2), WIN_YSIZE);
 821
 822     BlitBitmap(backbuffer, window, x1, y1, x2 - x1, y2 - y1, x1, y1);
 823   }
 824
 825   redraw_mask = REDRAW_NONE;
 826
 827 #if DEBUG_FRAME_TIME
 828   PrintFrameTimeDebugging();
 829 #endif
 830 }
 831
 832 void BackToFront_WithFrameDelay(unsigned int frame_delay_value)
 833 {
 834   unsigned int frame_delay_value_old = GetVideoFrameDelay();
 835
 836   SetVideoFrameDelay(frame_delay_value);
 837
 838   BackToFront();
 839
 840   SetVideoFrameDelay(frame_delay_value_old);
 841 }
 842
 843 static int fade_type_skip = FADE_TYPE_NONE;
 844
 845 static void FadeExt(int fade_mask, int fade_mode, int fade_type)
 846 {
 847   void (*draw_border_function)(void) = NULL;
 848   int x, y, width, height;
 849   int fade_delay, post_delay;
 850
 851   if (fade_type == FADE_TYPE_FADE_OUT)
 852   {
 853     if (fade_type_skip != FADE_TYPE_NONE)
 854     {
 855       /* skip all fade operations until specified fade operation */
 856       if (fade_type & fade_type_skip)
 857         fade_type_skip = FADE_TYPE_NONE;
 858
 859       return;
 860     }
 861
 862     if (fading.fade_mode & FADE_TYPE_TRANSFORM)
 863       return;
 864   }
 865
 866   redraw_mask |= fade_mask;
 867
 868   if (fade_type == FADE_TYPE_SKIP)
 869   {
 870     fade_type_skip = fade_mode;
 871
 872     return;
 873   }
 874
 875   fade_delay = fading.fade_delay;
 876   post_delay = (fade_mode == FADE_MODE_FADE_OUT ? fading.post_delay : 0);
 877
 878   if (fade_type_skip != FADE_TYPE_NONE)
 879   {
 880     /* skip all fade operations until specified fade operation */
 881     if (fade_type & fade_type_skip)
 882       fade_type_skip = FADE_TYPE_NONE;
 883
 884     fade_delay = 0;
 885   }
 886
 887   if (global.autoplay_leveldir)
 888   {
 889     return;
 890   }
 891
 892   if (fade_mask == REDRAW_FIELD)
 893   {
 894     x = FADE_SX;
 895     y = FADE_SY;
 896     width  = FADE_SXSIZE;
 897     height = FADE_SYSIZE;
 898
 899     if (border.draw_masked_when_fading)
 900       draw_border_function = DrawMaskedBorder_FIELD;    /* update when fading */
 901     else
 902       DrawMaskedBorder_FIELD();                         /* draw once */
 903   }
 904   else          /* REDRAW_ALL */
 905   {
 906     x = 0;
 907     y = 0;
 908     width  = WIN_XSIZE;
 909     height = WIN_YSIZE;
 910   }
 911
 912   if (!setup.fade_screens ||
 913       fade_delay == 0 ||
 914       fading.fade_mode == FADE_MODE_NONE)
 915   {
 916     if (fade_mode == FADE_MODE_FADE_OUT)
 917       return;
 918
 919     BlitBitmap(backbuffer, window, x, y, width, height, x, y);
 920
 921     redraw_mask &= ~fade_mask;
 922
 923     return;
 924   }
 925
 926   FadeRectangle(x, y, width, height, fade_mode, fade_delay, post_delay,
 927                 draw_border_function);
 928
 929   redraw_mask &= ~fade_mask;
 930 }
 931
 932 static void SetScreenStates_BeforeFadingIn()
 933 {
 934   // temporarily set screen mode for animations to screen after fading in
 935   global.anim_status = global.anim_status_next;
 936
 937   // store backbuffer with all animations that will be started after fading in
 938   if (fade_type_skip != FADE_MODE_SKIP_FADE_IN)
 939     PrepareFadeBitmap(DRAW_TO_FADE_TARGET);
 940
 941   // set screen mode for animations back to fading
 942   global.anim_status = GAME_MODE_PSEUDO_FADING;
 943 }
 944
 945 static void SetScreenStates_AfterFadingIn()
 946 {
 947   // store new source screen (to use correct masked border for fading)
 948   gfx.fade_border_source_status = global.border_status;
 949
 950   global.anim_status = global.anim_status_next;
 951 }
 952
 953 static void SetScreenStates_BeforeFadingOut()
 954 {
 955   // store new target screen (to use correct masked border for fading)
 956   gfx.fade_border_target_status = game_status;
 957
 958   // set screen mode for animations to fading
 959   global.anim_status = GAME_MODE_PSEUDO_FADING;
 960
 961   // store backbuffer with all animations that will be stopped for fading out
 962   if (fade_type_skip != FADE_MODE_SKIP_FADE_OUT)
 963     PrepareFadeBitmap(DRAW_TO_FADE_SOURCE);
 964 }
 965
 966 static void SetScreenStates_AfterFadingOut()
 967 {
 968   global.border_status = game_status;
 969 }
 970
 971 void FadeIn(int fade_mask)
 972 {
 973   SetScreenStates_BeforeFadingIn();
 974
 975 #if 1
 976   DrawMaskedBorder(REDRAW_ALL);
 977 #endif
 978
 979   if (fading.fade_mode & FADE_TYPE_TRANSFORM)
 980     FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_IN);
 981   else
 982     FadeExt(fade_mask, FADE_MODE_FADE_IN, FADE_TYPE_FADE_IN);
 983
 984   FADE_SX = REAL_SX;
 985   FADE_SY = REAL_SY;
 986   FADE_SXSIZE = FULL_SXSIZE;
 987   FADE_SYSIZE = FULL_SYSIZE;
 988
 989   if (game_status == GAME_MODE_PLAYING &&
 990       strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
 991     SetOverlayActive(TRUE);
 992
 993   SetScreenStates_AfterFadingIn();
 994
 995   // force update of global animation status in case of rapid screen changes
 996   redraw_mask = REDRAW_ALL;
 997   BackToFront();
 998 }
 999
1000 void FadeOut(int fade_mask)
1001 {
1002   // update screen if areas covered by "fade_mask" and "redraw_mask" differ
1003   if (!equalRedrawMasks(fade_mask, redraw_mask))
1004     BackToFront();
1005
1006   SetScreenStates_BeforeFadingOut();
1007
1008   SetOverlayActive(FALSE);
1009
1010 #if 0
1011   DrawMaskedBorder(REDRAW_ALL);
1012 #endif
1013
1014   if (fading.fade_mode & FADE_TYPE_TRANSFORM)
1015     FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_OUT);
1016   else
1017     FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
1018
1019   SetScreenStates_AfterFadingOut();
1020 }
1021
1022 static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
1023 {
1024   static struct TitleFadingInfo fading_leave_stored;
1025
1026   if (set)
1027     fading_leave_stored = fading_leave;
1028   else
1029     fading = fading_leave_stored;
1030 }
1031
1032 void FadeSetEnterMenu()
1033 {
1034   fading = menu.enter_menu;
1035
1036   FadeSetLeaveNext(fading, TRUE);       /* (keep same fade mode) */
1037 }
1038
1039 void FadeSetLeaveMenu()
1040 {
1041   fading = menu.leave_menu;
1042
1043   FadeSetLeaveNext(fading, TRUE);       /* (keep same fade mode) */
1044 }
1045
1046 void FadeSetEnterScreen()
1047 {
1048   fading = menu.enter_screen[game_status];
1049
1050   FadeSetLeaveNext(menu.leave_screen[game_status], TRUE);       /* store */
1051 }
1052
1053 void FadeSetNextScreen()
1054 {
1055   fading = menu.next_screen[game_status];
1056
1057   // (do not overwrite fade mode set by FadeSetEnterScreen)
1058   // FadeSetLeaveNext(fading, TRUE);    /* (keep same fade mode) */
1059 }
1060
1061 void FadeSetLeaveScreen()
1062 {
1063   FadeSetLeaveNext(menu.leave_screen[game_status], FALSE);      /* recall */
1064 }
1065
1066 void FadeSetFromType(int type)
1067 {
1068   if (type & TYPE_ENTER_SCREEN)
1069     FadeSetEnterScreen();
1070   else if (type & TYPE_ENTER)
1071     FadeSetEnterMenu();
1072   else if (type & TYPE_LEAVE)
1073     FadeSetLeaveMenu();
1074 }
1075
1076 void FadeSetDisabled()
1077 {
1078   static struct TitleFadingInfo fading_none = { FADE_MODE_NONE, -1, -1, -1 };
1079
1080   fading = fading_none;
1081 }
1082
1083 void FadeSkipNextFadeIn()
1084 {
1085   FadeExt(0, FADE_MODE_SKIP_FADE_IN, FADE_TYPE_SKIP);
1086 }
1087
1088 void FadeSkipNextFadeOut()
1089 {
1090   FadeExt(0, FADE_MODE_SKIP_FADE_OUT, FADE_TYPE_SKIP);
1091 }
1092
1093 Bitmap *getBitmapFromGraphicOrDefault(int graphic, int default_graphic)
1094 {
1095   boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
1096
1097   return (graphic == IMG_UNDEFINED ? NULL :
1098           graphic_info[graphic].bitmap != NULL || redefined ?
1099           graphic_info[graphic].bitmap :
1100           graphic_info[default_graphic].bitmap);
1101 }
1102
1103 Bitmap *getBackgroundBitmap(int graphic)
1104 {
1105   return getBitmapFromGraphicOrDefault(graphic, IMG_BACKGROUND);
1106 }
1107
1108 Bitmap *getGlobalBorderBitmap(int graphic)
1109 {
1110   return getBitmapFromGraphicOrDefault(graphic, IMG_GLOBAL_BORDER);
1111 }
1112
1113 Bitmap *getGlobalBorderBitmapFromStatus(int status)
1114 {
1115   int graphic =
1116     (status == GAME_MODE_MAIN ||
1117      status == GAME_MODE_PSEUDO_TYPENAME        ? IMG_GLOBAL_BORDER_MAIN :
1118      status == GAME_MODE_SCORES                 ? IMG_GLOBAL_BORDER_SCORES :
1119      status == GAME_MODE_EDITOR                 ? IMG_GLOBAL_BORDER_EDITOR :
1120      status == GAME_MODE_PLAYING                ? IMG_GLOBAL_BORDER_PLAYING :
1121      IMG_GLOBAL_BORDER);
1122
1123   return getGlobalBorderBitmap(graphic);
1124 }
1125
1126 void SetWindowBackgroundImageIfDefined(int graphic)
1127 {
1128   if (graphic_info[graphic].bitmap)
1129     SetWindowBackgroundBitmap(graphic_info[graphic].bitmap);
1130 }
1131
1132 void SetMainBackgroundImageIfDefined(int graphic)
1133 {
1134   if (graphic_info[graphic].bitmap)
1135     SetMainBackgroundBitmap(graphic_info[graphic].bitmap);
1136 }
1137
1138 void SetDoorBackgroundImageIfDefined(int graphic)
1139 {
1140   if (graphic_info[graphic].bitmap)
1141     SetDoorBackgroundBitmap(graphic_info[graphic].bitmap);
1142 }
1143
1144 void SetWindowBackgroundImage(int graphic)
1145 {
1146   SetWindowBackgroundBitmap(getBackgroundBitmap(graphic));
1147 }
1148
1149 void SetMainBackgroundImage(int graphic)
1150 {
1151   SetMainBackgroundBitmap(getBackgroundBitmap(graphic));
1152 }
1153
1154 void SetDoorBackgroundImage(int graphic)
1155 {
1156   SetDoorBackgroundBitmap(getBackgroundBitmap(graphic));
1157 }
1158
1159 void SetPanelBackground()
1160 {
1161   struct GraphicInfo *gfx = &graphic_info[IMG_BACKGROUND_PANEL];
1162
1163   BlitBitmapTiled(gfx->bitmap, bitmap_db_panel, gfx->src_x, gfx->src_y,
1164                   gfx->width, gfx->height, 0, 0, DXSIZE, DYSIZE);
1165
1166   SetDoorBackgroundBitmap(bitmap_db_panel);
1167 }
1168
1169 void DrawBackground(int x, int y, int width, int height)
1170 {
1171   /* "drawto" might still point to playfield buffer here (hall of fame) */
1172   ClearRectangleOnBackground(backbuffer, x, y, width, height);
1173
1174   if (IN_GFX_FIELD_FULL(x, y))
1175     redraw_mask |= REDRAW_FIELD;
1176   else if (IN_GFX_DOOR_1(x, y))
1177     redraw_mask |= REDRAW_DOOR_1;
1178   else if (IN_GFX_DOOR_2(x, y))
1179     redraw_mask |= REDRAW_DOOR_2;
1180   else if (IN_GFX_DOOR_3(x, y))
1181     redraw_mask |= REDRAW_DOOR_3;
1182 }
1183
1184 void DrawBackgroundForFont(int x, int y, int width, int height, int font_nr)
1185 {
1186   struct FontBitmapInfo *font = getFontBitmapInfo(font_nr);
1187
1188   if (font->bitmap == NULL)
1189     return;
1190
1191   DrawBackground(x, y, width, height);
1192 }
1193
1194 void DrawBackgroundForGraphic(int x, int y, int width, int height, int graphic)
1195 {
1196   struct GraphicInfo *g = &graphic_info[graphic];
1197
1198   if (g->bitmap == NULL)
1199     return;
1200
1201   DrawBackground(x, y, width, height);
1202 }
1203
1204 static int game_status_last = -1;
1205 static Bitmap *global_border_bitmap_last = NULL;
1206 static Bitmap *global_border_bitmap = NULL;
1207 static int real_sx_last = -1, real_sy_last = -1;
1208 static int full_sxsize_last = -1, full_sysize_last = -1;
1209 static int dx_last = -1, dy_last = -1;
1210 static int dxsize_last = -1, dysize_last = -1;
1211 static int vx_last = -1, vy_last = -1;
1212 static int vxsize_last = -1, vysize_last = -1;
1213
1214 boolean CheckIfGlobalBorderHasChanged()
1215 {
1216   // if game status has not changed, global border has not changed either
1217   if (game_status == game_status_last)
1218     return FALSE;
1219
1220   // determine and store new global border bitmap for current game status
1221   global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
1222
1223   return (global_border_bitmap_last != global_border_bitmap);
1224 }
1225
1226 boolean CheckIfGlobalBorderRedrawIsNeeded()
1227 {
1228   // if game status has not changed, nothing has to be redrawn
1229   if (game_status == game_status_last)
1230     return FALSE;
1231
1232   // redraw if last screen was title screen
1233   if (game_status_last == GAME_MODE_TITLE)
1234     return TRUE;
1235
1236   // redraw if global screen border has changed
1237   if (CheckIfGlobalBorderHasChanged())
1238     return TRUE;
1239
1240   // redraw if position or size of playfield area has changed
1241   if (real_sx_last != REAL_SX || real_sy_last != REAL_SY ||
1242       full_sxsize_last != FULL_SXSIZE || full_sysize_last != FULL_SYSIZE)
1243     return TRUE;
1244
1245   // redraw if position or size of door area has changed
1246   if (dx_last != DX || dy_last != DY ||
1247       dxsize_last != DXSIZE || dysize_last != DYSIZE)
1248     return TRUE;
1249
1250   // redraw if position or size of tape area has changed
1251   if (vx_last != VX || vy_last != VY ||
1252       vxsize_last != VXSIZE || vysize_last != VYSIZE)
1253     return TRUE;
1254
1255   return FALSE;
1256 }
1257
1258 void RedrawGlobalBorderFromBitmap(Bitmap *bitmap)
1259 {
1260   if (bitmap)
1261     BlitBitmap(bitmap, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1262   else
1263     ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
1264 }
1265
1266 void RedrawGlobalBorder()
1267 {
1268   Bitmap *bitmap = getGlobalBorderBitmapFromStatus(game_status);
1269
1270   RedrawGlobalBorderFromBitmap(bitmap);
1271
1272   redraw_mask = REDRAW_ALL;
1273 }
1274
1275 static void RedrawGlobalBorderIfNeeded()
1276 {
1277   if (game_status == game_status_last)
1278     return;
1279
1280   // copy current draw buffer to later copy back areas that have not changed
1281   if (game_status_last != GAME_MODE_TITLE)
1282     BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1283
1284   if (CheckIfGlobalBorderRedrawIsNeeded())
1285   {
1286     // redraw global screen border (or clear, if defined to be empty)
1287     RedrawGlobalBorderFromBitmap(global_border_bitmap);
1288
1289     // copy previous playfield and door areas, if they are defined on both
1290     // previous and current screen and if they still have the same size
1291
1292     if (real_sx_last != -1 && real_sy_last != -1 &&
1293         REAL_SX != -1 && REAL_SY != -1 &&
1294         full_sxsize_last == FULL_SXSIZE && full_sysize_last == FULL_SYSIZE)
1295       BlitBitmap(bitmap_db_store_1, backbuffer,
1296                  real_sx_last, real_sy_last, FULL_SXSIZE, FULL_SYSIZE,
1297                  REAL_SX, REAL_SY);
1298
1299     if (dx_last != -1 && dy_last != -1 &&
1300         DX != -1 && DY != -1 &&
1301         dxsize_last == DXSIZE && dysize_last == DYSIZE)
1302       BlitBitmap(bitmap_db_store_1, backbuffer,
1303                  dx_last, dy_last, DXSIZE, DYSIZE, DX, DY);
1304
1305     if (vx_last != -1 && vy_last != -1 &&
1306         VX != -1 && VY != -1 &&
1307         vxsize_last == VXSIZE && vysize_last == VYSIZE)
1308       BlitBitmap(bitmap_db_store_1, backbuffer,
1309                  vx_last, vy_last, VXSIZE, VYSIZE, VX, VY);
1310
1311     redraw_mask = REDRAW_ALL;
1312   }
1313
1314   game_status_last = game_status;
1315
1316   global_border_bitmap_last = global_border_bitmap;
1317
1318   real_sx_last = REAL_SX;
1319   real_sy_last = REAL_SY;
1320   full_sxsize_last = FULL_SXSIZE;
1321   full_sysize_last = FULL_SYSIZE;
1322   dx_last = DX;
1323   dy_last = DY;
1324   dxsize_last = DXSIZE;
1325   dysize_last = DYSIZE;
1326   vx_last = VX;
1327   vy_last = VY;
1328   vxsize_last = VXSIZE;
1329   vysize_last = VYSIZE;
1330 }
1331
1332 void ClearField()
1333 {
1334   RedrawGlobalBorderIfNeeded();
1335
1336   /* !!! "drawto" might still point to playfield buffer here (see above) !!! */
1337   /* (when entering hall of fame after playing) */
1338   DrawBackground(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
1339
1340   /* !!! maybe this should be done before clearing the background !!! */
1341   if (game_status == GAME_MODE_PLAYING)
1342   {
1343     ClearRectangle(fieldbuffer, 0, 0, FXSIZE, FYSIZE);
1344     SetDrawtoField(DRAW_TO_FIELDBUFFER);
1345   }
1346   else
1347   {
1348     SetDrawtoField(DRAW_TO_BACKBUFFER);
1349   }
1350 }
1351
1352 void MarkTileDirty(int x, int y)
1353 {
1354   redraw_mask |= REDRAW_FIELD;
1355 }
1356
1357 void SetBorderElement()
1358 {
1359   int x, y;
1360
1361   BorderElement = EL_EMPTY;
1362
1363   /* the MM game engine does not use a visible border element */
1364   if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
1365     return;
1366
1367   for (y = 0; y < lev_fieldy && BorderElement == EL_EMPTY; y++)
1368   {
1369     for (x = 0; x < lev_fieldx; x++)
1370     {
1371       if (!IS_INDESTRUCTIBLE(Feld[x][y]))
1372         BorderElement = EL_STEELWALL;
1373
1374       if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
1375         x = lev_fieldx - 2;
1376     }
1377   }
1378 }
1379
1380 void FloodFillLevelExt(int from_x, int from_y, int fill_element,
1381                        int max_array_fieldx, int max_array_fieldy,
1382                        short field[max_array_fieldx][max_array_fieldy],
1383                        int max_fieldx, int max_fieldy)
1384 {
1385   int i,x,y;
1386   int old_element;
1387   static int check[4][2] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };
1388   static int safety = 0;
1389
1390   /* check if starting field still has the desired content */
1391   if (field[from_x][from_y] == fill_element)
1392     return;
1393
1394   safety++;
1395
1396   if (safety > max_fieldx * max_fieldy)
1397     Error(ERR_EXIT, "Something went wrong in 'FloodFill()'. Please debug.");
1398
1399   old_element = field[from_x][from_y];
1400   field[from_x][from_y] = fill_element;
1401
1402   for (i = 0; i < 4; i++)
1403   {
1404     x = from_x + check[i][0];
1405     y = from_y + check[i][1];
1406
1407     if (IN_FIELD(x, y, max_fieldx, max_fieldy) && field[x][y] == old_element)
1408       FloodFillLevelExt(x, y, fill_element, max_array_fieldx, max_array_fieldy,
1409                         field, max_fieldx, max_fieldy);
1410   }
1411
1412   safety--;
1413 }
1414
1415 void FloodFillLevel(int from_x, int from_y, int fill_element,
1416                     short field[MAX_LEV_FIELDX][MAX_LEV_FIELDY],
1417                     int max_fieldx, int max_fieldy)
1418 {
1419   FloodFillLevelExt(from_x, from_y, fill_element,
1420                     MAX_LEV_FIELDX, MAX_LEV_FIELDY, field,
1421                     max_fieldx, max_fieldy);
1422 }
1423
1424 void SetRandomAnimationValue(int x, int y)
1425 {
1426   gfx.anim_random_frame = GfxRandom[x][y];
1427 }
1428
1429 int getGraphicAnimationFrame(int graphic, int sync_frame)
1430 {
1431   /* animation synchronized with global frame counter, not move position */
1432   if (graphic_info[graphic].anim_global_sync || sync_frame < 0)
1433     sync_frame = FrameCounter;
1434
1435   return getAnimationFrame(graphic_info[graphic].anim_frames,
1436                            graphic_info[graphic].anim_delay,
1437                            graphic_info[graphic].anim_mode,
1438                            graphic_info[graphic].anim_start_frame,
1439                            sync_frame);
1440 }
1441
1442 void getGraphicSourceBitmap(int graphic, int tilesize, Bitmap **bitmap)
1443 {
1444   struct GraphicInfo *g = &graphic_info[graphic];
1445   int tilesize_capped = MIN(MAX(1, tilesize), TILESIZE);
1446
1447   if (tilesize == gfx.standard_tile_size)
1448     *bitmap = g->bitmaps[IMG_BITMAP_STANDARD];
1449   else if (tilesize == game.tile_size)
1450     *bitmap = g->bitmaps[IMG_BITMAP_GAME];
1451   else
1452     *bitmap = g->bitmaps[IMG_BITMAP_1x1 - log_2(tilesize_capped)];
1453 }
1454
1455 void getGraphicSourceXY(int graphic, int frame, int *x, int *y,
1456                         boolean get_backside)
1457 {
1458   struct GraphicInfo *g = &graphic_info[graphic];
1459   int src_x = g->src_x + (get_backside ? g->offset2_x : 0);
1460   int src_y = g->src_y + (get_backside ? g->offset2_y : 0);
1461
1462   if (g->offset_y == 0)         /* frames are ordered horizontally */
1463   {
1464     int max_width = g->anim_frames_per_line * g->width;
1465     int pos = (src_y / g->height) * max_width + src_x + frame * g->offset_x;
1466
1467     *x = pos % max_width;
1468     *y = src_y % g->height + pos / max_width * g->height;
1469   }
1470   else if (g->offset_x == 0)    /* frames are ordered vertically */
1471   {
1472     int max_height = g->anim_frames_per_line * g->height;
1473     int pos = (src_x / g->width) * max_height + src_y + frame * g->offset_y;
1474
1475     *x = src_x % g->width + pos / max_height * g->width;
1476     *y = pos % max_height;
1477   }
1478   else                          /* frames are ordered diagonally */
1479   {
1480     *x = src_x + frame * g->offset_x;
1481     *y = src_y + frame * g->offset_y;
1482   }
1483 }
1484
1485 void getSizedGraphicSourceExt(int graphic, int frame, int tilesize,
1486                               Bitmap **bitmap, int *x, int *y,
1487                               boolean get_backside)
1488 {
1489   struct GraphicInfo *g = &graphic_info[graphic];
1490
1491   // if no in-game graphics defined, always use standard graphic size
1492   if (g->bitmaps[IMG_BITMAP_GAME] == NULL)
1493     tilesize = TILESIZE;
1494
1495   getGraphicSourceBitmap(graphic, tilesize, bitmap);
1496   getGraphicSourceXY(graphic, frame, x, y, get_backside);
1497
1498   *x = *x * tilesize / g->tile_size;
1499   *y = *y * tilesize / g->tile_size;
1500 }
1501
1502 void getSizedGraphicSource(int graphic, int frame, int tilesize,
1503                            Bitmap **bitmap, int *x, int *y)
1504 {
1505   getSizedGraphicSourceExt(graphic, frame, tilesize, bitmap, x, y, FALSE);
1506 }
1507
1508 void getFixedGraphicSource(int graphic, int frame,
1509                            Bitmap **bitmap, int *x, int *y)
1510 {
1511   getSizedGraphicSourceExt(graphic, frame, TILESIZE, bitmap, x, y, FALSE);
1512 }
1513
1514 void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
1515 {
1516   getSizedGraphicSource(graphic, 0, MINI_TILESIZE, bitmap, x, y);
1517 }
1518
1519 inline static void getGraphicSourceExt(int graphic, int frame, Bitmap **bitmap,
1520                                        int *x, int *y, boolean get_backside)
1521 {
1522   getSizedGraphicSourceExt(graphic, frame, TILESIZE_VAR, bitmap, x, y,
1523                            get_backside);
1524 }
1525
1526 void getGraphicSource(int graphic, int frame, Bitmap **bitmap, int *x, int *y)
1527 {
1528   getGraphicSourceExt(graphic, frame, bitmap, x, y, FALSE);
1529 }
1530
1531 void DrawGraphic(int x, int y, int graphic, int frame)
1532 {
1533 #if DEBUG
1534   if (!IN_SCR_FIELD(x, y))
1535   {
1536     printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n", x, y, graphic);
1537     printf("DrawGraphic(): This should never happen!\n");
1538     return;
1539   }
1540 #endif
1541
1542   DrawGraphicExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR, graphic,
1543                  frame);
1544
1545   MarkTileDirty(x, y);
1546 }
1547
1548 void DrawFixedGraphic(int x, int y, int graphic, int frame)
1549 {
1550 #if DEBUG
1551   if (!IN_SCR_FIELD(x, y))
1552   {
1553     printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n", x, y, graphic);
1554     printf("DrawGraphic(): This should never happen!\n");
1555     return;
1556   }
1557 #endif
1558
1559   DrawFixedGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic,
1560                       frame);
1561   MarkTileDirty(x, y);
1562 }
1563
1564 void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1565                     int frame)
1566 {
1567   Bitmap *src_bitmap;
1568   int src_x, src_y;
1569
1570   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1571
1572   BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX_VAR, TILEY_VAR, x, y);
1573 }
1574
1575 void DrawFixedGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1576                          int frame)
1577 {
1578   Bitmap *src_bitmap;
1579   int src_x, src_y;
1580
1581   getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1582   BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
1583 }
1584
1585 void DrawGraphicThruMask(int x, int y, int graphic, int frame)
1586 {
1587 #if DEBUG
1588   if (!IN_SCR_FIELD(x, y))
1589   {
1590     printf("DrawGraphicThruMask(): x = %d,y = %d, graphic = %d\n",x,y,graphic);
1591     printf("DrawGraphicThruMask(): This should never happen!\n");
1592     return;
1593   }
1594 #endif
1595
1596   DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
1597                          graphic, frame);
1598
1599   MarkTileDirty(x, y);
1600 }
1601
1602 void DrawFixedGraphicThruMask(int x, int y, int graphic, int frame)
1603 {
1604 #if DEBUG
1605   if (!IN_SCR_FIELD(x, y))
1606   {
1607     printf("DrawGraphicThruMask(): x = %d,y = %d, graphic = %d\n",x,y,graphic);
1608     printf("DrawGraphicThruMask(): This should never happen!\n");
1609     return;
1610   }
1611 #endif
1612
1613   DrawFixedGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
1614                               graphic, frame);
1615   MarkTileDirty(x, y);
1616 }
1617
1618 void DrawGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y, int graphic,
1619                             int frame)
1620 {
1621   Bitmap *src_bitmap;
1622   int src_x, src_y;
1623
1624   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1625
1626   BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX_VAR, TILEY_VAR,
1627                    dst_x, dst_y);
1628 }
1629
1630 void DrawFixedGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y,
1631                                  int graphic, int frame)
1632 {
1633   Bitmap *src_bitmap;
1634   int src_x, src_y;
1635
1636   getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1637
1638   BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY,
1639                    dst_x, dst_y);
1640 }
1641
1642 void DrawSizedGraphic(int x, int y, int graphic, int frame, int tilesize)
1643 {
1644   DrawSizedGraphicExt(drawto, SX + x * tilesize, SY + y * tilesize, graphic,
1645                       frame, tilesize);
1646   MarkTileDirty(x / tilesize, y / tilesize);
1647 }
1648
1649 void DrawSizedGraphicThruMask(int x, int y, int graphic, int frame,
1650                               int tilesize)
1651 {
1652   DrawSizedGraphicThruMaskExt(drawto, SX + x * tilesize, SY + y * tilesize,
1653                               graphic, frame, tilesize);
1654   MarkTileDirty(x / tilesize, y / tilesize);
1655 }
1656
1657 void DrawSizedGraphicExt(DrawBuffer *d, int x, int y, int graphic, int frame,
1658                          int tilesize)
1659 {
1660   Bitmap *src_bitmap;
1661   int src_x, src_y;
1662
1663   getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1664   BlitBitmap(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1665 }
1666
1667 void DrawSizedGraphicThruMaskExt(DrawBuffer *d, int x, int y, int graphic,
1668                                  int frame, int tilesize)
1669 {
1670   Bitmap *src_bitmap;
1671   int src_x, src_y;
1672
1673   getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1674   BlitBitmapMasked(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1675 }
1676
1677 void DrawMiniGraphic(int x, int y, int graphic)
1678 {
1679   DrawMiniGraphicExt(drawto, SX + x * MINI_TILEX,SY + y * MINI_TILEY, graphic);
1680   MarkTileDirty(x / 2, y / 2);
1681 }
1682
1683 void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
1684 {
1685   Bitmap *src_bitmap;
1686   int src_x, src_y;
1687
1688   getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
1689   BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
1690 }
1691
1692 inline static void DrawGraphicShiftedNormal(int x, int y, int dx, int dy,
1693                                             int graphic, int frame,
1694                                             int cut_mode, int mask_mode)
1695 {
1696   Bitmap *src_bitmap;
1697   int src_x, src_y;
1698   int dst_x, dst_y;
1699   int width = TILEX, height = TILEY;
1700   int cx = 0, cy = 0;
1701
1702   if (dx || dy)                 /* shifted graphic */
1703   {
1704     if (x < BX1)                /* object enters playfield from the left */
1705     {
1706       x = BX1;
1707       width = dx;
1708       cx = TILEX - dx;
1709       dx = 0;
1710     }
1711     else if (x > BX2)           /* object enters playfield from the right */
1712     {
1713       x = BX2;
1714       width = -dx;
1715       dx = TILEX + dx;
1716     }
1717     else if (x == BX1 && dx < 0) /* object leaves playfield to the left */
1718     {
1719       width += dx;
1720       cx = -dx;
1721       dx = 0;
1722     }
1723     else if (x == BX2 && dx > 0) /* object leaves playfield to the right */
1724       width -= dx;
1725     else if (dx)                /* general horizontal movement */
1726       MarkTileDirty(x + SIGN(dx), y);
1727
1728     if (y < BY1)                /* object enters playfield from the top */
1729     {
1730       if (cut_mode == CUT_BELOW) /* object completely above top border */
1731         return;
1732
1733       y = BY1;
1734       height = dy;
1735       cy = TILEY - dy;
1736       dy = 0;
1737     }
1738     else if (y > BY2)           /* object enters playfield from the bottom */
1739     {
1740       y = BY2;
1741       height = -dy;
1742       dy = TILEY + dy;
1743     }
1744     else if (y == BY1 && dy < 0) /* object leaves playfield to the top */
1745     {
1746       height += dy;
1747       cy = -dy;
1748       dy = 0;
1749     }
1750     else if (dy > 0 && cut_mode == CUT_ABOVE)
1751     {
1752       if (y == BY2)             /* object completely above bottom border */
1753         return;
1754
1755       height = dy;
1756       cy = TILEY - dy;
1757       dy = TILEY;
1758       MarkTileDirty(x, y + 1);
1759     }                           /* object leaves playfield to the bottom */
1760     else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
1761       height -= dy;
1762     else if (dy)                /* general vertical movement */
1763       MarkTileDirty(x, y + SIGN(dy));
1764   }
1765
1766 #if DEBUG
1767   if (!IN_SCR_FIELD(x, y))
1768   {
1769     printf("DrawGraphicShifted(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
1770     printf("DrawGraphicShifted(): This should never happen!\n");
1771     return;
1772   }
1773 #endif
1774
1775   width = width * TILESIZE_VAR / TILESIZE;
1776   height = height * TILESIZE_VAR / TILESIZE;
1777   cx = cx * TILESIZE_VAR / TILESIZE;
1778   cy = cy * TILESIZE_VAR / TILESIZE;
1779   dx = dx * TILESIZE_VAR / TILESIZE;
1780   dy = dy * TILESIZE_VAR / TILESIZE;
1781
1782   if (width > 0 && height > 0)
1783   {
1784     getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1785
1786     src_x += cx;
1787     src_y += cy;
1788
1789     dst_x = FX + x * TILEX_VAR + dx;
1790     dst_y = FY + y * TILEY_VAR + dy;
1791
1792     if (mask_mode == USE_MASKING)
1793       BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1794                        dst_x, dst_y);
1795     else
1796       BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1797                  dst_x, dst_y);
1798
1799     MarkTileDirty(x, y);
1800   }
1801 }
1802
1803 inline static void DrawGraphicShiftedDouble(int x, int y, int dx, int dy,
1804                                             int graphic, int frame,
1805                                             int cut_mode, int mask_mode)
1806 {
1807   Bitmap *src_bitmap;
1808   int src_x, src_y;
1809   int dst_x, dst_y;
1810   int width = TILEX_VAR, height = TILEY_VAR;
1811   int x1 = x;
1812   int y1 = y;
1813   int x2 = x + SIGN(dx);
1814   int y2 = y + SIGN(dy);
1815
1816   /* movement with two-tile animations must be sync'ed with movement position,
1817      not with current GfxFrame (which can be higher when using slow movement) */
1818   int anim_pos = (dx ? ABS(dx) : ABS(dy));
1819   int anim_frames = graphic_info[graphic].anim_frames;
1820
1821   /* (we also need anim_delay here for movement animations with less frames) */
1822   int anim_delay = graphic_info[graphic].anim_delay;
1823   int sync_frame = anim_pos * anim_frames * anim_delay / TILESIZE;
1824
1825   boolean draw_start_tile = (cut_mode != CUT_ABOVE);    /* only for falling! */
1826   boolean draw_end_tile   = (cut_mode != CUT_BELOW);    /* only for falling! */
1827
1828   /* re-calculate animation frame for two-tile movement animation */
1829   frame = getGraphicAnimationFrame(graphic, sync_frame);
1830
1831   /* check if movement start graphic inside screen area and should be drawn */
1832   if (draw_start_tile && IN_SCR_FIELD(x1, y1))
1833   {
1834     getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, TRUE);
1835
1836     dst_x = FX + x1 * TILEX_VAR;
1837     dst_y = FY + y1 * TILEY_VAR;
1838
1839     if (mask_mode == USE_MASKING)
1840       BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1841                        dst_x, dst_y);
1842     else
1843       BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1844                  dst_x, dst_y);
1845
1846     MarkTileDirty(x1, y1);
1847   }
1848
1849   /* check if movement end graphic inside screen area and should be drawn */
1850   if (draw_end_tile && IN_SCR_FIELD(x2, y2))
1851   {
1852     getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
1853
1854     dst_x = FX + x2 * TILEX_VAR;
1855     dst_y = FY + y2 * TILEY_VAR;
1856
1857     if (mask_mode == USE_MASKING)
1858       BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1859                        dst_x, dst_y);
1860     else
1861       BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1862                  dst_x, dst_y);
1863
1864     MarkTileDirty(x2, y2);
1865   }
1866 }
1867
1868 static void DrawGraphicShifted(int x, int y, int dx, int dy,
1869                                int graphic, int frame,
1870                                int cut_mode, int mask_mode)
1871 {
1872   if (graphic < 0)
1873   {
1874     DrawGraphic(x, y, graphic, frame);
1875
1876     return;
1877   }
1878
1879   if (graphic_info[graphic].double_movement)    /* EM style movement images */
1880     DrawGraphicShiftedDouble(x, y, dx, dy, graphic, frame, cut_mode,mask_mode);
1881   else
1882     DrawGraphicShiftedNormal(x, y, dx, dy, graphic, frame, cut_mode,mask_mode);
1883 }
1884
1885 void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy, int graphic,
1886                                 int frame, int cut_mode)
1887 {
1888   DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, USE_MASKING);
1889 }
1890
1891 void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
1892                           int cut_mode, int mask_mode)
1893 {
1894   int lx = LEVELX(x), ly = LEVELY(y);
1895   int graphic;
1896   int frame;
1897
1898   if (IN_LEV_FIELD(lx, ly))
1899   {
1900     SetRandomAnimationValue(lx, ly);
1901
1902     graphic = el_act_dir2img(element, GfxAction[lx][ly], GfxDir[lx][ly]);
1903     frame = getGraphicAnimationFrame(graphic, GfxFrame[lx][ly]);
1904
1905     /* do not use double (EM style) movement graphic when not moving */
1906     if (graphic_info[graphic].double_movement && !dx && !dy)
1907     {
1908       graphic = el_act_dir2img(element, ACTION_DEFAULT, GfxDir[lx][ly]);
1909       frame = getGraphicAnimationFrame(graphic, GfxFrame[lx][ly]);
1910     }
1911   }
1912   else  /* border element */
1913   {
1914     graphic = el2img(element);
1915     frame = getGraphicAnimationFrame(graphic, -1);
1916   }
1917
1918   if (element == EL_EXPANDABLE_WALL)
1919   {
1920     boolean left_stopped = FALSE, right_stopped = FALSE;
1921
1922     if (!IN_LEV_FIELD(lx - 1, ly) || IS_WALL(Feld[lx - 1][ly]))
1923       left_stopped = TRUE;
1924     if (!IN_LEV_FIELD(lx + 1, ly) || IS_WALL(Feld[lx + 1][ly]))
1925       right_stopped = TRUE;
1926
1927     if (left_stopped && right_stopped)
1928       graphic = IMG_WALL;
1929     else if (left_stopped)
1930     {
1931       graphic = IMG_EXPANDABLE_WALL_GROWING_RIGHT;
1932       frame = graphic_info[graphic].anim_frames - 1;
1933     }
1934     else if (right_stopped)
1935     {
1936       graphic = IMG_EXPANDABLE_WALL_GROWING_LEFT;
1937       frame = graphic_info[graphic].anim_frames - 1;
1938     }
1939   }
1940
1941   if (dx || dy)
1942     DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
1943   else if (mask_mode == USE_MASKING)
1944     DrawGraphicThruMask(x, y, graphic, frame);
1945   else
1946     DrawGraphic(x, y, graphic, frame);
1947 }
1948
1949 void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
1950                          int cut_mode, int mask_mode)
1951 {
1952   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
1953     DrawScreenElementExt(SCREENX(x), SCREENY(y), dx, dy, element,
1954                          cut_mode, mask_mode);
1955 }
1956
1957 void DrawScreenElementShifted(int x, int y, int dx, int dy, int element,
1958                               int cut_mode)
1959 {
1960   DrawScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
1961 }
1962
1963 void DrawLevelElementShifted(int x, int y, int dx, int dy, int element,
1964                              int cut_mode)
1965 {
1966   DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
1967 }
1968
1969 void DrawLevelElementThruMask(int x, int y, int element)
1970 {
1971   DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
1972 }
1973
1974 void DrawLevelFieldThruMask(int x, int y)
1975 {
1976   DrawLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
1977 }
1978
1979 /* !!! implementation of quicksand is totally broken !!! */
1980 #define IS_CRUMBLED_TILE(x, y, e)                                       \
1981         (GFX_CRUMBLED(e) && (!IN_LEV_FIELD(x, y) ||                     \
1982                              !IS_MOVING(x, y) ||                        \
1983                              (e) == EL_QUICKSAND_EMPTYING ||            \
1984                              (e) == EL_QUICKSAND_FAST_EMPTYING))
1985
1986 static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy,
1987                                                int graphic)
1988 {
1989   Bitmap *src_bitmap;
1990   int src_x, src_y;
1991   int width, height, cx, cy;
1992   int sx = SCREENX(x), sy = SCREENY(y);
1993   int crumbled_border_size = graphic_info[graphic].border_size;
1994   int crumbled_tile_size = graphic_info[graphic].tile_size;
1995   int crumbled_border_size_var =
1996     crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
1997   int i;
1998
1999   getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2000
2001   for (i = 1; i < 4; i++)
2002   {
2003     int dxx = (i & 1 ? dx : 0);
2004     int dyy = (i & 2 ? dy : 0);
2005     int xx = x + dxx;
2006     int yy = y + dyy;
2007     int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2008                    BorderElement);
2009
2010     /* check if neighbour field is of same crumble type */
2011     boolean same = (IS_CRUMBLED_TILE(xx, yy, element) &&
2012                     graphic_info[graphic].class ==
2013                     graphic_info[el_act2crm(element, ACTION_DEFAULT)].class);
2014
2015     /* return if check prevents inner corner */
2016     if (same == (dxx == dx && dyy == dy))
2017       return;
2018   }
2019
2020   /* if we reach this point, we have an inner corner */
2021
2022   getGraphicSource(graphic, 1, &src_bitmap, &src_x, &src_y);
2023
2024   width  = crumbled_border_size_var;
2025   height = crumbled_border_size_var;
2026   cx = (dx > 0 ? TILESIZE_VAR - width  : 0);
2027   cy = (dy > 0 ? TILESIZE_VAR - height : 0);
2028
2029   BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2030              width, height, FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2031 }
2032
2033 static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
2034                                           int dir)
2035 {
2036   Bitmap *src_bitmap;
2037   int src_x, src_y;
2038   int width, height, bx, by, cx, cy;
2039   int sx = SCREENX(x), sy = SCREENY(y);
2040   int crumbled_border_size = graphic_info[graphic].border_size;
2041   int crumbled_tile_size = graphic_info[graphic].tile_size;
2042   int crumbled_border_size_var =
2043     crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
2044   int crumbled_border_pos_var = TILESIZE_VAR - crumbled_border_size_var;
2045   int i;
2046
2047   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2048
2049   /* draw simple, sloppy, non-corner-accurate crumbled border */
2050
2051   width  = (dir == 1 || dir == 2 ? crumbled_border_size_var : TILESIZE_VAR);
2052   height = (dir == 0 || dir == 3 ? crumbled_border_size_var : TILESIZE_VAR);
2053   cx = (dir == 2 ? crumbled_border_pos_var : 0);
2054   cy = (dir == 3 ? crumbled_border_pos_var : 0);
2055
2056   BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy, width, height,
2057              FX + sx * TILEX_VAR + cx,
2058              FY + sy * TILEY_VAR + cy);
2059
2060   /* (remaining middle border part must be at least as big as corner part) */
2061   if (!(graphic_info[graphic].style & STYLE_ACCURATE_BORDERS) ||
2062       crumbled_border_size_var >= TILESIZE_VAR / 3)
2063     return;
2064
2065   /* correct corners of crumbled border, if needed */
2066
2067   for (i = -1; i <= 1; i += 2)
2068   {
2069     int xx = x + (dir == 0 || dir == 3 ? i : 0);
2070     int yy = y + (dir == 1 || dir == 2 ? i : 0);
2071     int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2072                    BorderElement);
2073
2074     /* check if neighbour field is of same crumble type */
2075     if (IS_CRUMBLED_TILE(xx, yy, element) &&
2076         graphic_info[graphic].class ==
2077         graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2078     {
2079       /* no crumbled corner, but continued crumbled border */
2080
2081       int c1 = (dir == 2 || dir == 3 ? crumbled_border_pos_var : 0);
2082       int c2 = (i == 1 ? crumbled_border_pos_var : 0);
2083       int b1 = (i == 1 ? crumbled_border_size_var :
2084                 TILESIZE_VAR - 2 * crumbled_border_size_var);
2085
2086       width  = crumbled_border_size_var;
2087       height = crumbled_border_size_var;
2088
2089       if (dir == 1 || dir == 2)
2090       {
2091         cx = c1;
2092         cy = c2;
2093         bx = cx;
2094         by = b1;
2095       }
2096       else
2097       {
2098         cx = c2;
2099         cy = c1;
2100         bx = b1;
2101         by = cy;
2102       }
2103
2104       BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
2105                  width, height,
2106                  FX + sx * TILEX_VAR + cx,
2107                  FY + sy * TILEY_VAR + cy);
2108     }
2109   }
2110 }
2111
2112 static void DrawLevelFieldCrumbledExt(int x, int y, int graphic, int frame)
2113 {
2114   int sx = SCREENX(x), sy = SCREENY(y);
2115   int element;
2116   int i;
2117   static int xy[4][2] =
2118   {
2119     { 0, -1 },
2120     { -1, 0 },
2121     { +1, 0 },
2122     { 0, +1 }
2123   };
2124
2125   if (!IN_LEV_FIELD(x, y))
2126     return;
2127
2128   element = TILE_GFX_ELEMENT(x, y);
2129
2130   if (IS_CRUMBLED_TILE(x, y, element))          /* crumble field itself */
2131   {
2132     if (!IN_SCR_FIELD(sx, sy))
2133       return;
2134
2135     /* crumble field borders towards direct neighbour fields */
2136     for (i = 0; i < 4; i++)
2137     {
2138       int xx = x + xy[i][0];
2139       int yy = y + xy[i][1];
2140
2141       element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2142                  BorderElement);
2143
2144       /* check if neighbour field is of same crumble type */
2145       if (IS_CRUMBLED_TILE(xx, yy, element) &&
2146           graphic_info[graphic].class ==
2147           graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2148         continue;
2149
2150       DrawLevelFieldCrumbledBorders(x, y, graphic, frame, i);
2151     }
2152
2153     /* crumble inner field corners towards corner neighbour fields */
2154     if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2155         graphic_info[graphic].anim_frames == 2)
2156     {
2157       for (i = 0; i < 4; i++)
2158       {
2159         int dx = (i & 1 ? +1 : -1);
2160         int dy = (i & 2 ? +1 : -1);
2161
2162         DrawLevelFieldCrumbledInnerCorners(x, y, dx, dy, graphic);
2163       }
2164     }
2165
2166     MarkTileDirty(sx, sy);
2167   }
2168   else          /* center field is not crumbled -- crumble neighbour fields */
2169   {
2170     /* crumble field borders of direct neighbour fields */
2171     for (i = 0; i < 4; i++)
2172     {
2173       int xx = x + xy[i][0];
2174       int yy = y + xy[i][1];
2175       int sxx = sx + xy[i][0];
2176       int syy = sy + xy[i][1];
2177
2178       if (!IN_LEV_FIELD(xx, yy) ||
2179           !IN_SCR_FIELD(sxx, syy))
2180         continue;
2181
2182       if (Feld[xx][yy] == EL_ELEMENT_SNAPPING)
2183         continue;
2184
2185       element = TILE_GFX_ELEMENT(xx, yy);
2186
2187       if (!IS_CRUMBLED_TILE(xx, yy, element))
2188         continue;
2189
2190       graphic = el_act2crm(element, ACTION_DEFAULT);
2191
2192       DrawLevelFieldCrumbledBorders(xx, yy, graphic, 0, 3 - i);
2193
2194       MarkTileDirty(sxx, syy);
2195     }
2196
2197     /* crumble inner field corners of corner neighbour fields */
2198     for (i = 0; i < 4; i++)
2199     {
2200       int dx = (i & 1 ? +1 : -1);
2201       int dy = (i & 2 ? +1 : -1);
2202       int xx = x + dx;
2203       int yy = y + dy;
2204       int sxx = sx + dx;
2205       int syy = sy + dy;
2206
2207       if (!IN_LEV_FIELD(xx, yy) ||
2208           !IN_SCR_FIELD(sxx, syy))
2209         continue;
2210
2211       if (Feld[xx][yy] == EL_ELEMENT_SNAPPING)
2212         continue;
2213
2214       element = TILE_GFX_ELEMENT(xx, yy);
2215
2216       if (!IS_CRUMBLED_TILE(xx, yy, element))
2217         continue;
2218
2219       graphic = el_act2crm(element, ACTION_DEFAULT);
2220
2221       if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2222           graphic_info[graphic].anim_frames == 2)
2223         DrawLevelFieldCrumbledInnerCorners(xx, yy, -dx, -dy, graphic);
2224
2225       MarkTileDirty(sxx, syy);
2226     }
2227   }
2228 }
2229
2230 void DrawLevelFieldCrumbled(int x, int y)
2231 {
2232   int graphic;
2233
2234   if (!IN_LEV_FIELD(x, y))
2235     return;
2236
2237   if (Feld[x][y] == EL_ELEMENT_SNAPPING &&
2238       GfxElement[x][y] != EL_UNDEFINED &&
2239       GFX_CRUMBLED(GfxElement[x][y]))
2240   {
2241     DrawLevelFieldCrumbledDigging(x, y, GfxDir[x][y], GfxFrame[x][y]);
2242
2243     return;
2244   }
2245
2246   graphic = el_act2crm(TILE_GFX_ELEMENT(x, y), ACTION_DEFAULT);
2247
2248   DrawLevelFieldCrumbledExt(x, y, graphic, 0);
2249 }
2250
2251 void DrawLevelFieldCrumbledDigging(int x, int y, int direction,
2252                                    int step_frame)
2253 {
2254   int graphic1 = el_act_dir2img(GfxElement[x][y], ACTION_DIGGING, direction);
2255   int graphic2 = el_act_dir2crm(GfxElement[x][y], ACTION_DIGGING, direction);
2256   int frame1 = getGraphicAnimationFrame(graphic1, step_frame);
2257   int frame2 = getGraphicAnimationFrame(graphic2, step_frame);
2258   int sx = SCREENX(x), sy = SCREENY(y);
2259
2260   DrawGraphic(sx, sy, graphic1, frame1);
2261   DrawLevelFieldCrumbledExt(x, y, graphic2, frame2);
2262 }
2263
2264 void DrawLevelFieldCrumbledNeighbours(int x, int y)
2265 {
2266   int sx = SCREENX(x), sy = SCREENY(y);
2267   static int xy[4][2] =
2268   {
2269     { 0, -1 },
2270     { -1, 0 },
2271     { +1, 0 },
2272     { 0, +1 }
2273   };
2274   int i;
2275
2276   /* crumble direct neighbour fields (required for field borders) */
2277   for (i = 0; i < 4; i++)
2278   {
2279     int xx = x + xy[i][0];
2280     int yy = y + xy[i][1];
2281     int sxx = sx + xy[i][0];
2282     int syy = sy + xy[i][1];
2283
2284     if (!IN_LEV_FIELD(xx, yy) ||
2285         !IN_SCR_FIELD(sxx, syy) ||
2286         !GFX_CRUMBLED(Feld[xx][yy]) ||
2287         IS_MOVING(xx, yy))
2288       continue;
2289
2290     DrawLevelField(xx, yy);
2291   }
2292
2293   /* crumble corner neighbour fields (required for inner field corners) */
2294   for (i = 0; i < 4; i++)
2295   {
2296     int dx = (i & 1 ? +1 : -1);
2297     int dy = (i & 2 ? +1 : -1);
2298     int xx = x + dx;
2299     int yy = y + dy;
2300     int sxx = sx + dx;
2301     int syy = sy + dy;
2302
2303     if (!IN_LEV_FIELD(xx, yy) ||
2304         !IN_SCR_FIELD(sxx, syy) ||
2305         !GFX_CRUMBLED(Feld[xx][yy]) ||
2306         IS_MOVING(xx, yy))
2307       continue;
2308
2309     int element = TILE_GFX_ELEMENT(xx, yy);
2310     int graphic = el_act2crm(element, ACTION_DEFAULT);
2311
2312     if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2313         graphic_info[graphic].anim_frames == 2)
2314       DrawLevelField(xx, yy);
2315   }
2316 }
2317
2318 static int getBorderElement(int x, int y)
2319 {
2320   int border[7][2] =
2321   {
2322     { EL_STEELWALL_TOPLEFT,             EL_INVISIBLE_STEELWALL_TOPLEFT     },
2323     { EL_STEELWALL_TOPRIGHT,            EL_INVISIBLE_STEELWALL_TOPRIGHT    },
2324     { EL_STEELWALL_BOTTOMLEFT,          EL_INVISIBLE_STEELWALL_BOTTOMLEFT  },
2325     { EL_STEELWALL_BOTTOMRIGHT,         EL_INVISIBLE_STEELWALL_BOTTOMRIGHT },
2326     { EL_STEELWALL_VERTICAL,            EL_INVISIBLE_STEELWALL_VERTICAL    },
2327     { EL_STEELWALL_HORIZONTAL,          EL_INVISIBLE_STEELWALL_HORIZONTAL  },
2328     { EL_STEELWALL,                     EL_INVISIBLE_STEELWALL             }
2329   };
2330   int steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
2331   int steel_position = (x == -1         && y == -1              ? 0 :
2332                         x == lev_fieldx && y == -1              ? 1 :
2333                         x == -1         && y == lev_fieldy      ? 2 :
2334                         x == lev_fieldx && y == lev_fieldy      ? 3 :
2335                         x == -1         || x == lev_fieldx      ? 4 :
2336                         y == -1         || y == lev_fieldy      ? 5 : 6);
2337
2338   return border[steel_position][steel_type];
2339 }
2340
2341 void DrawScreenElement(int x, int y, int element)
2342 {
2343   DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, NO_MASKING);
2344   DrawLevelFieldCrumbled(LEVELX(x), LEVELY(y));
2345 }
2346
2347 void DrawLevelElement(int x, int y, int element)
2348 {
2349   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2350     DrawScreenElement(SCREENX(x), SCREENY(y), element);
2351 }
2352
2353 void DrawScreenField(int x, int y)
2354 {
2355   int lx = LEVELX(x), ly = LEVELY(y);
2356   int element, content;
2357
2358   if (!IN_LEV_FIELD(lx, ly))
2359   {
2360     if (lx < -1 || lx > lev_fieldx || ly < -1 || ly > lev_fieldy)
2361       element = EL_EMPTY;
2362     else
2363       element = getBorderElement(lx, ly);
2364
2365     DrawScreenElement(x, y, element);
2366
2367     return;
2368   }
2369
2370   element = Feld[lx][ly];
2371   content = Store[lx][ly];
2372
2373   if (IS_MOVING(lx, ly))
2374   {
2375     int horiz_move = (MovDir[lx][ly] == MV_LEFT || MovDir[lx][ly] == MV_RIGHT);
2376     boolean cut_mode = NO_CUTTING;
2377
2378     if (element == EL_QUICKSAND_EMPTYING ||
2379         element == EL_QUICKSAND_FAST_EMPTYING ||
2380         element == EL_MAGIC_WALL_EMPTYING ||
2381         element == EL_BD_MAGIC_WALL_EMPTYING ||
2382         element == EL_DC_MAGIC_WALL_EMPTYING ||
2383         element == EL_AMOEBA_DROPPING)
2384       cut_mode = CUT_ABOVE;
2385     else if (element == EL_QUICKSAND_FILLING ||
2386              element == EL_QUICKSAND_FAST_FILLING ||
2387              element == EL_MAGIC_WALL_FILLING ||
2388              element == EL_BD_MAGIC_WALL_FILLING ||
2389              element == EL_DC_MAGIC_WALL_FILLING)
2390       cut_mode = CUT_BELOW;
2391
2392     if (cut_mode == CUT_ABOVE)
2393       DrawScreenElement(x, y, element);
2394     else
2395       DrawScreenElement(x, y, EL_EMPTY);
2396
2397     if (horiz_move)
2398       DrawScreenElementShifted(x, y, MovPos[lx][ly], 0, element, NO_CUTTING);
2399     else if (cut_mode == NO_CUTTING)
2400       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
2401     else
2402     {
2403       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
2404
2405       if (cut_mode == CUT_BELOW &&
2406           IN_LEV_FIELD(lx, ly + 1) && IN_SCR_FIELD(x, y + 1))
2407         DrawLevelElement(lx, ly + 1, element);
2408     }
2409
2410     if (content == EL_ACID)
2411     {
2412       int dir = MovDir[lx][ly];
2413       int newlx = lx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2414       int newly = ly + (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
2415
2416       DrawLevelElementThruMask(newlx, newly, EL_ACID);
2417
2418       // prevent target field from being drawn again (but without masking)
2419       // (this would happen if target field is scanned after moving element)
2420       Stop[newlx][newly] = TRUE;
2421     }
2422   }
2423   else if (IS_BLOCKED(lx, ly))
2424   {
2425     int oldx, oldy;
2426     int sx, sy;
2427     int horiz_move;
2428     boolean cut_mode = NO_CUTTING;
2429     int element_old, content_old;
2430
2431     Blocked2Moving(lx, ly, &oldx, &oldy);
2432     sx = SCREENX(oldx);
2433     sy = SCREENY(oldy);
2434     horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
2435                   MovDir[oldx][oldy] == MV_RIGHT);
2436
2437     element_old = Feld[oldx][oldy];
2438     content_old = Store[oldx][oldy];
2439
2440     if (element_old == EL_QUICKSAND_EMPTYING ||
2441         element_old == EL_QUICKSAND_FAST_EMPTYING ||
2442         element_old == EL_MAGIC_WALL_EMPTYING ||
2443         element_old == EL_BD_MAGIC_WALL_EMPTYING ||
2444         element_old == EL_DC_MAGIC_WALL_EMPTYING ||
2445         element_old == EL_AMOEBA_DROPPING)
2446       cut_mode = CUT_ABOVE;
2447
2448     DrawScreenElement(x, y, EL_EMPTY);
2449
2450     if (horiz_move)
2451       DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
2452                                NO_CUTTING);
2453     else if (cut_mode == NO_CUTTING)
2454       DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old,
2455                                cut_mode);
2456     else
2457       DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old,
2458                                cut_mode);
2459   }
2460   else if (IS_DRAWABLE(element))
2461     DrawScreenElement(x, y, element);
2462   else
2463     DrawScreenElement(x, y, EL_EMPTY);
2464 }
2465
2466 void DrawLevelField(int x, int y)
2467 {
2468   if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2469     DrawScreenField(SCREENX(x), SCREENY(y));
2470   else if (IS_MOVING(x, y))
2471   {
2472     int newx,newy;
2473
2474     Moving2Blocked(x, y, &newx, &newy);
2475     if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
2476       DrawScreenField(SCREENX(newx), SCREENY(newy));
2477   }
2478   else if (IS_BLOCKED(x, y))
2479   {
2480     int oldx, oldy;
2481
2482     Blocked2Moving(x, y, &oldx, &oldy);
2483     if (IN_SCR_FIELD(SCREENX(oldx), SCREENY(oldy)))
2484       DrawScreenField(SCREENX(oldx), SCREENY(oldy));
2485   }
2486 }
2487
2488 static void DrawSizedWallExt_MM(int dst_x, int dst_y, int element, int tilesize,
2489                                 int (*el2img_function)(int), boolean masked)
2490 {
2491   int element_base = map_mm_wall_element(element);
2492   int element_bits = (IS_DF_WALL(element) ?
2493                       element - EL_DF_WALL_START :
2494                       element - EL_MM_WALL_START) & 0x000f;
2495   int graphic = el2img_function(element_base);
2496   int tilesize_draw = tilesize / 2;
2497   Bitmap *src_bitmap;
2498   int src_x, src_y;
2499   int i;
2500
2501   getSizedGraphicSource(graphic, 0, tilesize_draw, &src_bitmap, &src_x, &src_y);
2502
2503   for (i = 0; i < 4; i++)
2504   {
2505     int dst_draw_x = dst_x + (i % 2) * tilesize_draw;
2506     int dst_draw_y = dst_y + (i / 2) * tilesize_draw;
2507
2508     if (element_bits & (1 << i))
2509     {
2510       if (masked)
2511         BlitBitmapMasked(src_bitmap, drawto, src_x, src_y,
2512                          tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2513       else
2514         BlitBitmap(src_bitmap, drawto, src_x, src_y,
2515                    tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2516     }
2517     else
2518     {
2519       if (!masked)
2520         ClearRectangle(drawto, dst_draw_x, dst_draw_y,
2521                        tilesize_draw, tilesize_draw);
2522     }
2523   }
2524 }
2525
2526 void DrawSizedWall_MM(int dst_x, int dst_y, int element, int tilesize,
2527                       int (*el2img_function)(int))
2528 {
2529   DrawSizedWallExt_MM(dst_x, dst_y, element, tilesize, el2img_function, FALSE);
2530 }
2531
2532 void DrawSizedElementExt(int x, int y, int element, int tilesize,
2533                          boolean masked)
2534 {
2535   if (IS_MM_WALL(element))
2536   {
2537     DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2538                         element, tilesize, el2edimg, masked);
2539   }
2540   else
2541   {
2542     int graphic = el2edimg(element);
2543
2544     if (masked)
2545       DrawSizedGraphicThruMask(x, y, graphic, 0, tilesize);
2546     else
2547       DrawSizedGraphic(x, y, graphic, 0, tilesize);
2548   }
2549 }
2550
2551 void DrawSizedElement(int x, int y, int element, int tilesize)
2552 {
2553   DrawSizedElementExt(x, y, element, tilesize, FALSE);
2554 }
2555
2556 void DrawSizedElementThruMask(int x, int y, int element, int tilesize)
2557 {
2558   DrawSizedElementExt(x, y, element, tilesize, TRUE);
2559 }
2560
2561 void DrawMiniElement(int x, int y, int element)
2562 {
2563   int graphic;
2564
2565   graphic = el2edimg(element);
2566   DrawMiniGraphic(x, y, graphic);
2567 }
2568
2569 void DrawSizedElementOrWall(int sx, int sy, int scroll_x, int scroll_y,
2570                             int tilesize)
2571 {
2572   int x = sx + scroll_x, y = sy + scroll_y;
2573
2574   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2575     DrawSizedElement(sx, sy, EL_EMPTY, tilesize);
2576   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2577     DrawSizedElement(sx, sy, Feld[x][y], tilesize);
2578   else
2579     DrawSizedGraphic(sx, sy, el2edimg(getBorderElement(x, y)), 0, tilesize);
2580 }
2581
2582 void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
2583 {
2584   int x = sx + scroll_x, y = sy + scroll_y;
2585
2586   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2587     DrawMiniElement(sx, sy, EL_EMPTY);
2588   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2589     DrawMiniElement(sx, sy, Feld[x][y]);
2590   else
2591     DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
2592 }
2593
2594 void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
2595                                  int x, int y, int xsize, int ysize,
2596                                  int tile_width, int tile_height)
2597 {
2598   Bitmap *src_bitmap;
2599   int src_x, src_y;
2600   int dst_x = startx + x * tile_width;
2601   int dst_y = starty + y * tile_height;
2602   int width  = graphic_info[graphic].width;
2603   int height = graphic_info[graphic].height;
2604   int inner_width_raw  = MAX(width  - 2 * tile_width,  tile_width);
2605   int inner_height_raw = MAX(height - 2 * tile_height, tile_height);
2606   int inner_width  = inner_width_raw  - (inner_width_raw  % tile_width);
2607   int inner_height = inner_height_raw - (inner_height_raw % tile_height);
2608   int inner_sx = (width  >= 3 * tile_width  ? tile_width  : 0);
2609   int inner_sy = (height >= 3 * tile_height ? tile_height : 0);
2610   boolean draw_masked = graphic_info[graphic].draw_masked;
2611
2612   getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2613
2614   if (src_bitmap == NULL || width < tile_width || height < tile_height)
2615   {
2616     ClearRectangle(drawto, dst_x, dst_y, tile_width, tile_height);
2617     return;
2618   }
2619
2620   src_x += (x == 0 ? 0 : x == xsize - 1 ? width  - tile_width  :
2621             inner_sx + (x - 1) * tile_width  % inner_width);
2622   src_y += (y == 0 ? 0 : y == ysize - 1 ? height - tile_height :
2623             inner_sy + (y - 1) * tile_height % inner_height);
2624
2625   if (draw_masked)
2626     BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2627                      dst_x, dst_y);
2628   else
2629     BlitBitmap(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2630                dst_x, dst_y);
2631 }
2632
2633 void DrawEnvelopeBackground(int graphic, int startx, int starty,
2634                             int x, int y, int xsize, int ysize, int font_nr)
2635 {
2636   int font_width  = getFontWidth(font_nr);
2637   int font_height = getFontHeight(font_nr);
2638
2639   DrawEnvelopeBackgroundTiles(graphic, startx, starty, x, y, xsize, ysize,
2640                               font_width, font_height);
2641 }
2642
2643 void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
2644 {
2645   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2646   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
2647   int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
2648   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2649   boolean no_delay = (tape.warp_forward);
2650   unsigned int anim_delay = 0;
2651   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2652   int anim_delay_value = MAX(1, (no_delay ? 0 : frame_delay_value) / 2);
2653   int font_nr = FONT_ENVELOPE_1 + envelope_nr;
2654   int font_width = getFontWidth(font_nr);
2655   int font_height = getFontHeight(font_nr);
2656   int max_xsize = level.envelope[envelope_nr].xsize;
2657   int max_ysize = level.envelope[envelope_nr].ysize;
2658   int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize : 0);
2659   int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize : 0);
2660   int xend = max_xsize;
2661   int yend = (anim_mode != ANIM_DEFAULT ? max_ysize : 0);
2662   int xstep = (xstart < xend ? 1 : 0);
2663   int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
2664   int start = 0;
2665   int end = MAX(xend - xstart, yend - ystart);
2666   int i;
2667
2668   for (i = start; i <= end; i++)
2669   {
2670     int last_frame = end;       // last frame of this "for" loop
2671     int x = xstart + i * xstep;
2672     int y = ystart + i * ystep;
2673     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
2674     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
2675     int sx = SX + (SXSIZE - xsize * font_width)  / 2;
2676     int sy = SY + (SYSIZE - ysize * font_height) / 2;
2677     int xx, yy;
2678
2679     SetDrawtoField(DRAW_TO_FIELDBUFFER);
2680
2681     BlitScreenToBitmap(backbuffer);
2682
2683     SetDrawtoField(DRAW_TO_BACKBUFFER);
2684
2685     for (yy = 0; yy < ysize; yy++)
2686       for (xx = 0; xx < xsize; xx++)
2687         DrawEnvelopeBackground(graphic, sx, sy, xx, yy, xsize, ysize, font_nr);
2688
2689     DrawTextBuffer(sx + font_width, sy + font_height,
2690                    level.envelope[envelope_nr].text, font_nr, max_xsize,
2691                    xsize - 2, ysize - 2, 0, mask_mode,
2692                    level.envelope[envelope_nr].autowrap,
2693                    level.envelope[envelope_nr].centered, FALSE);
2694
2695     redraw_mask |= REDRAW_FIELD;
2696     BackToFront();
2697
2698     SkipUntilDelayReached(&anim_delay, anim_delay_value, &i, last_frame);
2699   }
2700 }
2701
2702 void ShowEnvelope(int envelope_nr)
2703 {
2704   int element = EL_ENVELOPE_1 + envelope_nr;
2705   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2706   int sound_opening = element_info[element].sound[ACTION_OPENING];
2707   int sound_closing = element_info[element].sound[ACTION_CLOSING];
2708   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2709   boolean no_delay = (tape.warp_forward);
2710   int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
2711   int wait_delay_value = (no_delay ? 0 : normal_delay_value);
2712   int anim_mode = graphic_info[graphic].anim_mode;
2713   int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
2714                         anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
2715
2716   game.envelope_active = TRUE;  /* needed for RedrawPlayfield() events */
2717
2718   PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
2719
2720   if (anim_mode == ANIM_DEFAULT)
2721     AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
2722
2723   AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
2724
2725   if (tape.playing)
2726     Delay(wait_delay_value);
2727   else
2728     WaitForEventToContinue();
2729
2730   PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
2731
2732   if (anim_mode != ANIM_NONE)
2733     AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
2734
2735   if (anim_mode == ANIM_DEFAULT)
2736     AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
2737
2738   game.envelope_active = FALSE;
2739
2740   SetDrawtoField(DRAW_TO_FIELDBUFFER);
2741
2742   redraw_mask |= REDRAW_FIELD;
2743   BackToFront();
2744 }
2745
2746 static void setRequestBasePosition(int *x, int *y)
2747 {
2748   int sx_base, sy_base;
2749
2750   if (request.x != -1)
2751     sx_base = request.x;
2752   else if (request.align == ALIGN_LEFT)
2753     sx_base = SX;
2754   else if (request.align == ALIGN_RIGHT)
2755     sx_base = SX + SXSIZE;
2756   else
2757     sx_base = SX + SXSIZE / 2;
2758
2759   if (request.y != -1)
2760     sy_base = request.y;
2761   else if (request.valign == VALIGN_TOP)
2762     sy_base = SY;
2763   else if (request.valign == VALIGN_BOTTOM)
2764     sy_base = SY + SYSIZE;
2765   else
2766     sy_base = SY + SYSIZE / 2;
2767
2768   *x = sx_base;
2769   *y = sy_base;
2770 }
2771
2772 static void setRequestPositionExt(int *x, int *y, int width, int height,
2773                                   boolean add_border_size)
2774 {
2775   int border_size = request.border_size;
2776   int sx_base, sy_base;
2777   int sx, sy;
2778
2779   setRequestBasePosition(&sx_base, &sy_base);
2780
2781   if (request.align == ALIGN_LEFT)
2782     sx = sx_base;
2783   else if (request.align == ALIGN_RIGHT)
2784     sx = sx_base - width;
2785   else
2786     sx = sx_base - width  / 2;
2787
2788   if (request.valign == VALIGN_TOP)
2789     sy = sy_base;
2790   else if (request.valign == VALIGN_BOTTOM)
2791     sy = sy_base - height;
2792   else
2793     sy = sy_base - height / 2;
2794
2795   sx = MAX(0, MIN(sx, WIN_XSIZE - width));
2796   sy = MAX(0, MIN(sy, WIN_YSIZE - height));
2797
2798   if (add_border_size)
2799   {
2800     sx += border_size;
2801     sy += border_size;
2802   }
2803
2804   *x = sx;
2805   *y = sy;
2806 }
2807
2808 static void setRequestPosition(int *x, int *y, boolean add_border_size)
2809 {
2810   setRequestPositionExt(x, y, request.width, request.height, add_border_size);
2811 }
2812
2813 void DrawEnvelopeRequest(char *text)
2814 {
2815   char *text_final = text;
2816   char *text_door_style = NULL;
2817   int graphic = IMG_BACKGROUND_REQUEST;
2818   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
2819   int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
2820   int font_nr = FONT_REQUEST;
2821   int font_width = getFontWidth(font_nr);
2822   int font_height = getFontHeight(font_nr);
2823   int border_size = request.border_size;
2824   int line_spacing = request.line_spacing;
2825   int line_height = font_height + line_spacing;
2826   int max_text_width  = request.width  - 2 * border_size;
2827   int max_text_height = request.height - 2 * border_size;
2828   int line_length = max_text_width  / font_width;
2829   int max_lines   = max_text_height / line_height;
2830   int text_width = line_length * font_width;
2831   int width = request.width;
2832   int height = request.height;
2833   int tile_size = MAX(request.step_offset, 1);
2834   int x_steps = width  / tile_size;
2835   int y_steps = height / tile_size;
2836   int sx_offset = border_size;
2837   int sy_offset = border_size;
2838   int sx, sy;
2839   int i, x, y;
2840
2841   if (request.centered)
2842     sx_offset = (request.width - text_width) / 2;
2843
2844   if (request.wrap_single_words && !request.autowrap)
2845   {
2846     char *src_text_ptr, *dst_text_ptr;
2847
2848     text_door_style = checked_malloc(2 * strlen(text) + 1);
2849
2850     src_text_ptr = text;
2851     dst_text_ptr = text_door_style;
2852
2853     while (*src_text_ptr)
2854     {
2855       if (*src_text_ptr == ' ' ||
2856           *src_text_ptr == '?' ||
2857           *src_text_ptr == '!')
2858         *dst_text_ptr++ = '\n';
2859
2860       if (*src_text_ptr != ' ')
2861         *dst_text_ptr++ = *src_text_ptr;
2862
2863       src_text_ptr++;
2864     }
2865
2866     *dst_text_ptr = '\0';
2867
2868     text_final = text_door_style;
2869   }
2870
2871   setRequestPosition(&sx, &sy, FALSE);
2872
2873   ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
2874
2875   for (y = 0; y < y_steps; y++)
2876     for (x = 0; x < x_steps; x++)
2877       DrawEnvelopeBackgroundTiles(graphic, sx, sy,
2878                                   x, y, x_steps, y_steps,
2879                                   tile_size, tile_size);
2880
2881   /* force DOOR font inside door area */
2882   SetFontStatus(GAME_MODE_PSEUDO_DOOR);
2883
2884   DrawTextBuffer(sx + sx_offset, sy + sy_offset, text_final, font_nr,
2885                  line_length, -1, max_lines, line_spacing, mask_mode,
2886                  request.autowrap, request.centered, FALSE);
2887
2888   ResetFontStatus();
2889
2890   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
2891     RedrawGadget(tool_gadget[i]);
2892
2893   // store readily prepared envelope request for later use when animating
2894   BlitBitmap(backbuffer, bitmap_db_store_2, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
2895
2896   if (text_door_style)
2897     free(text_door_style);
2898 }
2899
2900 void AnimateEnvelopeRequest(int anim_mode, int action)
2901 {
2902   int graphic = IMG_BACKGROUND_REQUEST;
2903   boolean draw_masked = graphic_info[graphic].draw_masked;
2904   int delay_value_normal = request.step_delay;
2905   int delay_value_fast = delay_value_normal / 2;
2906   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2907   boolean no_delay = (tape.warp_forward);
2908   int delay_value = (ffwd_delay ? delay_value_fast : delay_value_normal);
2909   int anim_delay_value = MAX(1, (no_delay ? 0 : delay_value + 500 * 0) / 2);
2910   unsigned int anim_delay = 0;
2911
2912   int tile_size = MAX(request.step_offset, 1);
2913   int max_xsize = request.width  / tile_size;
2914   int max_ysize = request.height / tile_size;
2915   int max_xsize_inner = max_xsize - 2;
2916   int max_ysize_inner = max_ysize - 2;
2917
2918   int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize_inner : 0);
2919   int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize_inner : 0);
2920   int xend = max_xsize_inner;
2921   int yend = (anim_mode != ANIM_DEFAULT ? max_ysize_inner : 0);
2922   int xstep = (xstart < xend ? 1 : 0);
2923   int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
2924   int start = 0;
2925   int end = MAX(xend - xstart, yend - ystart);
2926   int i;
2927
2928   if (setup.quick_doors)
2929   {
2930     xstart = xend;
2931     ystart = yend;
2932     end = 0;
2933   }
2934
2935   for (i = start; i <= end; i++)
2936   {
2937     int last_frame = end;       // last frame of this "for" loop
2938     int x = xstart + i * xstep;
2939     int y = ystart + i * ystep;
2940     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
2941     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
2942     int xsize_size_left = (xsize - 1) * tile_size;
2943     int ysize_size_top  = (ysize - 1) * tile_size;
2944     int max_xsize_pos = (max_xsize - 1) * tile_size;
2945     int max_ysize_pos = (max_ysize - 1) * tile_size;
2946     int width  = xsize * tile_size;
2947     int height = ysize * tile_size;
2948     int src_x, src_y;
2949     int dst_x, dst_y;
2950     int xx, yy;
2951
2952     setRequestPosition(&src_x, &src_y, FALSE);
2953     setRequestPositionExt(&dst_x, &dst_y, width, height, FALSE);
2954
2955     BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
2956
2957     for (yy = 0; yy < 2; yy++)
2958     {
2959       for (xx = 0; xx < 2; xx++)
2960       {
2961         int src_xx = src_x + xx * max_xsize_pos;
2962         int src_yy = src_y + yy * max_ysize_pos;
2963         int dst_xx = dst_x + xx * xsize_size_left;
2964         int dst_yy = dst_y + yy * ysize_size_top;
2965         int xx_size = (xx ? tile_size : xsize_size_left);
2966         int yy_size = (yy ? tile_size : ysize_size_top);
2967
2968         if (draw_masked)
2969           BlitBitmapMasked(bitmap_db_store_2, backbuffer,
2970                            src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
2971         else
2972           BlitBitmap(bitmap_db_store_2, backbuffer,
2973                      src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
2974       }
2975     }
2976
2977     redraw_mask |= REDRAW_FIELD;
2978
2979     BackToFront();
2980
2981     SkipUntilDelayReached(&anim_delay, anim_delay_value, &i, last_frame);
2982   }
2983 }
2984
2985 void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
2986 {
2987   int graphic = IMG_BACKGROUND_REQUEST;
2988   int sound_opening = SND_REQUEST_OPENING;
2989   int sound_closing = SND_REQUEST_CLOSING;
2990   int anim_mode_1 = request.anim_mode;                  /* (higher priority) */
2991   int anim_mode_2 = graphic_info[graphic].anim_mode;    /* (lower priority) */
2992   int anim_mode = (anim_mode_1 != ANIM_DEFAULT ? anim_mode_1 : anim_mode_2);
2993   int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
2994                         anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
2995
2996   if (game_status == GAME_MODE_PLAYING)
2997     BlitScreenToBitmap(backbuffer);
2998
2999   SetDrawtoField(DRAW_TO_BACKBUFFER);
3000
3001   // SetDrawBackgroundMask(REDRAW_NONE);
3002
3003   if (action == ACTION_OPENING)
3004   {
3005     BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3006
3007     if (req_state & REQ_ASK)
3008     {
3009       MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
3010       MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
3011     }
3012     else if (req_state & REQ_CONFIRM)
3013     {
3014       MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
3015     }
3016     else if (req_state & REQ_PLAYER)
3017     {
3018       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
3019       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
3020       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
3021       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
3022     }
3023
3024     DrawEnvelopeRequest(text);
3025   }
3026
3027   game.envelope_active = TRUE;  /* needed for RedrawPlayfield() events */
3028
3029   if (action == ACTION_OPENING)
3030   {
3031     PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
3032
3033     if (anim_mode == ANIM_DEFAULT)
3034       AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
3035
3036     AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
3037   }
3038   else
3039   {
3040     PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
3041
3042     if (anim_mode != ANIM_NONE)
3043       AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
3044
3045     if (anim_mode == ANIM_DEFAULT)
3046       AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
3047   }
3048
3049   game.envelope_active = FALSE;
3050
3051   if (action == ACTION_CLOSING)
3052     BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3053
3054   // SetDrawBackgroundMask(last_draw_background_mask);
3055
3056   redraw_mask |= REDRAW_FIELD;
3057
3058   BackToFront();
3059
3060   if (action == ACTION_CLOSING &&
3061       game_status == GAME_MODE_PLAYING &&
3062       level.game_engine_type == GAME_ENGINE_TYPE_RND)
3063     SetDrawtoField(DRAW_TO_FIELDBUFFER);
3064 }
3065
3066 void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
3067 {
3068   if (IS_MM_WALL(element))
3069   {
3070     DrawSizedWall_MM(dst_x, dst_y, element, tilesize, el2preimg);
3071   }
3072   else
3073   {
3074     Bitmap *src_bitmap;
3075     int src_x, src_y;
3076     int graphic = el2preimg(element);
3077
3078     getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
3079     BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize,
3080                dst_x, dst_y);
3081   }
3082 }
3083
3084 void DrawLevel(int draw_background_mask)
3085 {
3086   int x,y;
3087
3088   SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
3089   SetDrawBackgroundMask(draw_background_mask);
3090
3091   ClearField();
3092
3093   for (x = BX1; x <= BX2; x++)
3094     for (y = BY1; y <= BY2; y++)
3095       DrawScreenField(x, y);
3096
3097   redraw_mask |= REDRAW_FIELD;
3098 }
3099
3100 void DrawSizedLevel(int size_x, int size_y, int scroll_x, int scroll_y,
3101                     int tilesize)
3102 {
3103   int x,y;
3104
3105   for (x = 0; x < size_x; x++)
3106     for (y = 0; y < size_y; y++)
3107       DrawSizedElementOrWall(x, y, scroll_x, scroll_y, tilesize);
3108
3109   redraw_mask |= REDRAW_FIELD;
3110 }
3111
3112 void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
3113 {
3114   int x,y;
3115
3116   for (x = 0; x < size_x; x++)
3117     for (y = 0; y < size_y; y++)
3118       DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
3119
3120   redraw_mask |= REDRAW_FIELD;
3121 }
3122
3123 static void DrawPreviewLevelPlayfield(int from_x, int from_y)
3124 {
3125   boolean show_level_border = (BorderElement != EL_EMPTY);
3126   int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3127   int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3128   int tile_size = preview.tile_size;
3129   int preview_width  = preview.xsize * tile_size;
3130   int preview_height = preview.ysize * tile_size;
3131   int real_preview_xsize = MIN(level_xsize, preview.xsize);
3132   int real_preview_ysize = MIN(level_ysize, preview.ysize);
3133   int real_preview_width  = real_preview_xsize * tile_size;
3134   int real_preview_height = real_preview_ysize * tile_size;
3135   int dst_x = SX + ALIGNED_XPOS(preview.x, preview_width, preview.align);
3136   int dst_y = SY + ALIGNED_YPOS(preview.y, preview_height, preview.valign);
3137   int x, y;
3138
3139   if (!IN_GFX_FIELD_FULL(dst_x, dst_y + preview_height - 1))
3140     return;
3141
3142   DrawBackground(dst_x, dst_y, preview_width, preview_height);
3143
3144   dst_x += (preview_width  - real_preview_width)  / 2;
3145   dst_y += (preview_height - real_preview_height) / 2;
3146
3147   for (x = 0; x < real_preview_xsize; x++)
3148   {
3149     for (y = 0; y < real_preview_ysize; y++)
3150     {
3151       int lx = from_x + x + (show_level_border ? -1 : 0);
3152       int ly = from_y + y + (show_level_border ? -1 : 0);
3153       int element = (IN_LEV_FIELD(lx, ly) ? level.field[lx][ly] :
3154                      getBorderElement(lx, ly));
3155
3156       DrawPreviewElement(dst_x + x * tile_size, dst_y + y * tile_size,
3157                          element, tile_size);
3158     }
3159   }
3160
3161   redraw_mask |= REDRAW_FIELD;
3162 }
3163
3164 #define MICROLABEL_EMPTY                0
3165 #define MICROLABEL_LEVEL_NAME           1
3166 #define MICROLABEL_LEVEL_AUTHOR_HEAD    2
3167 #define MICROLABEL_LEVEL_AUTHOR         3
3168 #define MICROLABEL_IMPORTED_FROM_HEAD   4
3169 #define MICROLABEL_IMPORTED_FROM        5
3170 #define MICROLABEL_IMPORTED_BY_HEAD     6
3171 #define MICROLABEL_IMPORTED_BY          7
3172
3173 static int getMaxTextLength(struct TextPosInfo *pos, int font_nr)
3174 {
3175   int max_text_width = SXSIZE;
3176   int font_width = getFontWidth(font_nr);
3177
3178   if (pos->align == ALIGN_CENTER)
3179     max_text_width = (pos->x < SXSIZE / 2 ? pos->x * 2 : (SXSIZE - pos->x) * 2);
3180   else if (pos->align == ALIGN_RIGHT)
3181     max_text_width = pos->x;
3182   else
3183     max_text_width = SXSIZE - pos->x;
3184
3185   return max_text_width / font_width;
3186 }
3187
3188 static void DrawPreviewLevelLabelExt(int mode, struct TextPosInfo *pos)
3189 {
3190   char label_text[MAX_OUTPUT_LINESIZE + 1];
3191   int max_len_label_text;
3192   int font_nr = pos->font;
3193   int i;
3194
3195   if (!IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3196     return;
3197
3198   if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
3199       mode == MICROLABEL_IMPORTED_FROM_HEAD ||
3200       mode == MICROLABEL_IMPORTED_BY_HEAD)
3201     font_nr = pos->font_alt;
3202
3203   max_len_label_text = getMaxTextLength(pos, font_nr);
3204
3205   if (pos->size != -1)
3206     max_len_label_text = pos->size;
3207
3208   for (i = 0; i < max_len_label_text; i++)
3209     label_text[i] = ' ';
3210   label_text[max_len_label_text] = '\0';
3211
3212   if (strlen(label_text) > 0)
3213     DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3214
3215   strncpy(label_text,
3216           (mode == MICROLABEL_LEVEL_NAME ? level.name :
3217            mode == MICROLABEL_LEVEL_AUTHOR_HEAD ? "created by" :
3218            mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
3219            mode == MICROLABEL_IMPORTED_FROM_HEAD ? "imported from" :
3220            mode == MICROLABEL_IMPORTED_FROM ? leveldir_current->imported_from :
3221            mode == MICROLABEL_IMPORTED_BY_HEAD ? "imported by" :
3222            mode == MICROLABEL_IMPORTED_BY ? leveldir_current->imported_by :""),
3223           max_len_label_text);
3224   label_text[max_len_label_text] = '\0';
3225
3226   if (strlen(label_text) > 0)
3227     DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3228
3229   redraw_mask |= REDRAW_FIELD;
3230 }
3231
3232 static void DrawPreviewLevelLabel(int mode)
3233 {
3234   DrawPreviewLevelLabelExt(mode, &menu.main.text.level_info_2);
3235 }
3236
3237 static void DrawPreviewLevelInfo(int mode)
3238 {
3239   if (mode == MICROLABEL_LEVEL_NAME)
3240     DrawPreviewLevelLabelExt(mode, &menu.main.text.level_name);
3241   else if (mode == MICROLABEL_LEVEL_AUTHOR)
3242     DrawPreviewLevelLabelExt(mode, &menu.main.text.level_author);
3243 }
3244
3245 static void DrawPreviewLevelExt(boolean restart)
3246 {
3247   static unsigned int scroll_delay = 0;
3248   static unsigned int label_delay = 0;
3249   static int from_x, from_y, scroll_direction;
3250   static int label_state, label_counter;
3251   unsigned int scroll_delay_value = preview.step_delay;
3252   boolean show_level_border = (BorderElement != EL_EMPTY);
3253   int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3254   int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3255
3256   if (restart)
3257   {
3258     from_x = 0;
3259     from_y = 0;
3260
3261     if (preview.anim_mode == ANIM_CENTERED)
3262     {
3263       if (level_xsize > preview.xsize)
3264         from_x = (level_xsize - preview.xsize) / 2;
3265       if (level_ysize > preview.ysize)
3266         from_y = (level_ysize - preview.ysize) / 2;
3267     }
3268
3269     from_x += preview.xoffset;
3270     from_y += preview.yoffset;
3271
3272     scroll_direction = MV_RIGHT;
3273     label_state = 1;
3274     label_counter = 0;
3275
3276     DrawPreviewLevelPlayfield(from_x, from_y);
3277     DrawPreviewLevelLabel(label_state);
3278
3279     DrawPreviewLevelInfo(MICROLABEL_LEVEL_NAME);
3280     DrawPreviewLevelInfo(MICROLABEL_LEVEL_AUTHOR);
3281
3282     /* initialize delay counters */
3283     DelayReached(&scroll_delay, 0);
3284     DelayReached(&label_delay, 0);
3285
3286     if (leveldir_current->name)
3287     {
3288       struct TextPosInfo *pos = &menu.main.text.level_info_1;
3289       char label_text[MAX_OUTPUT_LINESIZE + 1];
3290       int font_nr = pos->font;
3291       int max_len_label_text = getMaxTextLength(pos, font_nr);
3292
3293       if (pos->size != -1)
3294         max_len_label_text = pos->size;
3295
3296       strncpy(label_text, leveldir_current->name, max_len_label_text);
3297       label_text[max_len_label_text] = '\0';
3298
3299       if (IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3300         DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3301     }
3302
3303     return;
3304   }
3305
3306   /* scroll preview level, if needed */
3307   if (preview.anim_mode != ANIM_NONE &&
3308       (level_xsize > preview.xsize || level_ysize > preview.ysize) &&
3309       DelayReached(&scroll_delay, scroll_delay_value))
3310   {
3311     switch (scroll_direction)
3312     {
3313       case MV_LEFT:
3314         if (from_x > 0)
3315         {
3316           from_x -= preview.step_offset;
3317           from_x = (from_x < 0 ? 0 : from_x);
3318         }
3319         else
3320           scroll_direction = MV_UP;
3321         break;
3322
3323       case MV_RIGHT:
3324         if (from_x < level_xsize - preview.xsize)
3325         {
3326           from_x += preview.step_offset;
3327           from_x = (from_x > level_xsize - preview.xsize ?
3328                     level_xsize - preview.xsize : from_x);
3329         }
3330         else
3331           scroll_direction = MV_DOWN;
3332         break;
3333
3334       case MV_UP:
3335         if (from_y > 0)
3336         {
3337           from_y -= preview.step_offset;
3338           from_y = (from_y < 0 ? 0 : from_y);
3339         }
3340         else
3341           scroll_direction = MV_RIGHT;
3342         break;
3343
3344       case MV_DOWN:
3345         if (from_y < level_ysize - preview.ysize)
3346         {
3347           from_y += preview.step_offset;
3348           from_y = (from_y > level_ysize - preview.ysize ?
3349                     level_ysize - preview.ysize : from_y);
3350         }
3351         else
3352           scroll_direction = MV_LEFT;
3353         break;
3354
3355       default:
3356         break;
3357     }
3358
3359     DrawPreviewLevelPlayfield(from_x, from_y);
3360   }
3361
3362   /* !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!! */
3363   /* redraw micro level label, if needed */
3364   if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
3365       !strEqual(level.author, ANONYMOUS_NAME) &&
3366       !strEqual(level.author, leveldir_current->name) &&
3367       DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
3368   {
3369     int max_label_counter = 23;
3370
3371     if (leveldir_current->imported_from != NULL &&
3372         strlen(leveldir_current->imported_from) > 0)
3373       max_label_counter += 14;
3374     if (leveldir_current->imported_by != NULL &&
3375         strlen(leveldir_current->imported_by) > 0)
3376       max_label_counter += 14;
3377
3378     label_counter = (label_counter + 1) % max_label_counter;
3379     label_state = (label_counter >= 0 && label_counter <= 7 ?
3380                    MICROLABEL_LEVEL_NAME :
3381                    label_counter >= 9 && label_counter <= 12 ?
3382                    MICROLABEL_LEVEL_AUTHOR_HEAD :
3383                    label_counter >= 14 && label_counter <= 21 ?
3384                    MICROLABEL_LEVEL_AUTHOR :
3385                    label_counter >= 23 && label_counter <= 26 ?
3386                    MICROLABEL_IMPORTED_FROM_HEAD :
3387                    label_counter >= 28 && label_counter <= 35 ?
3388                    MICROLABEL_IMPORTED_FROM :
3389                    label_counter >= 37 && label_counter <= 40 ?
3390                    MICROLABEL_IMPORTED_BY_HEAD :
3391                    label_counter >= 42 && label_counter <= 49 ?
3392                    MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
3393
3394     if (leveldir_current->imported_from == NULL &&
3395         (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
3396          label_state == MICROLABEL_IMPORTED_FROM))
3397       label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
3398                      MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
3399
3400     DrawPreviewLevelLabel(label_state);
3401   }
3402 }
3403
3404 void DrawPreviewLevelInitial()
3405 {
3406   DrawPreviewLevelExt(TRUE);
3407 }
3408
3409 void DrawPreviewLevelAnimation()
3410 {
3411   DrawPreviewLevelExt(FALSE);
3412 }
3413
3414 inline static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3415                                            int graphic, int sync_frame,
3416                                            int mask_mode)
3417 {
3418   int frame = getGraphicAnimationFrame(graphic, sync_frame);
3419
3420   if (mask_mode == USE_MASKING)
3421     DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3422   else
3423     DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
3424 }
3425
3426 void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3427                                   int graphic, int sync_frame, int mask_mode)
3428 {
3429   int frame = getGraphicAnimationFrame(graphic, sync_frame);
3430
3431   if (mask_mode == USE_MASKING)
3432     DrawFixedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3433   else
3434     DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame);
3435 }
3436
3437 inline static void DrawGraphicAnimation(int x, int y, int graphic)
3438 {
3439   int lx = LEVELX(x), ly = LEVELY(y);
3440
3441   if (!IN_SCR_FIELD(x, y))
3442     return;
3443
3444   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
3445                           graphic, GfxFrame[lx][ly], NO_MASKING);
3446
3447   MarkTileDirty(x, y);
3448 }
3449
3450 void DrawFixedGraphicAnimation(int x, int y, int graphic)
3451 {
3452   int lx = LEVELX(x), ly = LEVELY(y);
3453
3454   if (!IN_SCR_FIELD(x, y))
3455     return;
3456
3457   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
3458                           graphic, GfxFrame[lx][ly], NO_MASKING);
3459   MarkTileDirty(x, y);
3460 }
3461
3462 void DrawLevelGraphicAnimation(int x, int y, int graphic)
3463 {
3464   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3465 }
3466
3467 void DrawLevelElementAnimation(int x, int y, int element)
3468 {
3469   int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
3470
3471   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3472 }
3473
3474 void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
3475 {
3476   int sx = SCREENX(x), sy = SCREENY(y);
3477
3478   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
3479     return;
3480
3481   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
3482     return;
3483
3484   DrawGraphicAnimation(sx, sy, graphic);
3485
3486 #if 1
3487   if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
3488     DrawLevelFieldCrumbled(x, y);
3489 #else
3490   if (GFX_CRUMBLED(Feld[x][y]))
3491     DrawLevelFieldCrumbled(x, y);
3492 #endif
3493 }
3494
3495 void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
3496 {
3497   int sx = SCREENX(x), sy = SCREENY(y);
3498   int graphic;
3499
3500   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
3501     return;
3502
3503   graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
3504
3505   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
3506     return;
3507
3508   DrawGraphicAnimation(sx, sy, graphic);
3509
3510   if (GFX_CRUMBLED(element))
3511     DrawLevelFieldCrumbled(x, y);
3512 }
3513
3514 static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
3515 {
3516   if (player->use_murphy)
3517   {
3518     /* this works only because currently only one player can be "murphy" ... */
3519     static int last_horizontal_dir = MV_LEFT;
3520     int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
3521
3522     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3523       last_horizontal_dir = move_dir;
3524
3525     if (graphic == IMG_SP_MURPHY)       /* undefined => use special graphic */
3526     {
3527       int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
3528
3529       graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
3530     }
3531
3532     return graphic;
3533   }
3534   else
3535     return el_act_dir2img(player->artwork_element, player->GfxAction,move_dir);
3536 }
3537
3538 static boolean equalGraphics(int graphic1, int graphic2)
3539 {
3540   struct GraphicInfo *g1 = &graphic_info[graphic1];
3541   struct GraphicInfo *g2 = &graphic_info[graphic2];
3542
3543   return (g1->bitmap      == g2->bitmap &&
3544           g1->src_x       == g2->src_x &&
3545           g1->src_y       == g2->src_y &&
3546           g1->anim_frames == g2->anim_frames &&
3547           g1->anim_delay  == g2->anim_delay &&
3548           g1->anim_mode   == g2->anim_mode);
3549 }
3550
3551 void DrawAllPlayers()
3552 {
3553   int i;
3554
3555   for (i = 0; i < MAX_PLAYERS; i++)
3556     if (stored_player[i].active)
3557       DrawPlayer(&stored_player[i]);
3558 }
3559
3560 void DrawPlayerField(int x, int y)
3561 {
3562   if (!IS_PLAYER(x, y))
3563     return;
3564
3565   DrawPlayer(PLAYERINFO(x, y));
3566 }
3567
3568 #define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
3569
3570 void DrawPlayer(struct PlayerInfo *player)
3571 {
3572   int jx = player->jx;
3573   int jy = player->jy;
3574   int move_dir = player->MovDir;
3575   int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
3576   int dy = (move_dir == MV_UP   ? -1 : move_dir == MV_DOWN  ? +1 : 0);
3577   int last_jx = (player->is_moving ? jx - dx : jx);
3578   int last_jy = (player->is_moving ? jy - dy : jy);
3579   int next_jx = jx + dx;
3580   int next_jy = jy + dy;
3581   boolean player_is_moving = (player->MovPos ? TRUE : FALSE);
3582   boolean player_is_opaque = FALSE;
3583   int sx = SCREENX(jx), sy = SCREENY(jy);
3584   int sxx = 0, syy = 0;
3585   int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
3586   int graphic;
3587   int action = ACTION_DEFAULT;
3588   int last_player_graphic = getPlayerGraphic(player, move_dir);
3589   int last_player_frame = player->Frame;
3590   int frame = 0;
3591
3592   /* GfxElement[][] is set to the element the player is digging or collecting;
3593      remove also for off-screen player if the player is not moving anymore */
3594   if (IN_LEV_FIELD(jx, jy) && !player_is_moving)
3595     GfxElement[jx][jy] = EL_UNDEFINED;
3596
3597   if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
3598     return;
3599
3600 #if DEBUG
3601   if (!IN_LEV_FIELD(jx, jy))
3602   {
3603     printf("DrawPlayerField(): x = %d, y = %d\n",jx,jy);
3604     printf("DrawPlayerField(): sx = %d, sy = %d\n",sx,sy);
3605     printf("DrawPlayerField(): This should never happen!\n");
3606     return;
3607   }
3608 #endif
3609
3610   if (element == EL_EXPLOSION)
3611     return;
3612
3613   action = (player->is_pushing    ? ACTION_PUSHING         :
3614             player->is_digging    ? ACTION_DIGGING         :
3615             player->is_collecting ? ACTION_COLLECTING      :
3616             player->is_moving     ? ACTION_MOVING          :
3617             player->is_snapping   ? ACTION_SNAPPING        :
3618             player->is_dropping   ? ACTION_DROPPING        :
3619             player->is_waiting    ? player->action_waiting : ACTION_DEFAULT);
3620
3621   if (player->is_waiting)
3622     move_dir = player->dir_waiting;
3623
3624   InitPlayerGfxAnimation(player, action, move_dir);
3625
3626   /* ----------------------------------------------------------------------- */
3627   /* draw things in the field the player is leaving, if needed               */
3628   /* ----------------------------------------------------------------------- */
3629
3630   if (player->is_moving)
3631   {
3632     if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
3633     {
3634       DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
3635
3636       if (last_element == EL_DYNAMITE_ACTIVE ||
3637           last_element == EL_EM_DYNAMITE_ACTIVE ||
3638           last_element == EL_SP_DISK_RED_ACTIVE)
3639         DrawDynamite(last_jx, last_jy);
3640       else
3641         DrawLevelFieldThruMask(last_jx, last_jy);
3642     }
3643     else if (last_element == EL_DYNAMITE_ACTIVE ||
3644              last_element == EL_EM_DYNAMITE_ACTIVE ||
3645              last_element == EL_SP_DISK_RED_ACTIVE)
3646       DrawDynamite(last_jx, last_jy);
3647 #if 0
3648     /* !!! this is not enough to prevent flickering of players which are
3649        moving next to each others without a free tile between them -- this
3650        can only be solved by drawing all players layer by layer (first the
3651        background, then the foreground etc.) !!! => TODO */
3652     else if (!IS_PLAYER(last_jx, last_jy))
3653       DrawLevelField(last_jx, last_jy);
3654 #else
3655     else
3656       DrawLevelField(last_jx, last_jy);
3657 #endif
3658
3659     if (player->is_pushing && IN_SCR_FIELD(SCREENX(next_jx), SCREENY(next_jy)))
3660       DrawLevelElement(next_jx, next_jy, EL_EMPTY);
3661   }
3662
3663   if (!IN_SCR_FIELD(sx, sy))
3664     return;
3665
3666   /* ----------------------------------------------------------------------- */
3667   /* draw things behind the player, if needed                                */
3668   /* ----------------------------------------------------------------------- */
3669
3670   if (Back[jx][jy])
3671     DrawLevelElement(jx, jy, Back[jx][jy]);
3672   else if (IS_ACTIVE_BOMB(element))
3673     DrawLevelElement(jx, jy, EL_EMPTY);
3674   else
3675   {
3676     if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
3677     {
3678       int old_element = GfxElement[jx][jy];
3679       int old_graphic = el_act_dir2img(old_element, action, move_dir);
3680       int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
3681
3682       if (GFX_CRUMBLED(old_element))
3683         DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
3684       else
3685         DrawGraphic(sx, sy, old_graphic, frame);
3686
3687       if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
3688         player_is_opaque = TRUE;
3689     }
3690     else
3691     {
3692       GfxElement[jx][jy] = EL_UNDEFINED;
3693
3694       /* make sure that pushed elements are drawn with correct frame rate */
3695       graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
3696
3697       if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
3698         GfxFrame[jx][jy] = player->StepFrame;
3699
3700       DrawLevelField(jx, jy);
3701     }
3702   }
3703
3704 #if !DRAW_PLAYER_OVER_PUSHED_ELEMENT
3705   /* ----------------------------------------------------------------------- */
3706   /* draw player himself                                                     */
3707   /* ----------------------------------------------------------------------- */
3708
3709   graphic = getPlayerGraphic(player, move_dir);
3710
3711   /* in the case of changed player action or direction, prevent the current
3712      animation frame from being restarted for identical animations */
3713   if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
3714     player->Frame = last_player_frame;
3715
3716   frame = getGraphicAnimationFrame(graphic, player->Frame);
3717
3718   if (player->GfxPos)
3719   {
3720     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3721       sxx = player->GfxPos;
3722     else
3723       syy = player->GfxPos;
3724   }
3725
3726   if (player_is_opaque)
3727     DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
3728   else
3729     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3730
3731   if (SHIELD_ON(player))
3732   {
3733     int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
3734                    IMG_SHIELD_NORMAL_ACTIVE);
3735     int frame = getGraphicAnimationFrame(graphic, -1);
3736
3737     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3738   }
3739 #endif
3740
3741 #if DRAW_PLAYER_OVER_PUSHED_ELEMENT
3742   if (player->GfxPos)
3743   {
3744     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3745       sxx = player->GfxPos;
3746     else
3747       syy = player->GfxPos;
3748   }
3749 #endif
3750
3751   /* ----------------------------------------------------------------------- */
3752   /* draw things the player is pushing, if needed                            */
3753   /* ----------------------------------------------------------------------- */
3754
3755   if (player->is_pushing && player->is_moving)
3756   {
3757     int px = SCREENX(jx), py = SCREENY(jy);
3758     int pxx = (TILEX - ABS(sxx)) * dx;
3759     int pyy = (TILEY - ABS(syy)) * dy;
3760     int gfx_frame = GfxFrame[jx][jy];
3761
3762     int graphic;
3763     int sync_frame;
3764     int frame;
3765
3766     if (!IS_MOVING(jx, jy))             /* push movement already finished */
3767     {
3768       element = Feld[next_jx][next_jy];
3769       gfx_frame = GfxFrame[next_jx][next_jy];
3770     }
3771
3772     graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
3773
3774     sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
3775     frame = getGraphicAnimationFrame(graphic, sync_frame);
3776
3777     /* draw background element under pushed element (like the Sokoban field) */
3778     if (game.use_masked_pushing && IS_MOVING(jx, jy))
3779     {
3780       /* this allows transparent pushing animation over non-black background */
3781
3782       if (Back[jx][jy])
3783         DrawLevelElement(jx, jy, Back[jx][jy]);
3784       else
3785         DrawLevelElement(jx, jy, EL_EMPTY);
3786
3787       if (Back[next_jx][next_jy])
3788         DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
3789       else
3790         DrawLevelElement(next_jx, next_jy, EL_EMPTY);
3791     }
3792     else if (Back[next_jx][next_jy])
3793       DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
3794
3795 #if 1
3796     /* do not draw (EM style) pushing animation when pushing is finished */
3797     /* (two-tile animations usually do not contain start and end frame) */
3798     if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
3799       DrawLevelElement(next_jx, next_jy, Feld[next_jx][next_jy]);
3800     else
3801       DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
3802 #else
3803     /* masked drawing is needed for EMC style (double) movement graphics */
3804     /* !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!! */
3805     DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
3806 #endif
3807   }
3808
3809 #if DRAW_PLAYER_OVER_PUSHED_ELEMENT
3810   /* ----------------------------------------------------------------------- */
3811   /* draw player himself                                                     */
3812   /* ----------------------------------------------------------------------- */
3813
3814   graphic = getPlayerGraphic(player, move_dir);
3815
3816   /* in the case of changed player action or direction, prevent the current
3817      animation frame from being restarted for identical animations */
3818   if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
3819     player->Frame = last_player_frame;
3820
3821   frame = getGraphicAnimationFrame(graphic, player->Frame);
3822
3823   if (player->GfxPos)
3824   {
3825     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3826       sxx = player->GfxPos;
3827     else
3828       syy = player->GfxPos;
3829   }
3830
3831   if (player_is_opaque)
3832     DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
3833   else
3834     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3835
3836   if (SHIELD_ON(player))
3837   {
3838     int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
3839                    IMG_SHIELD_NORMAL_ACTIVE);
3840     int frame = getGraphicAnimationFrame(graphic, -1);
3841
3842     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3843   }
3844 #endif
3845
3846   /* ----------------------------------------------------------------------- */
3847   /* draw things in front of player (active dynamite or dynabombs)           */
3848   /* ----------------------------------------------------------------------- */
3849
3850   if (IS_ACTIVE_BOMB(element))
3851   {
3852     graphic = el2img(element);
3853     frame = getGraphicAnimationFrame(graphic, GfxFrame[jx][jy]);
3854
3855     if (game.emulation == EMU_SUPAPLEX)
3856       DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
3857     else
3858       DrawGraphicThruMask(sx, sy, graphic, frame);
3859   }
3860
3861   if (player_is_moving && last_element == EL_EXPLOSION)
3862   {
3863     int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
3864                    GfxElement[last_jx][last_jy] :  EL_EMPTY);
3865     int graphic = el_act2img(element, ACTION_EXPLODING);
3866     int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
3867     int phase = ExplodePhase[last_jx][last_jy] - 1;
3868     int frame = getGraphicAnimationFrame(graphic, phase - delay);
3869
3870     if (phase >= delay)
3871       DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
3872   }
3873
3874   /* ----------------------------------------------------------------------- */
3875   /* draw elements the player is just walking/passing through/under          */
3876   /* ----------------------------------------------------------------------- */
3877
3878   if (player_is_moving)
3879   {
3880     /* handle the field the player is leaving ... */
3881     if (IS_ACCESSIBLE_INSIDE(last_element))
3882       DrawLevelField(last_jx, last_jy);
3883     else if (IS_ACCESSIBLE_UNDER(last_element))
3884       DrawLevelFieldThruMask(last_jx, last_jy);
3885   }
3886
3887   /* do not redraw accessible elements if the player is just pushing them */
3888   if (!player_is_moving || !player->is_pushing)
3889   {
3890     /* ... and the field the player is entering */
3891     if (IS_ACCESSIBLE_INSIDE(element))
3892       DrawLevelField(jx, jy);
3893     else if (IS_ACCESSIBLE_UNDER(element))
3894       DrawLevelFieldThruMask(jx, jy);
3895   }
3896
3897   MarkTileDirty(sx, sy);
3898 }
3899
3900 /* ------------------------------------------------------------------------- */
3901
3902 void WaitForEventToContinue()
3903 {
3904   boolean still_wait = TRUE;
3905
3906   if (program.headless)
3907     return;
3908
3909   /* simulate releasing mouse button over last gadget, if still pressed */
3910   if (button_status)
3911     HandleGadgets(-1, -1, 0);
3912
3913   button_status = MB_RELEASED;
3914
3915   ClearEventQueue();
3916
3917   while (still_wait)
3918   {
3919     Event event;
3920
3921     if (NextValidEvent(&event))
3922     {
3923       switch (event.type)
3924       {
3925         case EVENT_BUTTONPRESS:
3926         case EVENT_KEYPRESS:
3927 #if defined(TARGET_SDL2)
3928         case SDL_CONTROLLERBUTTONDOWN:
3929 #endif
3930         case SDL_JOYBUTTONDOWN:
3931           still_wait = FALSE;
3932           break;
3933
3934         case EVENT_KEYRELEASE:
3935           ClearPlayerAction();
3936           break;
3937
3938         default:
3939           HandleOtherEvents(&event);
3940           break;
3941       }
3942     }
3943     else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
3944     {
3945       still_wait = FALSE;
3946     }
3947
3948     BackToFront();
3949   }
3950 }
3951
3952 #define MAX_REQUEST_LINES               13
3953 #define MAX_REQUEST_LINE_FONT1_LEN      7
3954 #define MAX_REQUEST_LINE_FONT2_LEN      10
3955
3956 static int RequestHandleEvents(unsigned int req_state)
3957 {
3958   boolean level_solved = (game_status == GAME_MODE_PLAYING &&
3959                           local_player->LevelSolved_GameEnd);
3960   int width  = request.width;
3961   int height = request.height;
3962   int sx, sy;
3963   int result;
3964
3965   setRequestPosition(&sx, &sy, FALSE);
3966
3967   button_status = MB_RELEASED;
3968
3969   request_gadget_id = -1;
3970   result = -1;
3971
3972   while (result < 0)
3973   {
3974     if (level_solved)
3975     {
3976       /* the MM game engine does not use a special (scrollable) field buffer */
3977       if (level.game_engine_type != GAME_ENGINE_TYPE_MM)
3978         SetDrawtoField(DRAW_TO_FIELDBUFFER);
3979
3980       HandleGameActions();
3981
3982       SetDrawtoField(DRAW_TO_BACKBUFFER);
3983
3984       if (global.use_envelope_request)
3985       {
3986         /* copy current state of request area to middle of playfield area */
3987         BlitBitmap(bitmap_db_store_2, drawto, sx, sy, width, height, sx, sy);
3988       }
3989     }
3990
3991     if (PendingEvent())
3992     {
3993       Event event;
3994
3995       while (NextValidEvent(&event))
3996       {
3997         switch (event.type)
3998         {
3999           case EVENT_BUTTONPRESS:
4000           case EVENT_BUTTONRELEASE:
4001           case EVENT_MOTIONNOTIFY:
4002           {
4003             int mx, my;
4004
4005             if (event.type == EVENT_MOTIONNOTIFY)
4006             {
4007               if (!button_status)
4008                 continue;
4009
4010               motion_status = TRUE;
4011               mx = ((MotionEvent *) &event)->x;
4012               my = ((MotionEvent *) &event)->y;
4013             }
4014             else
4015             {
4016               motion_status = FALSE;
4017               mx = ((ButtonEvent *) &event)->x;
4018               my = ((ButtonEvent *) &event)->y;
4019               if (event.type == EVENT_BUTTONPRESS)
4020                 button_status = ((ButtonEvent *) &event)->button;
4021               else
4022                 button_status = MB_RELEASED;
4023             }
4024
4025             /* this sets 'request_gadget_id' */
4026             HandleGadgets(mx, my, button_status);
4027
4028             switch (request_gadget_id)
4029             {
4030               case TOOL_CTRL_ID_YES:
4031                 result = TRUE;
4032                 break;
4033               case TOOL_CTRL_ID_NO:
4034                 result = FALSE;
4035                 break;
4036               case TOOL_CTRL_ID_CONFIRM:
4037                 result = TRUE | FALSE;
4038                 break;
4039
4040               case TOOL_CTRL_ID_PLAYER_1:
4041                 result = 1;
4042                 break;
4043               case TOOL_CTRL_ID_PLAYER_2:
4044                 result = 2;
4045                 break;
4046               case TOOL_CTRL_ID_PLAYER_3:
4047                 result = 3;
4048                 break;
4049               case TOOL_CTRL_ID_PLAYER_4:
4050                 result = 4;
4051                 break;
4052
4053               default:
4054                 break;
4055             }
4056
4057             break;
4058           }
4059
4060 #if defined(TARGET_SDL2)
4061           case SDL_WINDOWEVENT:
4062             HandleWindowEvent((WindowEvent *) &event);
4063             break;
4064
4065           case SDL_APP_WILLENTERBACKGROUND:
4066           case SDL_APP_DIDENTERBACKGROUND:
4067           case SDL_APP_WILLENTERFOREGROUND:
4068           case SDL_APP_DIDENTERFOREGROUND:
4069             HandlePauseResumeEvent((PauseResumeEvent *) &event);
4070             break;
4071 #endif
4072
4073           case EVENT_KEYPRESS:
4074           {
4075             Key key = GetEventKey((KeyEvent *)&event, TRUE);
4076
4077             switch (key)
4078             {
4079               case KSYM_space:
4080                 if (req_state & REQ_CONFIRM)
4081                   result = 1;
4082                 break;
4083
4084               case KSYM_Return:
4085 #if defined(TARGET_SDL2)
4086               case KSYM_Select:
4087               case KSYM_Menu:
4088 #if defined(KSYM_Rewind)
4089               case KSYM_Rewind:         /* for Amazon Fire TV remote */
4090 #endif
4091 #endif
4092                 result = 1;
4093                 break;
4094
4095               case KSYM_Escape:
4096 #if defined(TARGET_SDL2)
4097               case KSYM_Back:
4098 #if defined(KSYM_FastForward)
4099               case KSYM_FastForward:    /* for Amazon Fire TV remote */
4100 #endif
4101 #endif
4102                 result = 0;
4103                 break;
4104
4105               default:
4106                 HandleKeysDebug(key);
4107                 break;
4108             }
4109
4110             if (req_state & REQ_PLAYER)
4111               result = 0;
4112
4113             break;
4114           }
4115
4116           case EVENT_KEYRELEASE:
4117             ClearPlayerAction();
4118             break;
4119
4120 #if defined(TARGET_SDL2)
4121           case SDL_CONTROLLERBUTTONDOWN:
4122             switch (event.cbutton.button)
4123             {
4124               case SDL_CONTROLLER_BUTTON_A:
4125               case SDL_CONTROLLER_BUTTON_X:
4126               case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
4127                 result = 1;
4128                 break;
4129
4130               case SDL_CONTROLLER_BUTTON_B:
4131               case SDL_CONTROLLER_BUTTON_Y:
4132               case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
4133               case SDL_CONTROLLER_BUTTON_BACK:
4134                 result = 0;
4135                 break;
4136             }
4137
4138             if (req_state & REQ_PLAYER)
4139               result = 0;
4140
4141             break;
4142
4143           case SDL_CONTROLLERBUTTONUP:
4144             HandleJoystickEvent(&event);
4145             ClearPlayerAction();
4146             break;
4147 #endif
4148
4149           default:
4150             HandleOtherEvents(&event);
4151             break;
4152         }
4153       }
4154     }
4155     else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4156     {
4157       int joy = AnyJoystick();
4158
4159       if (joy & JOY_BUTTON_1)
4160         result = 1;
4161       else if (joy & JOY_BUTTON_2)
4162         result = 0;
4163     }
4164
4165     if (level_solved)
4166     {
4167       if (global.use_envelope_request)
4168       {
4169         /* copy back current state of pressed buttons inside request area */
4170         BlitBitmap(drawto, bitmap_db_store_2, sx, sy, width, height, sx, sy);
4171       }
4172     }
4173
4174     BackToFront();
4175   }
4176
4177   return result;
4178 }
4179
4180 static boolean RequestDoor(char *text, unsigned int req_state)
4181 {
4182   unsigned int old_door_state;
4183   int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN;
4184   int font_nr = FONT_TEXT_2;
4185   char *text_ptr;
4186   int result;
4187   int ty;
4188
4189   if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN)
4190   {
4191     max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
4192     font_nr = FONT_TEXT_1;
4193   }
4194
4195   if (game_status == GAME_MODE_PLAYING)
4196     BlitScreenToBitmap(backbuffer);
4197
4198   /* disable deactivated drawing when quick-loading level tape recording */
4199   if (tape.playing && tape.deactivate_display)
4200     TapeDeactivateDisplayOff(TRUE);
4201
4202   SetMouseCursor(CURSOR_DEFAULT);
4203
4204 #if defined(NETWORK_AVALIABLE)
4205   /* pause network game while waiting for request to answer */
4206   if (options.network &&
4207       game_status == GAME_MODE_PLAYING &&
4208       req_state & REQUEST_WAIT_FOR_INPUT)
4209     SendToServer_PausePlaying();
4210 #endif
4211
4212   old_door_state = GetDoorState();
4213
4214   /* simulate releasing mouse button over last gadget, if still pressed */
4215   if (button_status)
4216     HandleGadgets(-1, -1, 0);
4217
4218   UnmapAllGadgets();
4219
4220   /* draw released gadget before proceeding */
4221   // BackToFront();
4222
4223   if (old_door_state & DOOR_OPEN_1)
4224   {
4225     CloseDoor(DOOR_CLOSE_1);
4226
4227     /* save old door content */
4228     BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
4229                0 * DXSIZE, 0, DXSIZE, DYSIZE, 1 * DXSIZE, 0);
4230   }
4231
4232   SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
4233   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4234
4235   /* clear door drawing field */
4236   DrawBackground(DX, DY, DXSIZE, DYSIZE);
4237
4238   /* force DOOR font inside door area */
4239   SetFontStatus(GAME_MODE_PSEUDO_DOOR);
4240
4241   /* write text for request */
4242   for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
4243   {
4244     char text_line[max_request_line_len + 1];
4245     int tx, tl, tc = 0;
4246
4247     if (!*text_ptr)
4248       break;
4249
4250     for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
4251     {
4252       tc = *(text_ptr + tx);
4253       // if (!tc || tc == ' ')
4254       if (!tc || tc == ' ' || tc == '?' || tc == '!')
4255         break;
4256     }
4257
4258     if ((tc == '?' || tc == '!') && tl == 0)
4259       tl = 1;
4260
4261     if (!tl)
4262     {
4263       text_ptr++;
4264       ty--;
4265       continue;
4266     }
4267
4268     strncpy(text_line, text_ptr, tl);
4269     text_line[tl] = 0;
4270
4271     DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
4272              DY + 8 + ty * (getFontHeight(font_nr) + 2),
4273              text_line, font_nr);
4274
4275     text_ptr += tl + (tc == ' ' ? 1 : 0);
4276     // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
4277   }
4278
4279   ResetFontStatus();
4280
4281   if (req_state & REQ_ASK)
4282   {
4283     MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
4284     MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
4285   }
4286   else if (req_state & REQ_CONFIRM)
4287   {
4288     MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
4289   }
4290   else if (req_state & REQ_PLAYER)
4291   {
4292     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
4293     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
4294     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
4295     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
4296   }
4297
4298   /* copy request gadgets to door backbuffer */
4299   BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4300
4301   OpenDoor(DOOR_OPEN_1);
4302
4303   if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4304   {
4305     if (game_status == GAME_MODE_PLAYING)
4306     {
4307       SetPanelBackground();
4308       SetDrawBackgroundMask(REDRAW_DOOR_1);
4309     }
4310     else
4311     {
4312       SetDrawBackgroundMask(REDRAW_FIELD);
4313     }
4314
4315     return FALSE;
4316   }
4317
4318   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4319
4320   // ---------- handle request buttons ----------
4321   result = RequestHandleEvents(req_state);
4322
4323   UnmapToolButtons();
4324
4325   if (!(req_state & REQ_STAY_OPEN))
4326   {
4327     CloseDoor(DOOR_CLOSE_1);
4328
4329     if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
4330         (req_state & REQ_REOPEN))
4331       OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
4332   }
4333
4334   RemapAllGadgets();
4335
4336   if (game_status == GAME_MODE_PLAYING)
4337   {
4338     SetPanelBackground();
4339     SetDrawBackgroundMask(REDRAW_DOOR_1);
4340   }
4341   else
4342   {
4343     SetDrawBackgroundMask(REDRAW_FIELD);
4344   }
4345
4346 #if defined(NETWORK_AVALIABLE)
4347   /* continue network game after request */
4348   if (options.network &&
4349       game_status == GAME_MODE_PLAYING &&
4350       req_state & REQUEST_WAIT_FOR_INPUT)
4351     SendToServer_ContinuePlaying();
4352 #endif
4353
4354   /* restore deactivated drawing when quick-loading level tape recording */
4355   if (tape.playing && tape.deactivate_display)
4356     TapeDeactivateDisplayOn();
4357
4358   return result;
4359 }
4360
4361 static boolean RequestEnvelope(char *text, unsigned int req_state)
4362 {
4363   int result;
4364
4365   if (game_status == GAME_MODE_PLAYING)
4366     BlitScreenToBitmap(backbuffer);
4367
4368   /* disable deactivated drawing when quick-loading level tape recording */
4369   if (tape.playing && tape.deactivate_display)
4370     TapeDeactivateDisplayOff(TRUE);
4371
4372   SetMouseCursor(CURSOR_DEFAULT);
4373
4374 #if defined(NETWORK_AVALIABLE)
4375   /* pause network game while waiting for request to answer */
4376   if (options.network &&
4377       game_status == GAME_MODE_PLAYING &&
4378       req_state & REQUEST_WAIT_FOR_INPUT)
4379     SendToServer_PausePlaying();
4380 #endif
4381
4382   /* simulate releasing mouse button over last gadget, if still pressed */
4383   if (button_status)
4384     HandleGadgets(-1, -1, 0);
4385
4386   UnmapAllGadgets();
4387
4388   // (replace with setting corresponding request background)
4389   // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
4390   // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4391
4392   /* clear door drawing field */
4393   // DrawBackground(DX, DY, DXSIZE, DYSIZE);
4394
4395   ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
4396
4397   if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4398   {
4399     if (game_status == GAME_MODE_PLAYING)
4400     {
4401       SetPanelBackground();
4402       SetDrawBackgroundMask(REDRAW_DOOR_1);
4403     }
4404     else
4405     {
4406       SetDrawBackgroundMask(REDRAW_FIELD);
4407     }
4408
4409     return FALSE;
4410   }
4411
4412   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4413
4414   // ---------- handle request buttons ----------
4415   result = RequestHandleEvents(req_state);
4416
4417   UnmapToolButtons();
4418
4419   ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
4420
4421   RemapAllGadgets();
4422
4423   if (game_status == GAME_MODE_PLAYING)
4424   {
4425     SetPanelBackground();
4426     SetDrawBackgroundMask(REDRAW_DOOR_1);
4427   }
4428   else
4429   {
4430     SetDrawBackgroundMask(REDRAW_FIELD);
4431   }
4432
4433 #if defined(NETWORK_AVALIABLE)
4434   /* continue network game after request */
4435   if (options.network &&
4436       game_status == GAME_MODE_PLAYING &&
4437       req_state & REQUEST_WAIT_FOR_INPUT)
4438     SendToServer_ContinuePlaying();
4439 #endif
4440
4441   /* restore deactivated drawing when quick-loading level tape recording */
4442   if (tape.playing && tape.deactivate_display)
4443     TapeDeactivateDisplayOn();
4444
4445   return result;
4446 }
4447
4448 boolean Request(char *text, unsigned int req_state)
4449 {
4450   boolean overlay_active = GetOverlayActive();
4451   boolean result;
4452
4453   SetOverlayActive(FALSE);
4454
4455   if (global.use_envelope_request)
4456     result = RequestEnvelope(text, req_state);
4457   else
4458     result = RequestDoor(text, req_state);
4459
4460   SetOverlayActive(overlay_active);
4461
4462   return result;
4463 }
4464
4465 static int compareDoorPartOrderInfo(const void *object1, const void *object2)
4466 {
4467   const struct DoorPartOrderInfo *dpo1 = (struct DoorPartOrderInfo *)object1;
4468   const struct DoorPartOrderInfo *dpo2 = (struct DoorPartOrderInfo *)object2;
4469   int compare_result;
4470
4471   if (dpo1->sort_priority != dpo2->sort_priority)
4472     compare_result = dpo1->sort_priority - dpo2->sort_priority;
4473   else
4474     compare_result = dpo1->nr - dpo2->nr;
4475
4476   return compare_result;
4477 }
4478
4479 void InitGraphicCompatibilityInfo_Doors()
4480 {
4481   struct
4482   {
4483     int door_token;
4484     int part_1, part_8;
4485     struct DoorInfo *door;
4486   }
4487   doors[] =
4488   {
4489     { DOOR_1,   IMG_GFX_DOOR_1_PART_1,  IMG_GFX_DOOR_1_PART_8,  &door_1 },
4490     { DOOR_2,   IMG_GFX_DOOR_2_PART_1,  IMG_GFX_DOOR_2_PART_8,  &door_2 },
4491
4492     { -1,       -1,                     -1,                     NULL    }
4493   };
4494   struct Rect door_rect_list[] =
4495   {
4496     { DX, DY, DXSIZE, DYSIZE },
4497     { VX, VY, VXSIZE, VYSIZE }
4498   };
4499   int i, j;
4500
4501   for (i = 0; doors[i].door_token != -1; i++)
4502   {
4503     int door_token = doors[i].door_token;
4504     int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
4505     int part_1 = doors[i].part_1;
4506     int part_8 = doors[i].part_8;
4507     int part_2 = part_1 + 1;
4508     int part_3 = part_1 + 2;
4509     struct DoorInfo *door = doors[i].door;
4510     struct Rect *door_rect = &door_rect_list[door_index];
4511     boolean door_gfx_redefined = FALSE;
4512
4513     /* check if any door part graphic definitions have been redefined */
4514
4515     for (j = 0; door_part_controls[j].door_token != -1; j++)
4516     {
4517       struct DoorPartControlInfo *dpc = &door_part_controls[j];
4518       struct FileInfo *fi = getImageListEntryFromImageID(dpc->graphic);
4519
4520       if (dpc->door_token == door_token && fi->redefined)
4521         door_gfx_redefined = TRUE;
4522     }
4523
4524     /* check for old-style door graphic/animation modifications */
4525
4526     if (!door_gfx_redefined)
4527     {
4528       if (door->anim_mode & ANIM_STATIC_PANEL)
4529       {
4530         door->panel.step_xoffset = 0;
4531         door->panel.step_yoffset = 0;
4532       }
4533
4534       if (door->anim_mode & (ANIM_HORIZONTAL | ANIM_VERTICAL))
4535       {
4536         struct GraphicInfo *g_part_1 = &graphic_info[part_1];
4537         struct GraphicInfo *g_part_2 = &graphic_info[part_2];
4538         int num_door_steps, num_panel_steps;
4539
4540         /* remove door part graphics other than the two default wings */
4541
4542         for (j = 0; door_part_controls[j].door_token != -1; j++)
4543         {
4544           struct DoorPartControlInfo *dpc = &door_part_controls[j];
4545           struct GraphicInfo *g = &graphic_info[dpc->graphic];
4546
4547           if (dpc->graphic >= part_3 &&
4548               dpc->graphic <= part_8)
4549             g->bitmap = NULL;
4550         }
4551
4552         /* set graphics and screen positions of the default wings */
4553
4554         g_part_1->width  = door_rect->width;
4555         g_part_1->height = door_rect->height;
4556         g_part_2->width  = door_rect->width;
4557         g_part_2->height = door_rect->height;
4558         g_part_2->src_x = door_rect->width;
4559         g_part_2->src_y = g_part_1->src_y;
4560
4561         door->part_2.x = door->part_1.x;
4562         door->part_2.y = door->part_1.y;
4563
4564         if (door->width != -1)
4565         {
4566           g_part_1->width = door->width;
4567           g_part_2->width = door->width;
4568
4569           // special treatment for graphics and screen position of right wing
4570           g_part_2->src_x += door_rect->width - door->width;
4571           door->part_2.x  += door_rect->width - door->width;
4572         }
4573
4574         if (door->height != -1)
4575         {
4576           g_part_1->height = door->height;
4577           g_part_2->height = door->height;
4578
4579           // special treatment for graphics and screen position of bottom wing
4580           g_part_2->src_y += door_rect->height - door->height;
4581           door->part_2.y  += door_rect->height - door->height;
4582         }
4583
4584         /* set animation delays for the default wings and panels */
4585
4586         door->part_1.step_delay = door->step_delay;
4587         door->part_2.step_delay = door->step_delay;
4588         door->panel.step_delay  = door->step_delay;
4589
4590         /* set animation draw order for the default wings */
4591
4592         door->part_1.sort_priority = 2; /* draw left wing over ... */
4593         door->part_2.sort_priority = 1; /*          ... right wing */
4594
4595         /* set animation draw offset for the default wings */
4596
4597         if (door->anim_mode & ANIM_HORIZONTAL)
4598         {
4599           door->part_1.step_xoffset = door->step_offset;
4600           door->part_1.step_yoffset = 0;
4601           door->part_2.step_xoffset = door->step_offset * -1;
4602           door->part_2.step_yoffset = 0;
4603
4604           num_door_steps = g_part_1->width / door->step_offset;
4605         }
4606         else    // ANIM_VERTICAL
4607         {
4608           door->part_1.step_xoffset = 0;
4609           door->part_1.step_yoffset = door->step_offset;
4610           door->part_2.step_xoffset = 0;
4611           door->part_2.step_yoffset = door->step_offset * -1;
4612
4613           num_door_steps = g_part_1->height / door->step_offset;
4614         }
4615
4616         /* set animation draw offset for the default panels */
4617
4618         if (door->step_offset > 1)
4619         {
4620           num_panel_steps = 2 * door_rect->height / door->step_offset;
4621           door->panel.start_step = num_panel_steps - num_door_steps;
4622           door->panel.start_step_closing = door->panel.start_step;
4623         }
4624         else
4625         {
4626           num_panel_steps = door_rect->height / door->step_offset;
4627           door->panel.start_step = num_panel_steps - num_door_steps / 2;
4628           door->panel.start_step_closing = door->panel.start_step;
4629           door->panel.step_delay *= 2;
4630         }
4631       }
4632     }
4633   }
4634 }
4635
4636 void InitDoors()
4637 {
4638   int i;
4639
4640   for (i = 0; door_part_controls[i].door_token != -1; i++)
4641   {
4642     struct DoorPartControlInfo *dpc = &door_part_controls[i];
4643     struct DoorPartOrderInfo *dpo = &door_part_order[i];
4644
4645     /* initialize "start_step_opening" and "start_step_closing", if needed */
4646     if (dpc->pos->start_step_opening == 0 &&
4647         dpc->pos->start_step_closing == 0)
4648     {
4649       // dpc->pos->start_step_opening = dpc->pos->start_step;
4650       dpc->pos->start_step_closing = dpc->pos->start_step;
4651     }
4652
4653     /* fill structure for door part draw order (sorted below) */
4654     dpo->nr = i;
4655     dpo->sort_priority = dpc->pos->sort_priority;
4656   }
4657
4658   /* sort door part controls according to sort_priority and graphic number */
4659   qsort(door_part_order, MAX_DOOR_PARTS,
4660         sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
4661 }
4662
4663 unsigned int OpenDoor(unsigned int door_state)
4664 {
4665   if (door_state & DOOR_COPY_BACK)
4666   {
4667     if (door_state & DOOR_OPEN_1)
4668       BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
4669                  1 * DXSIZE, 0, DXSIZE, DYSIZE, 0 * DXSIZE, 0);
4670
4671     if (door_state & DOOR_OPEN_2)
4672       BlitBitmap(bitmap_db_door_2, bitmap_db_door_2,
4673                  1 * VXSIZE, 0, VXSIZE, VYSIZE, 0 * VXSIZE, 0);
4674
4675     door_state &= ~DOOR_COPY_BACK;
4676   }
4677
4678   return MoveDoor(door_state);
4679 }
4680
4681 unsigned int CloseDoor(unsigned int door_state)
4682 {
4683   unsigned int old_door_state = GetDoorState();
4684
4685   if (!(door_state & DOOR_NO_COPY_BACK))
4686   {
4687     if (old_door_state & DOOR_OPEN_1)
4688       BlitBitmap(backbuffer, bitmap_db_door_1,
4689                  DX, DY, DXSIZE, DYSIZE, 0, 0);
4690
4691     if (old_door_state & DOOR_OPEN_2)
4692       BlitBitmap(backbuffer, bitmap_db_door_2,
4693                  VX, VY, VXSIZE, VYSIZE, 0, 0);
4694
4695     door_state &= ~DOOR_NO_COPY_BACK;
4696   }
4697
4698   return MoveDoor(door_state);
4699 }
4700
4701 unsigned int GetDoorState()
4702 {
4703   return MoveDoor(DOOR_GET_STATE);
4704 }
4705
4706 unsigned int SetDoorState(unsigned int door_state)
4707 {
4708   return MoveDoor(door_state | DOOR_SET_STATE);
4709 }
4710
4711 int euclid(int a, int b)
4712 {
4713   return (b ? euclid(b, a % b) : a);
4714 }
4715
4716 unsigned int MoveDoor(unsigned int door_state)
4717 {
4718   struct Rect door_rect_list[] =
4719   {
4720     { DX, DY, DXSIZE, DYSIZE },
4721     { VX, VY, VXSIZE, VYSIZE }
4722   };
4723   static int door1 = DOOR_CLOSE_1;
4724   static int door2 = DOOR_CLOSE_2;
4725   unsigned int door_delay = 0;
4726   unsigned int door_delay_value;
4727   int i;
4728
4729   if (door_state == DOOR_GET_STATE)
4730     return (door1 | door2);
4731
4732   if (door_state & DOOR_SET_STATE)
4733   {
4734     if (door_state & DOOR_ACTION_1)
4735       door1 = door_state & DOOR_ACTION_1;
4736     if (door_state & DOOR_ACTION_2)
4737       door2 = door_state & DOOR_ACTION_2;
4738
4739     return (door1 | door2);
4740   }
4741
4742   if (!(door_state & DOOR_FORCE_REDRAW))
4743   {
4744     if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
4745       door_state &= ~DOOR_OPEN_1;
4746     else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
4747       door_state &= ~DOOR_CLOSE_1;
4748     if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
4749       door_state &= ~DOOR_OPEN_2;
4750     else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
4751       door_state &= ~DOOR_CLOSE_2;
4752   }
4753
4754   if (global.autoplay_leveldir)
4755   {
4756     door_state |= DOOR_NO_DELAY;
4757     door_state &= ~DOOR_CLOSE_ALL;
4758   }
4759
4760   if (game_status == GAME_MODE_EDITOR)
4761     door_state |= DOOR_NO_DELAY;
4762
4763   if (door_state & DOOR_ACTION)