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                                 int element_bits_draw)
2491 {
2492   int element_base = map_mm_wall_element(element);
2493   int element_bits = (IS_DF_WALL(element) ?
2494                       element - EL_DF_WALL_START :
2495                       IS_MM_WALL(element) ?
2496                       element - EL_MM_WALL_START : EL_EMPTY) & 0x000f;
2497   int graphic = el2img_function(element_base);
2498   int tilesize_draw = tilesize / 2;
2499   Bitmap *src_bitmap;
2500   int src_x, src_y;
2501   int i;
2502
2503   getSizedGraphicSource(graphic, 0, tilesize_draw, &src_bitmap, &src_x, &src_y);
2504
2505   for (i = 0; i < 4; i++)
2506   {
2507     int dst_draw_x = dst_x + (i % 2) * tilesize_draw;
2508     int dst_draw_y = dst_y + (i / 2) * tilesize_draw;
2509
2510     if (!(element_bits_draw & (1 << i)))
2511       continue;
2512
2513     if (element_bits & (1 << i))
2514     {
2515       if (masked)
2516         BlitBitmapMasked(src_bitmap, drawto, src_x, src_y,
2517                          tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2518       else
2519         BlitBitmap(src_bitmap, drawto, src_x, src_y,
2520                    tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2521     }
2522     else
2523     {
2524       if (!masked)
2525         ClearRectangle(drawto, dst_draw_x, dst_draw_y,
2526                        tilesize_draw, tilesize_draw);
2527     }
2528   }
2529 }
2530
2531 void DrawSizedWallParts_MM(int x, int y, int element, int tilesize,
2532                            boolean masked, int element_bits_draw)
2533 {
2534   DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2535                       element, tilesize, el2edimg, masked, element_bits_draw);
2536 }
2537
2538 void DrawSizedWall_MM(int dst_x, int dst_y, int element, int tilesize,
2539                       int (*el2img_function)(int))
2540 {
2541   DrawSizedWallExt_MM(dst_x, dst_y, element, tilesize, el2img_function, FALSE,
2542                       0x000f);
2543 }
2544
2545 void DrawSizedElementExt(int x, int y, int element, int tilesize,
2546                          boolean masked)
2547 {
2548   if (IS_MM_WALL(element))
2549   {
2550     DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2551                         element, tilesize, el2edimg, masked, 0x000f);
2552   }
2553   else
2554   {
2555     int graphic = el2edimg(element);
2556
2557     if (masked)
2558       DrawSizedGraphicThruMask(x, y, graphic, 0, tilesize);
2559     else
2560       DrawSizedGraphic(x, y, graphic, 0, tilesize);
2561   }
2562 }
2563
2564 void DrawSizedElement(int x, int y, int element, int tilesize)
2565 {
2566   DrawSizedElementExt(x, y, element, tilesize, FALSE);
2567 }
2568
2569 void DrawSizedElementThruMask(int x, int y, int element, int tilesize)
2570 {
2571   DrawSizedElementExt(x, y, element, tilesize, TRUE);
2572 }
2573
2574 void DrawMiniElement(int x, int y, int element)
2575 {
2576   int graphic;
2577
2578   graphic = el2edimg(element);
2579   DrawMiniGraphic(x, y, graphic);
2580 }
2581
2582 void DrawSizedElementOrWall(int sx, int sy, int scroll_x, int scroll_y,
2583                             int tilesize)
2584 {
2585   int x = sx + scroll_x, y = sy + scroll_y;
2586
2587   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2588     DrawSizedElement(sx, sy, EL_EMPTY, tilesize);
2589   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2590     DrawSizedElement(sx, sy, Feld[x][y], tilesize);
2591   else
2592     DrawSizedGraphic(sx, sy, el2edimg(getBorderElement(x, y)), 0, tilesize);
2593 }
2594
2595 void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
2596 {
2597   int x = sx + scroll_x, y = sy + scroll_y;
2598
2599   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2600     DrawMiniElement(sx, sy, EL_EMPTY);
2601   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2602     DrawMiniElement(sx, sy, Feld[x][y]);
2603   else
2604     DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
2605 }
2606
2607 void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
2608                                  int x, int y, int xsize, int ysize,
2609                                  int tile_width, int tile_height)
2610 {
2611   Bitmap *src_bitmap;
2612   int src_x, src_y;
2613   int dst_x = startx + x * tile_width;
2614   int dst_y = starty + y * tile_height;
2615   int width  = graphic_info[graphic].width;
2616   int height = graphic_info[graphic].height;
2617   int inner_width_raw  = MAX(width  - 2 * tile_width,  tile_width);
2618   int inner_height_raw = MAX(height - 2 * tile_height, tile_height);
2619   int inner_width  = inner_width_raw  - (inner_width_raw  % tile_width);
2620   int inner_height = inner_height_raw - (inner_height_raw % tile_height);
2621   int inner_sx = (width  >= 3 * tile_width  ? tile_width  : 0);
2622   int inner_sy = (height >= 3 * tile_height ? tile_height : 0);
2623   boolean draw_masked = graphic_info[graphic].draw_masked;
2624
2625   getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2626
2627   if (src_bitmap == NULL || width < tile_width || height < tile_height)
2628   {
2629     ClearRectangle(drawto, dst_x, dst_y, tile_width, tile_height);
2630     return;
2631   }
2632
2633   src_x += (x == 0 ? 0 : x == xsize - 1 ? width  - tile_width  :
2634             inner_sx + (x - 1) * tile_width  % inner_width);
2635   src_y += (y == 0 ? 0 : y == ysize - 1 ? height - tile_height :
2636             inner_sy + (y - 1) * tile_height % inner_height);
2637
2638   if (draw_masked)
2639     BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2640                      dst_x, dst_y);
2641   else
2642     BlitBitmap(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2643                dst_x, dst_y);
2644 }
2645
2646 void DrawEnvelopeBackground(int graphic, int startx, int starty,
2647                             int x, int y, int xsize, int ysize, int font_nr)
2648 {
2649   int font_width  = getFontWidth(font_nr);
2650   int font_height = getFontHeight(font_nr);
2651
2652   DrawEnvelopeBackgroundTiles(graphic, startx, starty, x, y, xsize, ysize,
2653                               font_width, font_height);
2654 }
2655
2656 void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
2657 {
2658   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2659   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
2660   int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
2661   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2662   boolean no_delay = (tape.warp_forward);
2663   unsigned int anim_delay = 0;
2664   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2665   int anim_delay_value = MAX(1, (no_delay ? 0 : frame_delay_value) / 2);
2666   int font_nr = FONT_ENVELOPE_1 + envelope_nr;
2667   int font_width = getFontWidth(font_nr);
2668   int font_height = getFontHeight(font_nr);
2669   int max_xsize = level.envelope[envelope_nr].xsize;
2670   int max_ysize = level.envelope[envelope_nr].ysize;
2671   int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize : 0);
2672   int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize : 0);
2673   int xend = max_xsize;
2674   int yend = (anim_mode != ANIM_DEFAULT ? max_ysize : 0);
2675   int xstep = (xstart < xend ? 1 : 0);
2676   int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
2677   int start = 0;
2678   int end = MAX(xend - xstart, yend - ystart);
2679   int i;
2680
2681   for (i = start; i <= end; i++)
2682   {
2683     int last_frame = end;       // last frame of this "for" loop
2684     int x = xstart + i * xstep;
2685     int y = ystart + i * ystep;
2686     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
2687     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
2688     int sx = SX + (SXSIZE - xsize * font_width)  / 2;
2689     int sy = SY + (SYSIZE - ysize * font_height) / 2;
2690     int xx, yy;
2691
2692     SetDrawtoField(DRAW_TO_FIELDBUFFER);
2693
2694     BlitScreenToBitmap(backbuffer);
2695
2696     SetDrawtoField(DRAW_TO_BACKBUFFER);
2697
2698     for (yy = 0; yy < ysize; yy++)
2699       for (xx = 0; xx < xsize; xx++)
2700         DrawEnvelopeBackground(graphic, sx, sy, xx, yy, xsize, ysize, font_nr);
2701
2702     DrawTextBuffer(sx + font_width, sy + font_height,
2703                    level.envelope[envelope_nr].text, font_nr, max_xsize,
2704                    xsize - 2, ysize - 2, 0, mask_mode,
2705                    level.envelope[envelope_nr].autowrap,
2706                    level.envelope[envelope_nr].centered, FALSE);
2707
2708     redraw_mask |= REDRAW_FIELD;
2709     BackToFront();
2710
2711     SkipUntilDelayReached(&anim_delay, anim_delay_value, &i, last_frame);
2712   }
2713 }
2714
2715 void ShowEnvelope(int envelope_nr)
2716 {
2717   int element = EL_ENVELOPE_1 + envelope_nr;
2718   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2719   int sound_opening = element_info[element].sound[ACTION_OPENING];
2720   int sound_closing = element_info[element].sound[ACTION_CLOSING];
2721   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2722   boolean no_delay = (tape.warp_forward);
2723   int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
2724   int wait_delay_value = (no_delay ? 0 : normal_delay_value);
2725   int anim_mode = graphic_info[graphic].anim_mode;
2726   int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
2727                         anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
2728
2729   game.envelope_active = TRUE;  /* needed for RedrawPlayfield() events */
2730
2731   PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
2732
2733   if (anim_mode == ANIM_DEFAULT)
2734     AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
2735
2736   AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
2737
2738   if (tape.playing)
2739     Delay(wait_delay_value);
2740   else
2741     WaitForEventToContinue();
2742
2743   PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
2744
2745   if (anim_mode != ANIM_NONE)
2746     AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
2747
2748   if (anim_mode == ANIM_DEFAULT)
2749     AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
2750
2751   game.envelope_active = FALSE;
2752
2753   SetDrawtoField(DRAW_TO_FIELDBUFFER);
2754
2755   redraw_mask |= REDRAW_FIELD;
2756   BackToFront();
2757 }
2758
2759 static void setRequestBasePosition(int *x, int *y)
2760 {
2761   int sx_base, sy_base;
2762
2763   if (request.x != -1)
2764     sx_base = request.x;
2765   else if (request.align == ALIGN_LEFT)
2766     sx_base = SX;
2767   else if (request.align == ALIGN_RIGHT)
2768     sx_base = SX + SXSIZE;
2769   else
2770     sx_base = SX + SXSIZE / 2;
2771
2772   if (request.y != -1)
2773     sy_base = request.y;
2774   else if (request.valign == VALIGN_TOP)
2775     sy_base = SY;
2776   else if (request.valign == VALIGN_BOTTOM)
2777     sy_base = SY + SYSIZE;
2778   else
2779     sy_base = SY + SYSIZE / 2;
2780
2781   *x = sx_base;
2782   *y = sy_base;
2783 }
2784
2785 static void setRequestPositionExt(int *x, int *y, int width, int height,
2786                                   boolean add_border_size)
2787 {
2788   int border_size = request.border_size;
2789   int sx_base, sy_base;
2790   int sx, sy;
2791
2792   setRequestBasePosition(&sx_base, &sy_base);
2793
2794   if (request.align == ALIGN_LEFT)
2795     sx = sx_base;
2796   else if (request.align == ALIGN_RIGHT)
2797     sx = sx_base - width;
2798   else
2799     sx = sx_base - width  / 2;
2800
2801   if (request.valign == VALIGN_TOP)
2802     sy = sy_base;
2803   else if (request.valign == VALIGN_BOTTOM)
2804     sy = sy_base - height;
2805   else
2806     sy = sy_base - height / 2;
2807
2808   sx = MAX(0, MIN(sx, WIN_XSIZE - width));
2809   sy = MAX(0, MIN(sy, WIN_YSIZE - height));
2810
2811   if (add_border_size)
2812   {
2813     sx += border_size;
2814     sy += border_size;
2815   }
2816
2817   *x = sx;
2818   *y = sy;
2819 }
2820
2821 static void setRequestPosition(int *x, int *y, boolean add_border_size)
2822 {
2823   setRequestPositionExt(x, y, request.width, request.height, add_border_size);
2824 }
2825
2826 void DrawEnvelopeRequest(char *text)
2827 {
2828   char *text_final = text;
2829   char *text_door_style = NULL;
2830   int graphic = IMG_BACKGROUND_REQUEST;
2831   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
2832   int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
2833   int font_nr = FONT_REQUEST;
2834   int font_width = getFontWidth(font_nr);
2835   int font_height = getFontHeight(font_nr);
2836   int border_size = request.border_size;
2837   int line_spacing = request.line_spacing;
2838   int line_height = font_height + line_spacing;
2839   int max_text_width  = request.width  - 2 * border_size;
2840   int max_text_height = request.height - 2 * border_size;
2841   int line_length = max_text_width  / font_width;
2842   int max_lines   = max_text_height / line_height;
2843   int text_width = line_length * font_width;
2844   int width = request.width;
2845   int height = request.height;
2846   int tile_size = MAX(request.step_offset, 1);
2847   int x_steps = width  / tile_size;
2848   int y_steps = height / tile_size;
2849   int sx_offset = border_size;
2850   int sy_offset = border_size;
2851   int sx, sy;
2852   int i, x, y;
2853
2854   if (request.centered)
2855     sx_offset = (request.width - text_width) / 2;
2856
2857   if (request.wrap_single_words && !request.autowrap)
2858   {
2859     char *src_text_ptr, *dst_text_ptr;
2860
2861     text_door_style = checked_malloc(2 * strlen(text) + 1);
2862
2863     src_text_ptr = text;
2864     dst_text_ptr = text_door_style;
2865
2866     while (*src_text_ptr)
2867     {
2868       if (*src_text_ptr == ' ' ||
2869           *src_text_ptr == '?' ||
2870           *src_text_ptr == '!')
2871         *dst_text_ptr++ = '\n';
2872
2873       if (*src_text_ptr != ' ')
2874         *dst_text_ptr++ = *src_text_ptr;
2875
2876       src_text_ptr++;
2877     }
2878
2879     *dst_text_ptr = '\0';
2880
2881     text_final = text_door_style;
2882   }
2883
2884   setRequestPosition(&sx, &sy, FALSE);
2885
2886   ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
2887
2888   for (y = 0; y < y_steps; y++)
2889     for (x = 0; x < x_steps; x++)
2890       DrawEnvelopeBackgroundTiles(graphic, sx, sy,
2891                                   x, y, x_steps, y_steps,
2892                                   tile_size, tile_size);
2893
2894   /* force DOOR font inside door area */
2895   SetFontStatus(GAME_MODE_PSEUDO_DOOR);
2896
2897   DrawTextBuffer(sx + sx_offset, sy + sy_offset, text_final, font_nr,
2898                  line_length, -1, max_lines, line_spacing, mask_mode,
2899                  request.autowrap, request.centered, FALSE);
2900
2901   ResetFontStatus();
2902
2903   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
2904     RedrawGadget(tool_gadget[i]);
2905
2906   // store readily prepared envelope request for later use when animating
2907   BlitBitmap(backbuffer, bitmap_db_store_2, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
2908
2909   if (text_door_style)
2910     free(text_door_style);
2911 }
2912
2913 void AnimateEnvelopeRequest(int anim_mode, int action)
2914 {
2915   int graphic = IMG_BACKGROUND_REQUEST;
2916   boolean draw_masked = graphic_info[graphic].draw_masked;
2917   int delay_value_normal = request.step_delay;
2918   int delay_value_fast = delay_value_normal / 2;
2919   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2920   boolean no_delay = (tape.warp_forward);
2921   int delay_value = (ffwd_delay ? delay_value_fast : delay_value_normal);
2922   int anim_delay_value = MAX(1, (no_delay ? 0 : delay_value + 500 * 0) / 2);
2923   unsigned int anim_delay = 0;
2924
2925   int tile_size = MAX(request.step_offset, 1);
2926   int max_xsize = request.width  / tile_size;
2927   int max_ysize = request.height / tile_size;
2928   int max_xsize_inner = max_xsize - 2;
2929   int max_ysize_inner = max_ysize - 2;
2930
2931   int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize_inner : 0);
2932   int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize_inner : 0);
2933   int xend = max_xsize_inner;
2934   int yend = (anim_mode != ANIM_DEFAULT ? max_ysize_inner : 0);
2935   int xstep = (xstart < xend ? 1 : 0);
2936   int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
2937   int start = 0;
2938   int end = MAX(xend - xstart, yend - ystart);
2939   int i;
2940
2941   if (setup.quick_doors)
2942   {
2943     xstart = xend;
2944     ystart = yend;
2945     end = 0;
2946   }
2947
2948   for (i = start; i <= end; i++)
2949   {
2950     int last_frame = end;       // last frame of this "for" loop
2951     int x = xstart + i * xstep;
2952     int y = ystart + i * ystep;
2953     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
2954     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
2955     int xsize_size_left = (xsize - 1) * tile_size;
2956     int ysize_size_top  = (ysize - 1) * tile_size;
2957     int max_xsize_pos = (max_xsize - 1) * tile_size;
2958     int max_ysize_pos = (max_ysize - 1) * tile_size;
2959     int width  = xsize * tile_size;
2960     int height = ysize * tile_size;
2961     int src_x, src_y;
2962     int dst_x, dst_y;
2963     int xx, yy;
2964
2965     setRequestPosition(&src_x, &src_y, FALSE);
2966     setRequestPositionExt(&dst_x, &dst_y, width, height, FALSE);
2967
2968     BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
2969
2970     for (yy = 0; yy < 2; yy++)
2971     {
2972       for (xx = 0; xx < 2; xx++)
2973       {
2974         int src_xx = src_x + xx * max_xsize_pos;
2975         int src_yy = src_y + yy * max_ysize_pos;
2976         int dst_xx = dst_x + xx * xsize_size_left;
2977         int dst_yy = dst_y + yy * ysize_size_top;
2978         int xx_size = (xx ? tile_size : xsize_size_left);
2979         int yy_size = (yy ? tile_size : ysize_size_top);
2980
2981         if (draw_masked)
2982           BlitBitmapMasked(bitmap_db_store_2, backbuffer,
2983                            src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
2984         else
2985           BlitBitmap(bitmap_db_store_2, backbuffer,
2986                      src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
2987       }
2988     }
2989
2990     redraw_mask |= REDRAW_FIELD;
2991
2992     BackToFront();
2993
2994     SkipUntilDelayReached(&anim_delay, anim_delay_value, &i, last_frame);
2995   }
2996 }
2997
2998 void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
2999 {
3000   int graphic = IMG_BACKGROUND_REQUEST;
3001   int sound_opening = SND_REQUEST_OPENING;
3002   int sound_closing = SND_REQUEST_CLOSING;
3003   int anim_mode_1 = request.anim_mode;                  /* (higher priority) */
3004   int anim_mode_2 = graphic_info[graphic].anim_mode;    /* (lower priority) */
3005   int anim_mode = (anim_mode_1 != ANIM_DEFAULT ? anim_mode_1 : anim_mode_2);
3006   int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
3007                         anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
3008
3009   if (game_status == GAME_MODE_PLAYING)
3010     BlitScreenToBitmap(backbuffer);
3011
3012   SetDrawtoField(DRAW_TO_BACKBUFFER);
3013
3014   // SetDrawBackgroundMask(REDRAW_NONE);
3015
3016   if (action == ACTION_OPENING)
3017   {
3018     BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3019
3020     if (req_state & REQ_ASK)
3021     {
3022       MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
3023       MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
3024     }
3025     else if (req_state & REQ_CONFIRM)
3026     {
3027       MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
3028     }
3029     else if (req_state & REQ_PLAYER)
3030     {
3031       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
3032       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
3033       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
3034       MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
3035     }
3036
3037     DrawEnvelopeRequest(text);
3038   }
3039
3040   game.envelope_active = TRUE;  /* needed for RedrawPlayfield() events */
3041
3042   if (action == ACTION_OPENING)
3043   {
3044     PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
3045
3046     if (anim_mode == ANIM_DEFAULT)
3047       AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
3048
3049     AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
3050   }
3051   else
3052   {
3053     PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
3054
3055     if (anim_mode != ANIM_NONE)
3056       AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
3057
3058     if (anim_mode == ANIM_DEFAULT)
3059       AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
3060   }
3061
3062   game.envelope_active = FALSE;
3063
3064   if (action == ACTION_CLOSING)
3065     BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3066
3067   // SetDrawBackgroundMask(last_draw_background_mask);
3068
3069   redraw_mask |= REDRAW_FIELD;
3070
3071   BackToFront();
3072
3073   if (action == ACTION_CLOSING &&
3074       game_status == GAME_MODE_PLAYING &&
3075       level.game_engine_type == GAME_ENGINE_TYPE_RND)
3076     SetDrawtoField(DRAW_TO_FIELDBUFFER);
3077 }
3078
3079 void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
3080 {
3081   if (IS_MM_WALL(element))
3082   {
3083     DrawSizedWall_MM(dst_x, dst_y, element, tilesize, el2preimg);
3084   }
3085   else
3086   {
3087     Bitmap *src_bitmap;
3088     int src_x, src_y;
3089     int graphic = el2preimg(element);
3090
3091     getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
3092     BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize,
3093                dst_x, dst_y);
3094   }
3095 }
3096
3097 void DrawLevel(int draw_background_mask)
3098 {
3099   int x,y;
3100
3101   SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
3102   SetDrawBackgroundMask(draw_background_mask);
3103
3104   ClearField();
3105
3106   for (x = BX1; x <= BX2; x++)
3107     for (y = BY1; y <= BY2; y++)
3108       DrawScreenField(x, y);
3109
3110   redraw_mask |= REDRAW_FIELD;
3111 }
3112
3113 void DrawSizedLevel(int size_x, int size_y, int scroll_x, int scroll_y,
3114                     int tilesize)
3115 {
3116   int x,y;
3117
3118   for (x = 0; x < size_x; x++)
3119     for (y = 0; y < size_y; y++)
3120       DrawSizedElementOrWall(x, y, scroll_x, scroll_y, tilesize);
3121
3122   redraw_mask |= REDRAW_FIELD;
3123 }
3124
3125 void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
3126 {
3127   int x,y;
3128
3129   for (x = 0; x < size_x; x++)
3130     for (y = 0; y < size_y; y++)
3131       DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
3132
3133   redraw_mask |= REDRAW_FIELD;
3134 }
3135
3136 static void DrawPreviewLevelPlayfield(int from_x, int from_y)
3137 {
3138   boolean show_level_border = (BorderElement != EL_EMPTY);
3139   int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3140   int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3141   int tile_size = preview.tile_size;
3142   int preview_width  = preview.xsize * tile_size;
3143   int preview_height = preview.ysize * tile_size;
3144   int real_preview_xsize = MIN(level_xsize, preview.xsize);
3145   int real_preview_ysize = MIN(level_ysize, preview.ysize);
3146   int real_preview_width  = real_preview_xsize * tile_size;
3147   int real_preview_height = real_preview_ysize * tile_size;
3148   int dst_x = SX + ALIGNED_XPOS(preview.x, preview_width, preview.align);
3149   int dst_y = SY + ALIGNED_YPOS(preview.y, preview_height, preview.valign);
3150   int x, y;
3151
3152   if (!IN_GFX_FIELD_FULL(dst_x, dst_y + preview_height - 1))
3153     return;
3154
3155   DrawBackground(dst_x, dst_y, preview_width, preview_height);
3156
3157   dst_x += (preview_width  - real_preview_width)  / 2;
3158   dst_y += (preview_height - real_preview_height) / 2;
3159
3160   for (x = 0; x < real_preview_xsize; x++)
3161   {
3162     for (y = 0; y < real_preview_ysize; y++)
3163     {
3164       int lx = from_x + x + (show_level_border ? -1 : 0);
3165       int ly = from_y + y + (show_level_border ? -1 : 0);
3166       int element = (IN_LEV_FIELD(lx, ly) ? level.field[lx][ly] :
3167                      getBorderElement(lx, ly));
3168
3169       DrawPreviewElement(dst_x + x * tile_size, dst_y + y * tile_size,
3170                          element, tile_size);
3171     }
3172   }
3173
3174   redraw_mask |= REDRAW_FIELD;
3175 }
3176
3177 #define MICROLABEL_EMPTY                0
3178 #define MICROLABEL_LEVEL_NAME           1
3179 #define MICROLABEL_LEVEL_AUTHOR_HEAD    2
3180 #define MICROLABEL_LEVEL_AUTHOR         3
3181 #define MICROLABEL_IMPORTED_FROM_HEAD   4
3182 #define MICROLABEL_IMPORTED_FROM        5
3183 #define MICROLABEL_IMPORTED_BY_HEAD     6
3184 #define MICROLABEL_IMPORTED_BY          7
3185
3186 static int getMaxTextLength(struct TextPosInfo *pos, int font_nr)
3187 {
3188   int max_text_width = SXSIZE;
3189   int font_width = getFontWidth(font_nr);
3190
3191   if (pos->align == ALIGN_CENTER)
3192     max_text_width = (pos->x < SXSIZE / 2 ? pos->x * 2 : (SXSIZE - pos->x) * 2);
3193   else if (pos->align == ALIGN_RIGHT)
3194     max_text_width = pos->x;
3195   else
3196     max_text_width = SXSIZE - pos->x;
3197
3198   return max_text_width / font_width;
3199 }
3200
3201 static void DrawPreviewLevelLabelExt(int mode, struct TextPosInfo *pos)
3202 {
3203   char label_text[MAX_OUTPUT_LINESIZE + 1];
3204   int max_len_label_text;
3205   int font_nr = pos->font;
3206   int i;
3207
3208   if (!IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3209     return;
3210
3211   if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
3212       mode == MICROLABEL_IMPORTED_FROM_HEAD ||
3213       mode == MICROLABEL_IMPORTED_BY_HEAD)
3214     font_nr = pos->font_alt;
3215
3216   max_len_label_text = getMaxTextLength(pos, font_nr);
3217
3218   if (pos->size != -1)
3219     max_len_label_text = pos->size;
3220
3221   for (i = 0; i < max_len_label_text; i++)
3222     label_text[i] = ' ';
3223   label_text[max_len_label_text] = '\0';
3224
3225   if (strlen(label_text) > 0)
3226     DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3227
3228   strncpy(label_text,
3229           (mode == MICROLABEL_LEVEL_NAME ? level.name :
3230            mode == MICROLABEL_LEVEL_AUTHOR_HEAD ? "created by" :
3231            mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
3232            mode == MICROLABEL_IMPORTED_FROM_HEAD ? "imported from" :
3233            mode == MICROLABEL_IMPORTED_FROM ? leveldir_current->imported_from :
3234            mode == MICROLABEL_IMPORTED_BY_HEAD ? "imported by" :
3235            mode == MICROLABEL_IMPORTED_BY ? leveldir_current->imported_by :""),
3236           max_len_label_text);
3237   label_text[max_len_label_text] = '\0';
3238
3239   if (strlen(label_text) > 0)
3240     DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3241
3242   redraw_mask |= REDRAW_FIELD;
3243 }
3244
3245 static void DrawPreviewLevelLabel(int mode)
3246 {
3247   DrawPreviewLevelLabelExt(mode, &menu.main.text.level_info_2);
3248 }
3249
3250 static void DrawPreviewLevelInfo(int mode)
3251 {
3252   if (mode == MICROLABEL_LEVEL_NAME)
3253     DrawPreviewLevelLabelExt(mode, &menu.main.text.level_name);
3254   else if (mode == MICROLABEL_LEVEL_AUTHOR)
3255     DrawPreviewLevelLabelExt(mode, &menu.main.text.level_author);
3256 }
3257
3258 static void DrawPreviewLevelExt(boolean restart)
3259 {
3260   static unsigned int scroll_delay = 0;
3261   static unsigned int label_delay = 0;
3262   static int from_x, from_y, scroll_direction;
3263   static int label_state, label_counter;
3264   unsigned int scroll_delay_value = preview.step_delay;
3265   boolean show_level_border = (BorderElement != EL_EMPTY);
3266   int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3267   int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3268
3269   if (restart)
3270   {
3271     from_x = 0;
3272     from_y = 0;
3273
3274     if (preview.anim_mode == ANIM_CENTERED)
3275     {
3276       if (level_xsize > preview.xsize)
3277         from_x = (level_xsize - preview.xsize) / 2;
3278       if (level_ysize > preview.ysize)
3279         from_y = (level_ysize - preview.ysize) / 2;
3280     }
3281
3282     from_x += preview.xoffset;
3283     from_y += preview.yoffset;
3284
3285     scroll_direction = MV_RIGHT;
3286     label_state = 1;
3287     label_counter = 0;
3288
3289     DrawPreviewLevelPlayfield(from_x, from_y);
3290     DrawPreviewLevelLabel(label_state);
3291
3292     DrawPreviewLevelInfo(MICROLABEL_LEVEL_NAME);
3293     DrawPreviewLevelInfo(MICROLABEL_LEVEL_AUTHOR);
3294
3295     /* initialize delay counters */
3296     DelayReached(&scroll_delay, 0);
3297     DelayReached(&label_delay, 0);
3298
3299     if (leveldir_current->name)
3300     {
3301       struct TextPosInfo *pos = &menu.main.text.level_info_1;
3302       char label_text[MAX_OUTPUT_LINESIZE + 1];
3303       int font_nr = pos->font;
3304       int max_len_label_text = getMaxTextLength(pos, font_nr);
3305
3306       if (pos->size != -1)
3307         max_len_label_text = pos->size;
3308
3309       strncpy(label_text, leveldir_current->name, max_len_label_text);
3310       label_text[max_len_label_text] = '\0';
3311
3312       if (IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3313         DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3314     }
3315
3316     return;
3317   }
3318
3319   /* scroll preview level, if needed */
3320   if (preview.anim_mode != ANIM_NONE &&
3321       (level_xsize > preview.xsize || level_ysize > preview.ysize) &&
3322       DelayReached(&scroll_delay, scroll_delay_value))
3323   {
3324     switch (scroll_direction)
3325     {
3326       case MV_LEFT:
3327         if (from_x > 0)
3328         {
3329           from_x -= preview.step_offset;
3330           from_x = (from_x < 0 ? 0 : from_x);
3331         }
3332         else
3333           scroll_direction = MV_UP;
3334         break;
3335
3336       case MV_RIGHT:
3337         if (from_x < level_xsize - preview.xsize)
3338         {
3339           from_x += preview.step_offset;
3340           from_x = (from_x > level_xsize - preview.xsize ?
3341                     level_xsize - preview.xsize : from_x);
3342         }
3343         else
3344           scroll_direction = MV_DOWN;
3345         break;
3346
3347       case MV_UP:
3348         if (from_y > 0)
3349         {
3350           from_y -= preview.step_offset;
3351           from_y = (from_y < 0 ? 0 : from_y);
3352         }
3353         else
3354           scroll_direction = MV_RIGHT;
3355         break;
3356
3357       case MV_DOWN:
3358         if (from_y < level_ysize - preview.ysize)
3359         {
3360           from_y += preview.step_offset;
3361           from_y = (from_y > level_ysize - preview.ysize ?
3362                     level_ysize - preview.ysize : from_y);
3363         }
3364         else
3365           scroll_direction = MV_LEFT;
3366         break;
3367
3368       default:
3369         break;
3370     }
3371
3372     DrawPreviewLevelPlayfield(from_x, from_y);
3373   }
3374
3375   /* !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!! */
3376   /* redraw micro level label, if needed */
3377   if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
3378       !strEqual(level.author, ANONYMOUS_NAME) &&
3379       !strEqual(level.author, leveldir_current->name) &&
3380       DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
3381   {
3382     int max_label_counter = 23;
3383
3384     if (leveldir_current->imported_from != NULL &&
3385         strlen(leveldir_current->imported_from) > 0)
3386       max_label_counter += 14;
3387     if (leveldir_current->imported_by != NULL &&
3388         strlen(leveldir_current->imported_by) > 0)
3389       max_label_counter += 14;
3390
3391     label_counter = (label_counter + 1) % max_label_counter;
3392     label_state = (label_counter >= 0 && label_counter <= 7 ?
3393                    MICROLABEL_LEVEL_NAME :
3394                    label_counter >= 9 && label_counter <= 12 ?
3395                    MICROLABEL_LEVEL_AUTHOR_HEAD :
3396                    label_counter >= 14 && label_counter <= 21 ?
3397                    MICROLABEL_LEVEL_AUTHOR :
3398                    label_counter >= 23 && label_counter <= 26 ?
3399                    MICROLABEL_IMPORTED_FROM_HEAD :
3400                    label_counter >= 28 && label_counter <= 35 ?
3401                    MICROLABEL_IMPORTED_FROM :
3402                    label_counter >= 37 && label_counter <= 40 ?
3403                    MICROLABEL_IMPORTED_BY_HEAD :
3404                    label_counter >= 42 && label_counter <= 49 ?
3405                    MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
3406
3407     if (leveldir_current->imported_from == NULL &&
3408         (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
3409          label_state == MICROLABEL_IMPORTED_FROM))
3410       label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
3411                      MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
3412
3413     DrawPreviewLevelLabel(label_state);
3414   }
3415 }
3416
3417 void DrawPreviewLevelInitial()
3418 {
3419   DrawPreviewLevelExt(TRUE);
3420 }
3421
3422 void DrawPreviewLevelAnimation()
3423 {
3424   DrawPreviewLevelExt(FALSE);
3425 }
3426
3427 inline static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3428                                            int graphic, int sync_frame,
3429                                            int mask_mode)
3430 {
3431   int frame = getGraphicAnimationFrame(graphic, sync_frame);
3432
3433   if (mask_mode == USE_MASKING)
3434     DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3435   else
3436     DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
3437 }
3438
3439 void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3440                                   int graphic, int sync_frame, int mask_mode)
3441 {
3442   int frame = getGraphicAnimationFrame(graphic, sync_frame);
3443
3444   if (mask_mode == USE_MASKING)
3445     DrawFixedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3446   else
3447     DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame);
3448 }
3449
3450 inline static void DrawGraphicAnimation(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_VAR, FY + y * TILEY_VAR,
3458                           graphic, GfxFrame[lx][ly], NO_MASKING);
3459
3460   MarkTileDirty(x, y);
3461 }
3462
3463 void DrawFixedGraphicAnimation(int x, int y, int graphic)
3464 {
3465   int lx = LEVELX(x), ly = LEVELY(y);
3466
3467   if (!IN_SCR_FIELD(x, y))
3468     return;
3469
3470   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
3471                           graphic, GfxFrame[lx][ly], NO_MASKING);
3472   MarkTileDirty(x, y);
3473 }
3474
3475 void DrawLevelGraphicAnimation(int x, int y, int graphic)
3476 {
3477   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3478 }
3479
3480 void DrawLevelElementAnimation(int x, int y, int element)
3481 {
3482   int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
3483
3484   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3485 }
3486
3487 void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
3488 {
3489   int sx = SCREENX(x), sy = SCREENY(y);
3490
3491   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
3492     return;
3493
3494   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
3495     return;
3496
3497   DrawGraphicAnimation(sx, sy, graphic);
3498
3499 #if 1
3500   if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
3501     DrawLevelFieldCrumbled(x, y);
3502 #else
3503   if (GFX_CRUMBLED(Feld[x][y]))
3504     DrawLevelFieldCrumbled(x, y);
3505 #endif
3506 }
3507
3508 void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
3509 {
3510   int sx = SCREENX(x), sy = SCREENY(y);
3511   int graphic;
3512
3513   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
3514     return;
3515
3516   graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
3517
3518   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
3519     return;
3520
3521   DrawGraphicAnimation(sx, sy, graphic);
3522
3523   if (GFX_CRUMBLED(element))
3524     DrawLevelFieldCrumbled(x, y);
3525 }
3526
3527 static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
3528 {
3529   if (player->use_murphy)
3530   {
3531     /* this works only because currently only one player can be "murphy" ... */
3532     static int last_horizontal_dir = MV_LEFT;
3533     int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
3534
3535     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3536       last_horizontal_dir = move_dir;
3537
3538     if (graphic == IMG_SP_MURPHY)       /* undefined => use special graphic */
3539     {
3540       int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
3541
3542       graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
3543     }
3544
3545     return graphic;
3546   }
3547   else
3548     return el_act_dir2img(player->artwork_element, player->GfxAction,move_dir);
3549 }
3550
3551 static boolean equalGraphics(int graphic1, int graphic2)
3552 {
3553   struct GraphicInfo *g1 = &graphic_info[graphic1];
3554   struct GraphicInfo *g2 = &graphic_info[graphic2];
3555
3556   return (g1->bitmap      == g2->bitmap &&
3557           g1->src_x       == g2->src_x &&
3558           g1->src_y       == g2->src_y &&
3559           g1->anim_frames == g2->anim_frames &&
3560           g1->anim_delay  == g2->anim_delay &&
3561           g1->anim_mode   == g2->anim_mode);
3562 }
3563
3564 void DrawAllPlayers()
3565 {
3566   int i;
3567
3568   for (i = 0; i < MAX_PLAYERS; i++)
3569     if (stored_player[i].active)
3570       DrawPlayer(&stored_player[i]);
3571 }
3572
3573 void DrawPlayerField(int x, int y)
3574 {
3575   if (!IS_PLAYER(x, y))
3576     return;
3577
3578   DrawPlayer(PLAYERINFO(x, y));
3579 }
3580
3581 #define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
3582
3583 void DrawPlayer(struct PlayerInfo *player)
3584 {
3585   int jx = player->jx;
3586   int jy = player->jy;
3587   int move_dir = player->MovDir;
3588   int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
3589   int dy = (move_dir == MV_UP   ? -1 : move_dir == MV_DOWN  ? +1 : 0);
3590   int last_jx = (player->is_moving ? jx - dx : jx);
3591   int last_jy = (player->is_moving ? jy - dy : jy);
3592   int next_jx = jx + dx;
3593   int next_jy = jy + dy;
3594   boolean player_is_moving = (player->MovPos ? TRUE : FALSE);
3595   boolean player_is_opaque = FALSE;
3596   int sx = SCREENX(jx), sy = SCREENY(jy);
3597   int sxx = 0, syy = 0;
3598   int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
3599   int graphic;
3600   int action = ACTION_DEFAULT;
3601   int last_player_graphic = getPlayerGraphic(player, move_dir);
3602   int last_player_frame = player->Frame;
3603   int frame = 0;
3604
3605   /* GfxElement[][] is set to the element the player is digging or collecting;
3606      remove also for off-screen player if the player is not moving anymore */
3607   if (IN_LEV_FIELD(jx, jy) && !player_is_moving)
3608     GfxElement[jx][jy] = EL_UNDEFINED;
3609
3610   if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
3611     return;
3612
3613 #if DEBUG
3614   if (!IN_LEV_FIELD(jx, jy))
3615   {
3616     printf("DrawPlayerField(): x = %d, y = %d\n",jx,jy);
3617     printf("DrawPlayerField(): sx = %d, sy = %d\n",sx,sy);
3618     printf("DrawPlayerField(): This should never happen!\n");
3619     return;
3620   }
3621 #endif
3622
3623   if (element == EL_EXPLOSION)
3624     return;
3625
3626   action = (player->is_pushing    ? ACTION_PUSHING         :
3627             player->is_digging    ? ACTION_DIGGING         :
3628             player->is_collecting ? ACTION_COLLECTING      :
3629             player->is_moving     ? ACTION_MOVING          :
3630             player->is_snapping   ? ACTION_SNAPPING        :
3631             player->is_dropping   ? ACTION_DROPPING        :
3632             player->is_waiting    ? player->action_waiting : ACTION_DEFAULT);
3633
3634   if (player->is_waiting)
3635     move_dir = player->dir_waiting;
3636
3637   InitPlayerGfxAnimation(player, action, move_dir);
3638
3639   /* ----------------------------------------------------------------------- */
3640   /* draw things in the field the player is leaving, if needed               */
3641   /* ----------------------------------------------------------------------- */
3642
3643   if (player->is_moving)
3644   {
3645     if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
3646     {
3647       DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
3648
3649       if (last_element == EL_DYNAMITE_ACTIVE ||
3650           last_element == EL_EM_DYNAMITE_ACTIVE ||
3651           last_element == EL_SP_DISK_RED_ACTIVE)
3652         DrawDynamite(last_jx, last_jy);
3653       else
3654         DrawLevelFieldThruMask(last_jx, last_jy);
3655     }
3656     else if (last_element == EL_DYNAMITE_ACTIVE ||
3657              last_element == EL_EM_DYNAMITE_ACTIVE ||
3658              last_element == EL_SP_DISK_RED_ACTIVE)
3659       DrawDynamite(last_jx, last_jy);
3660 #if 0
3661     /* !!! this is not enough to prevent flickering of players which are
3662        moving next to each others without a free tile between them -- this
3663        can only be solved by drawing all players layer by layer (first the
3664        background, then the foreground etc.) !!! => TODO */
3665     else if (!IS_PLAYER(last_jx, last_jy))
3666       DrawLevelField(last_jx, last_jy);
3667 #else
3668     else
3669       DrawLevelField(last_jx, last_jy);
3670 #endif
3671
3672     if (player->is_pushing && IN_SCR_FIELD(SCREENX(next_jx), SCREENY(next_jy)))
3673       DrawLevelElement(next_jx, next_jy, EL_EMPTY);
3674   }
3675
3676   if (!IN_SCR_FIELD(sx, sy))
3677     return;
3678
3679   /* ----------------------------------------------------------------------- */
3680   /* draw things behind the player, if needed                                */
3681   /* ----------------------------------------------------------------------- */
3682
3683   if (Back[jx][jy])
3684     DrawLevelElement(jx, jy, Back[jx][jy]);
3685   else if (IS_ACTIVE_BOMB(element))
3686     DrawLevelElement(jx, jy, EL_EMPTY);
3687   else
3688   {
3689     if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
3690     {
3691       int old_element = GfxElement[jx][jy];
3692       int old_graphic = el_act_dir2img(old_element, action, move_dir);
3693       int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
3694
3695       if (GFX_CRUMBLED(old_element))
3696         DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
3697       else
3698         DrawGraphic(sx, sy, old_graphic, frame);
3699
3700       if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
3701         player_is_opaque = TRUE;
3702     }
3703     else
3704     {
3705       GfxElement[jx][jy] = EL_UNDEFINED;
3706
3707       /* make sure that pushed elements are drawn with correct frame rate */
3708       graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
3709
3710       if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
3711         GfxFrame[jx][jy] = player->StepFrame;
3712
3713       DrawLevelField(jx, jy);
3714     }
3715   }
3716
3717 #if !DRAW_PLAYER_OVER_PUSHED_ELEMENT
3718   /* ----------------------------------------------------------------------- */
3719   /* draw player himself                                                     */
3720   /* ----------------------------------------------------------------------- */
3721
3722   graphic = getPlayerGraphic(player, move_dir);
3723
3724   /* in the case of changed player action or direction, prevent the current
3725      animation frame from being restarted for identical animations */
3726   if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
3727     player->Frame = last_player_frame;
3728
3729   frame = getGraphicAnimationFrame(graphic, player->Frame);
3730
3731   if (player->GfxPos)
3732   {
3733     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3734       sxx = player->GfxPos;
3735     else
3736       syy = player->GfxPos;
3737   }
3738
3739   if (player_is_opaque)
3740     DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
3741   else
3742     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3743
3744   if (SHIELD_ON(player))
3745   {
3746     int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
3747                    IMG_SHIELD_NORMAL_ACTIVE);
3748     int frame = getGraphicAnimationFrame(graphic, -1);
3749
3750     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3751   }
3752 #endif
3753
3754 #if DRAW_PLAYER_OVER_PUSHED_ELEMENT
3755   if (player->GfxPos)
3756   {
3757     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3758       sxx = player->GfxPos;
3759     else
3760       syy = player->GfxPos;
3761   }
3762 #endif
3763
3764   /* ----------------------------------------------------------------------- */
3765   /* draw things the player is pushing, if needed                            */
3766   /* ----------------------------------------------------------------------- */
3767
3768   if (player->is_pushing && player->is_moving)
3769   {
3770     int px = SCREENX(jx), py = SCREENY(jy);
3771     int pxx = (TILEX - ABS(sxx)) * dx;
3772     int pyy = (TILEY - ABS(syy)) * dy;
3773     int gfx_frame = GfxFrame[jx][jy];
3774
3775     int graphic;
3776     int sync_frame;
3777     int frame;
3778
3779     if (!IS_MOVING(jx, jy))             /* push movement already finished */
3780     {
3781       element = Feld[next_jx][next_jy];
3782       gfx_frame = GfxFrame[next_jx][next_jy];
3783     }
3784
3785     graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
3786
3787     sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
3788     frame = getGraphicAnimationFrame(graphic, sync_frame);
3789
3790     /* draw background element under pushed element (like the Sokoban field) */
3791     if (game.use_masked_pushing && IS_MOVING(jx, jy))
3792     {
3793       /* this allows transparent pushing animation over non-black background */
3794
3795       if (Back[jx][jy])
3796         DrawLevelElement(jx, jy, Back[jx][jy]);
3797       else
3798         DrawLevelElement(jx, jy, EL_EMPTY);
3799
3800       if (Back[next_jx][next_jy])
3801         DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
3802       else
3803         DrawLevelElement(next_jx, next_jy, EL_EMPTY);
3804     }
3805     else if (Back[next_jx][next_jy])
3806       DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
3807
3808 #if 1
3809     /* do not draw (EM style) pushing animation when pushing is finished */
3810     /* (two-tile animations usually do not contain start and end frame) */
3811     if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
3812       DrawLevelElement(next_jx, next_jy, Feld[next_jx][next_jy]);
3813     else
3814       DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
3815 #else
3816     /* masked drawing is needed for EMC style (double) movement graphics */
3817     /* !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!! */
3818     DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
3819 #endif
3820   }
3821
3822 #if DRAW_PLAYER_OVER_PUSHED_ELEMENT
3823   /* ----------------------------------------------------------------------- */
3824   /* draw player himself                                                     */
3825   /* ----------------------------------------------------------------------- */
3826
3827   graphic = getPlayerGraphic(player, move_dir);
3828
3829   /* in the case of changed player action or direction, prevent the current
3830      animation frame from being restarted for identical animations */
3831   if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
3832     player->Frame = last_player_frame;
3833
3834   frame = getGraphicAnimationFrame(graphic, player->Frame);
3835
3836   if (player->GfxPos)
3837   {
3838     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
3839       sxx = player->GfxPos;
3840     else
3841       syy = player->GfxPos;
3842   }
3843
3844   if (player_is_opaque)
3845     DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
3846   else
3847     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3848
3849   if (SHIELD_ON(player))
3850   {
3851     int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
3852                    IMG_SHIELD_NORMAL_ACTIVE);
3853     int frame = getGraphicAnimationFrame(graphic, -1);
3854
3855     DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
3856   }
3857 #endif
3858
3859   /* ----------------------------------------------------------------------- */
3860   /* draw things in front of player (active dynamite or dynabombs)           */
3861   /* ----------------------------------------------------------------------- */
3862
3863   if (IS_ACTIVE_BOMB(element))
3864   {
3865     graphic = el2img(element);
3866     frame = getGraphicAnimationFrame(graphic, GfxFrame[jx][jy]);
3867
3868     if (game.emulation == EMU_SUPAPLEX)
3869       DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
3870     else
3871       DrawGraphicThruMask(sx, sy, graphic, frame);
3872   }
3873
3874   if (player_is_moving && last_element == EL_EXPLOSION)
3875   {
3876     int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
3877                    GfxElement[last_jx][last_jy] :  EL_EMPTY);
3878     int graphic = el_act2img(element, ACTION_EXPLODING);
3879     int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
3880     int phase = ExplodePhase[last_jx][last_jy] - 1;
3881     int frame = getGraphicAnimationFrame(graphic, phase - delay);
3882
3883     if (phase >= delay)
3884       DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
3885   }
3886
3887   /* ----------------------------------------------------------------------- */
3888   /* draw elements the player is just walking/passing through/under          */
3889   /* ----------------------------------------------------------------------- */
3890
3891   if (player_is_moving)
3892   {
3893     /* handle the field the player is leaving ... */
3894     if (IS_ACCESSIBLE_INSIDE(last_element))
3895       DrawLevelField(last_jx, last_jy);
3896     else if (IS_ACCESSIBLE_UNDER(last_element))
3897       DrawLevelFieldThruMask(last_jx, last_jy);
3898   }
3899
3900   /* do not redraw accessible elements if the player is just pushing them */
3901   if (!player_is_moving || !player->is_pushing)
3902   {
3903     /* ... and the field the player is entering */
3904     if (IS_ACCESSIBLE_INSIDE(element))
3905       DrawLevelField(jx, jy);
3906     else if (IS_ACCESSIBLE_UNDER(element))
3907       DrawLevelFieldThruMask(jx, jy);
3908   }
3909
3910   MarkTileDirty(sx, sy);
3911 }
3912
3913 /* ------------------------------------------------------------------------- */
3914
3915 void WaitForEventToContinue()
3916 {
3917   boolean still_wait = TRUE;
3918
3919   if (program.headless)
3920     return;
3921
3922   /* simulate releasing mouse button over last gadget, if still pressed */
3923   if (button_status)
3924     HandleGadgets(-1, -1, 0);
3925
3926   button_status = MB_RELEASED;
3927
3928   ClearEventQueue();
3929
3930   while (still_wait)
3931   {
3932     Event event;
3933
3934     if (NextValidEvent(&event))
3935     {
3936       switch (event.type)
3937       {
3938         case EVENT_BUTTONPRESS:
3939         case EVENT_KEYPRESS:
3940 #if defined(TARGET_SDL2)
3941         case SDL_CONTROLLERBUTTONDOWN:
3942 #endif
3943         case SDL_JOYBUTTONDOWN:
3944           still_wait = FALSE;
3945           break;
3946
3947         case EVENT_KEYRELEASE:
3948           ClearPlayerAction();
3949           break;
3950
3951         default:
3952           HandleOtherEvents(&event);
3953           break;
3954       }
3955     }
3956     else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
3957     {
3958       still_wait = FALSE;
3959     }
3960
3961     BackToFront();
3962   }
3963 }
3964
3965 #define MAX_REQUEST_LINES               13
3966 #define MAX_REQUEST_LINE_FONT1_LEN      7
3967 #define MAX_REQUEST_LINE_FONT2_LEN      10
3968
3969 static int RequestHandleEvents(unsigned int req_state)
3970 {
3971   boolean level_solved = (game_status == GAME_MODE_PLAYING &&
3972                           local_player->LevelSolved_GameEnd);
3973   int width  = request.width;
3974   int height = request.height;
3975   int sx, sy;
3976   int result;
3977
3978   setRequestPosition(&sx, &sy, FALSE);
3979
3980   button_status = MB_RELEASED;
3981
3982   request_gadget_id = -1;
3983   result = -1;
3984
3985   while (result < 0)
3986   {
3987     if (level_solved)
3988     {
3989       /* the MM game engine does not use a special (scrollable) field buffer */
3990       if (level.game_engine_type != GAME_ENGINE_TYPE_MM)
3991         SetDrawtoField(DRAW_TO_FIELDBUFFER);
3992
3993       HandleGameActions();
3994
3995       SetDrawtoField(DRAW_TO_BACKBUFFER);
3996
3997       if (global.use_envelope_request)
3998       {
3999         /* copy current state of request area to middle of playfield area */
4000         BlitBitmap(bitmap_db_store_2, drawto, sx, sy, width, height, sx, sy);
4001       }
4002     }
4003
4004     if (PendingEvent())
4005     {
4006       Event event;
4007
4008       while (NextValidEvent(&event))
4009       {
4010         switch (event.type)
4011         {
4012           case EVENT_BUTTONPRESS:
4013           case EVENT_BUTTONRELEASE:
4014           case EVENT_MOTIONNOTIFY:
4015           {
4016             int mx, my;
4017
4018             if (event.type == EVENT_MOTIONNOTIFY)
4019             {
4020               if (!button_status)
4021                 continue;
4022
4023               motion_status = TRUE;
4024               mx = ((MotionEvent *) &event)->x;
4025               my = ((MotionEvent *) &event)->y;
4026             }
4027             else
4028             {
4029               motion_status = FALSE;
4030               mx = ((ButtonEvent *) &event)->x;
4031               my = ((ButtonEvent *) &event)->y;
4032               if (event.type == EVENT_BUTTONPRESS)
4033                 button_status = ((ButtonEvent *) &event)->button;
4034               else
4035                 button_status = MB_RELEASED;
4036             }
4037
4038             /* this sets 'request_gadget_id' */
4039             HandleGadgets(mx, my, button_status);
4040
4041             switch (request_gadget_id)
4042             {
4043               case TOOL_CTRL_ID_YES:
4044                 result = TRUE;
4045                 break;
4046               case TOOL_CTRL_ID_NO:
4047                 result = FALSE;
4048                 break;
4049               case TOOL_CTRL_ID_CONFIRM:
4050                 result = TRUE | FALSE;
4051                 break;
4052
4053               case TOOL_CTRL_ID_PLAYER_1:
4054                 result = 1;
4055                 break;
4056               case TOOL_CTRL_ID_PLAYER_2:
4057                 result = 2;
4058                 break;
4059               case TOOL_CTRL_ID_PLAYER_3:
4060                 result = 3;
4061                 break;
4062               case TOOL_CTRL_ID_PLAYER_4:
4063                 result = 4;
4064                 break;
4065
4066               default:
4067                 break;
4068             }
4069
4070             break;
4071           }
4072
4073 #if defined(TARGET_SDL2)
4074           case SDL_WINDOWEVENT:
4075             HandleWindowEvent((WindowEvent *) &event);
4076             break;
4077
4078           case SDL_APP_WILLENTERBACKGROUND:
4079           case SDL_APP_DIDENTERBACKGROUND:
4080           case SDL_APP_WILLENTERFOREGROUND:
4081           case SDL_APP_DIDENTERFOREGROUND:
4082             HandlePauseResumeEvent((PauseResumeEvent *) &event);
4083             break;
4084 #endif
4085
4086           case EVENT_KEYPRESS:
4087           {
4088             Key key = GetEventKey((KeyEvent *)&event, TRUE);
4089
4090             switch (key)
4091             {
4092               case KSYM_space:
4093                 if (req_state & REQ_CONFIRM)
4094                   result = 1;
4095                 break;
4096
4097               case KSYM_Return:
4098 #if defined(TARGET_SDL2)
4099               case KSYM_Select:
4100               case KSYM_Menu:
4101 #if defined(KSYM_Rewind)
4102               case KSYM_Rewind:         /* for Amazon Fire TV remote */
4103 #endif
4104 #endif
4105                 result = 1;
4106                 break;
4107
4108               case KSYM_Escape:
4109 #if defined(TARGET_SDL2)
4110               case KSYM_Back:
4111 #if defined(KSYM_FastForward)
4112               case KSYM_FastForward:    /* for Amazon Fire TV remote */
4113 #endif
4114 #endif
4115                 result = 0;
4116                 break;
4117
4118               default:
4119                 HandleKeysDebug(key);
4120                 break;
4121             }
4122
4123             if (req_state & REQ_PLAYER)
4124               result = 0;
4125
4126             break;
4127           }
4128
4129           case EVENT_KEYRELEASE:
4130             ClearPlayerAction();
4131             break;
4132
4133 #if defined(TARGET_SDL2)
4134           case SDL_CONTROLLERBUTTONDOWN:
4135             switch (event.cbutton.button)
4136             {
4137               case SDL_CONTROLLER_BUTTON_A:
4138               case SDL_CONTROLLER_BUTTON_X:
4139               case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
4140                 result = 1;
4141                 break;
4142
4143               case SDL_CONTROLLER_BUTTON_B:
4144               case SDL_CONTROLLER_BUTTON_Y:
4145               case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
4146               case SDL_CONTROLLER_BUTTON_BACK:
4147                 result = 0;
4148                 break;
4149             }
4150
4151             if (req_state & REQ_PLAYER)
4152               result = 0;
4153
4154             break;
4155
4156           case SDL_CONTROLLERBUTTONUP:
4157             HandleJoystickEvent(&event);
4158             ClearPlayerAction();
4159             break;
4160 #endif
4161
4162           default:
4163             HandleOtherEvents(&event);
4164             break;
4165         }
4166       }
4167     }
4168     else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4169     {
4170       int joy = AnyJoystick();
4171
4172       if (joy & JOY_BUTTON_1)
4173         result = 1;
4174       else if (joy & JOY_BUTTON_2)
4175         result = 0;
4176     }
4177
4178     if (level_solved)
4179     {
4180       if (global.use_envelope_request)
4181       {
4182         /* copy back current state of pressed buttons inside request area */
4183         BlitBitmap(drawto, bitmap_db_store_2, sx, sy, width, height, sx, sy);
4184       }
4185     }
4186
4187     BackToFront();
4188   }
4189
4190   return result;
4191 }
4192
4193 static boolean RequestDoor(char *text, unsigned int req_state)
4194 {
4195   unsigned int old_door_state;
4196   int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN;
4197   int font_nr = FONT_TEXT_2;
4198   char *text_ptr;
4199   int result;
4200   int ty;
4201
4202   if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN)
4203   {
4204     max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
4205     font_nr = FONT_TEXT_1;
4206   }
4207
4208   if (game_status == GAME_MODE_PLAYING)
4209     BlitScreenToBitmap(backbuffer);
4210
4211   /* disable deactivated drawing when quick-loading level tape recording */
4212   if (tape.playing && tape.deactivate_display)
4213     TapeDeactivateDisplayOff(TRUE);
4214
4215   SetMouseCursor(CURSOR_DEFAULT);
4216
4217 #if defined(NETWORK_AVALIABLE)
4218   /* pause network game while waiting for request to answer */
4219   if (options.network &&
4220       game_status == GAME_MODE_PLAYING &&
4221       req_state & REQUEST_WAIT_FOR_INPUT)
4222     SendToServer_PausePlaying();
4223 #endif
4224
4225   old_door_state = GetDoorState();
4226
4227   /* simulate releasing mouse button over last gadget, if still pressed */
4228   if (button_status)
4229     HandleGadgets(-1, -1, 0);
4230
4231   UnmapAllGadgets();
4232
4233   /* draw released gadget before proceeding */
4234   // BackToFront();
4235
4236   if (old_door_state & DOOR_OPEN_1)
4237   {
4238     CloseDoor(DOOR_CLOSE_1);
4239
4240     /* save old door content */
4241     BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
4242                0 * DXSIZE, 0, DXSIZE, DYSIZE, 1 * DXSIZE, 0);
4243   }
4244
4245   SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
4246   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4247
4248   /* clear door drawing field */
4249   DrawBackground(DX, DY, DXSIZE, DYSIZE);
4250
4251   /* force DOOR font inside door area */
4252   SetFontStatus(GAME_MODE_PSEUDO_DOOR);
4253
4254   /* write text for request */
4255   for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
4256   {
4257     char text_line[max_request_line_len + 1];
4258     int tx, tl, tc = 0;
4259
4260     if (!*text_ptr)
4261       break;
4262
4263     for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
4264     {
4265       tc = *(text_ptr + tx);
4266       // if (!tc || tc == ' ')
4267       if (!tc || tc == ' ' || tc == '?' || tc == '!')
4268         break;
4269     }
4270
4271     if ((tc == '?' || tc == '!') && tl == 0)
4272       tl = 1;
4273
4274     if (!tl)
4275     {
4276       text_ptr++;
4277       ty--;
4278       continue;
4279     }
4280
4281     strncpy(text_line, text_ptr, tl);
4282     text_line[tl] = 0;
4283
4284     DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
4285              DY + 8 + ty * (getFontHeight(font_nr) + 2),
4286              text_line, font_nr);
4287
4288     text_ptr += tl + (tc == ' ' ? 1 : 0);
4289     // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
4290   }
4291
4292   ResetFontStatus();
4293
4294   if (req_state & REQ_ASK)
4295   {
4296     MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
4297     MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
4298   }
4299   else if (req_state & REQ_CONFIRM)
4300   {
4301     MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
4302   }
4303   else if (req_state & REQ_PLAYER)
4304   {
4305     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
4306     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
4307     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
4308     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
4309   }
4310
4311   /* copy request gadgets to door backbuffer */
4312   BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4313
4314   OpenDoor(DOOR_OPEN_1);
4315
4316   if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4317   {
4318     if (game_status == GAME_MODE_PLAYING)
4319     {
4320       SetPanelBackground();
4321       SetDrawBackgroundMask(REDRAW_DOOR_1);
4322     }
4323     else
4324     {
4325       SetDrawBackgroundMask(REDRAW_FIELD);
4326     }
4327
4328     return FALSE;
4329   }
4330
4331   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4332
4333   // ---------- handle request buttons ----------
4334   result = RequestHandleEvents(req_state);
4335
4336   UnmapToolButtons();
4337
4338   if (!(req_state & REQ_STAY_OPEN))
4339   {
4340     CloseDoor(DOOR_CLOSE_1);
4341
4342     if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
4343         (req_state & REQ_REOPEN))
4344       OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
4345   }
4346
4347   RemapAllGadgets();
4348
4349   if (game_status == GAME_MODE_PLAYING)
4350   {
4351     SetPanelBackground();
4352     SetDrawBackgroundMask(REDRAW_DOOR_1);
4353   }
4354   else
4355   {
4356     SetDrawBackgroundMask(REDRAW_FIELD);
4357   }
4358
4359 #if defined(NETWORK_AVALIABLE)
4360   /* continue network game after request */
4361   if (options.network &&
4362       game_status == GAME_MODE_PLAYING &&
4363       req_state & REQUEST_WAIT_FOR_INPUT)
4364     SendToServer_ContinuePlaying();
4365 #endif
4366
4367   /* restore deactivated drawing when quick-loading level tape recording */
4368   if (tape.playing && tape.deactivate_display)
4369     TapeDeactivateDisplayOn();
4370
4371   return result;
4372 }
4373
4374 static boolean RequestEnvelope(char *text, unsigned int req_state)
4375 {
4376   int result;
4377
4378   if (game_status == GAME_MODE_PLAYING)
4379     BlitScreenToBitmap(backbuffer);
4380
4381   /* disable deactivated drawing when quick-loading level tape recording */
4382   if (tape.playing && tape.deactivate_display)
4383     TapeDeactivateDisplayOff(TRUE);
4384
4385   SetMouseCursor(CURSOR_DEFAULT);
4386
4387 #if defined(NETWORK_AVALIABLE)
4388   /* pause network game while waiting for request to answer */
4389   if (options.network &&
4390       game_status == GAME_MODE_PLAYING &&
4391       req_state & REQUEST_WAIT_FOR_INPUT)
4392     SendToServer_PausePlaying();
4393 #endif
4394
4395   /* simulate releasing mouse button over last gadget, if still pressed */
4396   if (button_status)
4397     HandleGadgets(-1, -1, 0);
4398
4399   UnmapAllGadgets();
4400
4401   // (replace with setting corresponding request background)
4402   // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
4403   // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4404
4405   /* clear door drawing field */
4406   // DrawBackground(DX, DY, DXSIZE, DYSIZE);
4407
4408   ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
4409
4410   if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4411   {
4412     if (game_status == GAME_MODE_PLAYING)
4413     {
4414       SetPanelBackground();
4415       SetDrawBackgroundMask(REDRAW_DOOR_1);
4416     }
4417     else
4418     {
4419       SetDrawBackgroundMask(REDRAW_FIELD);
4420     }
4421
4422     return FALSE;
4423   }
4424
4425   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4426
4427   // ---------- handle request buttons ----------
4428   result = RequestHandleEvents(req_state);
4429
4430   UnmapToolButtons();
4431
4432   ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
4433
4434   RemapAllGadgets();
4435
4436   if (game_status == GAME_MODE_PLAYING)
4437   {
4438     SetPanelBackground();
4439     SetDrawBackgroundMask(REDRAW_DOOR_1);
4440   }
4441   else
4442   {
4443     SetDrawBackgroundMask(REDRAW_FIELD);
4444   }
4445
4446 #if defined(NETWORK_AVALIABLE)
4447   /* continue network game after request */
4448   if (options.network &&
4449       game_status == GAME_MODE_PLAYING &&
4450       req_state & REQUEST_WAIT_FOR_INPUT)
4451     SendToServer_ContinuePlaying();
4452 #endif
4453
4454   /* restore deactivated drawing when quick-loading level tape recording */
4455   if (tape.playing && tape.deactivate_display)
4456     TapeDeactivateDisplayOn();
4457
4458   return result;
4459 }
4460
4461 boolean Request(char *text, unsigned int req_state)
4462 {
4463   boolean overlay_active = GetOverlayActive();
4464   boolean result;
4465
4466   SetOverlayActive(FALSE);
4467
4468   if (global.use_envelope_request)
4469     result = RequestEnvelope(text, req_state);
4470   else
4471     result = RequestDoor(text, req_state);
4472
4473   SetOverlayActive(overlay_active);
4474
4475   return result;
4476 }
4477
4478 static int compareDoorPartOrderInfo(const void *object1, const void *object2)
4479 {
4480   const struct DoorPartOrderInfo *dpo1 = (struct DoorPartOrderInfo *)object1;
4481   const struct DoorPartOrderInfo *dpo2 = (struct DoorPartOrderInfo *)object2;
4482   int compare_result;
4483
4484   if (dpo1->sort_priority != dpo2->sort_priority)
4485     compare_result = dpo1->sort_priority - dpo2->sort_priority;
4486   else
4487     compare_result = dpo1->nr - dpo2->nr;
4488
4489   return compare_result;
4490 }
4491
4492 void InitGraphicCompatibilityInfo_Doors()
4493 {
4494   struct
4495   {
4496     int door_token;
4497     int part_1, part_8;
4498     struct DoorInfo *door;
4499   }
4500   doors[] =
4501   {
4502     { DOOR_1,   IMG_GFX_DOOR_1_PART_1,  IMG_GFX_DOOR_1_PART_8,  &door_1 },
4503     { DOOR_2,   IMG_GFX_DOOR_2_PART_1,  IMG_GFX_DOOR_2_PART_8,  &door_2 },
4504
4505     { -1,       -1,                     -1,                     NULL    }
4506   };
4507   struct Rect door_rect_list[] =
4508   {
4509     { DX, DY, DXSIZE, DYSIZE },
4510     { VX, VY, VXSIZE, VYSIZE }
4511   };
4512   int i, j;
4513
4514   for (i = 0; doors[i].door_token != -1; i++)
4515   {
4516     int door_token = doors[i].door_token;
4517     int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
4518     int part_1 = doors[i].part_1;
4519     int part_8 = doors[i].part_8;
4520     int part_2 = part_1 + 1;
4521     int part_3 = part_1 + 2;
4522     struct DoorInfo *door = doors[i].door;
4523     struct Rect *door_rect = &door_rect_list[door_index];
4524     boolean door_gfx_redefined = FALSE;
4525
4526     /* check if any door part graphic definitions have been redefined */
4527
4528     for (j = 0; door_part_controls[j].door_token != -1; j++)
4529     {
4530       struct DoorPartControlInfo *dpc = &door_part_controls[j];
4531       struct FileInfo *fi = getImageListEntryFromImageID(dpc->graphic);
4532
4533       if (dpc->door_token == door_token && fi->redefined)
4534         door_gfx_redefined = TRUE;
4535     }
4536
4537     /* check for old-style door graphic/animation modifications */
4538
4539     if (!door_gfx_redefined)
4540     {
4541       if (door->anim_mode & ANIM_STATIC_PANEL)
4542       {
4543         door->panel.step_xoffset = 0;
4544         door->panel.step_yoffset = 0;
4545       }
4546
4547       if (door->anim_mode & (ANIM_HORIZONTAL | ANIM_VERTICAL))
4548       {
4549         struct GraphicInfo *g_part_1 = &graphic_info[part_1];
4550         struct GraphicInfo *g_part_2 = &graphic_info[part_2];
4551         int num_door_steps, num_panel_steps;
4552
4553         /* remove door part graphics other than the two default wings */
4554
4555         for (j = 0; door_part_controls[j].door_token != -1; j++)
4556         {
4557           struct DoorPartControlInfo *dpc = &door_part_controls[j];
4558           struct GraphicInfo *g = &graphic_info[dpc->graphic];
4559
4560           if (dpc->graphic >= part_3 &&
4561               dpc->graphic <= part_8)
4562             g->bitmap = NULL;
4563         }
4564
4565         /* set graphics and screen positions of the default wings */
4566
4567         g_part_1->width  = door_rect->width;
4568         g_part_1->height = door_rect->height;
4569         g_part_2->width  = door_rect->width;
4570         g_part_2->height = door_rect->height;
4571         g_part_2->src_x = door_rect->width;
4572         g_part_2->src_y = g_part_1->src_y;
4573
4574         door->part_2.x = door->part_1.x;
4575         door->part_2.y = door->part_1.y;
4576
4577         if (door->width != -1)
4578         {
4579           g_part_1->width = door->width;
4580           g_part_2->width = door->width;
4581
4582           // special treatment for graphics and screen position of right wing
4583           g_part_2->src_x += door_rect->width - door->width;
4584           door->part_2.x  += door_rect->width - door->width;
4585         }
4586
4587         if (door->height != -1)
4588         {
4589           g_part_1->height = door->height;
4590           g_part_2->height = door->height;
4591
4592           // special treatment for graphics and screen position of bottom wing
4593           g_part_2->src_y += door_rect->height - door->height;
4594           door->part_2.y  += door_rect->height - door->height;
4595         }
4596
4597         /* set animation delays for the default wings and panels */
4598
4599         door->part_1.step_delay = door->step_delay;
4600         door->part_2.step_delay = door->step_delay;
4601         door->panel.step_delay  = door->step_delay;
4602
4603         /* set animation draw order for the default wings */
4604
4605         door->part_1.sort_priority = 2; /* draw left wing over ... */
4606         door->part_2.sort_priority = 1; /*          ... right wing */
4607
4608         /* set animation draw offset for the default wings */
4609
4610         if (door->anim_mode & ANIM_HORIZONTAL)
4611         {
4612           door->part_1.step_xoffset = door->step_offset;
4613           door->part_1.step_yoffset = 0;
4614           door->part_2.step_xoffset = door->step_offset * -1;
4615           door->part_2.step_yoffset = 0;
4616
4617           num_door_steps = g_part_1->width / door->step_offset;
4618         }
4619         else    // ANIM_VERTICAL
4620         {
4621           door->part_1.step_xoffset = 0;
4622           door->part_1.step_yoffset = door->step_offset;
4623           door->part_2.step_xoffset = 0;
4624           door->part_2.step_yoffset = door->step_offset * -1;
4625
4626           num_door_steps = g_part_1->height / door->step_offset;
4627         }
4628
4629         /* set animation draw offset for the default panels */
4630
4631         if (door->step_offset > 1)
4632         {
4633           num_panel_steps = 2 * door_rect->height / door->step_offset;
4634           door->panel.start_step = num_panel_steps - num_door_steps;
4635           door->panel.start_step_closing = door->panel.start_step;
4636         }
4637         else
4638         {
4639           num_panel_steps = door_rect->height / door->step_offset;
4640           door->panel.start_step = num_panel_steps - num_door_steps / 2;
4641           door->panel.start_step_closing = door->panel.start_step;
4642           door->panel.step_delay *= 2;
4643         }
4644       }
4645     }
4646   }
4647 }
4648
4649 void InitDoors()
4650 {
4651   int i;
4652
4653   for (i = 0; door_part_controls[i].door_token != -1; i++)
4654   {
4655     struct DoorPartControlInfo *dpc = &door_part_controls[i];
4656     struct DoorPartOrderInfo *dpo = &door_part_order[i];
4657
4658     /* initialize "start_step_opening" and "start_step_closing", if needed */
4659     if (dpc->pos->start_step_opening == 0 &&
4660         dpc->pos->start_step_closing == 0)
4661     {
4662       // dpc->pos->start_step_opening = dpc->pos->start_step;
4663       dpc->pos->start_step_closing = dpc->pos->start_step;
4664     }
4665
4666     /* fill structure for door part draw order (sorted below) */
4667     dpo->nr = i;
4668     dpo->sort_priority = dpc->pos->sort_priority;
4669   }
4670
4671   /* sort door part controls according to sort_priority and graphic number */
4672   qsort(door_part_order, MAX_DOOR_PARTS,
4673         sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
4674 }
4675
4676 unsigned int OpenDoor(unsigned int door_state)
4677 {
4678   if (door_state & DOOR_COPY_BACK)
4679   {
4680     if (door_state & DOOR_OPEN_1)
4681       BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
4682                  1 * DXSIZE, 0, DXSIZE, DYSIZE, 0 * DXSIZE, 0);
4683
4684     if (door_state & DOOR_OPEN_2)
4685       BlitBitmap(bitmap_db_door_2, bitmap_db_door_2,
4686                  1 * VXSIZE, 0, VXSIZE, VYSIZE, 0 * VXSIZE, 0);
4687
4688     door_state &= ~DOOR_COPY_BACK;
4689   }
4690
4691   return MoveDoor(door_state);
4692 }
4693
4694 unsigned int CloseDoor(unsigned int door_state)
4695 {
4696   unsigned int old_door_state = GetDoorState();
4697
4698   if (!(door_state & DOOR_NO_COPY_BACK))
4699   {
4700     if (old_door_state & DOOR_OPEN_1)
4701       BlitBitmap(backbuffer, bitmap_db_door_1,
4702                  DX, DY, DXSIZE, DYSIZE, 0, 0);
4703
4704     if (old_door_state & DOOR_OPEN_2)
4705       BlitBitmap(backbuffer, bitmap_db_door_2,
4706                  VX, VY, VXSIZE, VYSIZE, 0, 0);
4707
4708     door_state &= ~DOOR_NO_COPY_BACK;
4709   }
4710
4711   return MoveDoor(door_state);
4712 }
4713
4714 unsigned int GetDoorState()
4715 {
4716   return MoveDoor(DOOR_GET_STATE);
4717 }
4718
4719 unsigned int SetDoorState(unsigned int door_state)
4720 {
4721   return MoveDoor(door_state | DOOR_SET_STATE);
4722 }
4723
4724 int euclid(int a, int b)
4725 {
4726   return (b ? euclid(b, a % b) : a);
4727 }
4728
4729 unsigned int MoveDoor(unsigned int door_state)
4730 {
4731   struct Rect door_rect_list[] =
4732   {
4733     { DX, DY, DXSIZE, DYSIZE },
4734     { VX, VY, VXSIZE, VYSIZE }
4735   };
4736   static int door1 = DOOR_CLOSE_1;
4737   static int door2 = DOOR_CLOSE_2;
4738   unsigned int door_delay = 0;
4739   unsigned int door_delay_value;
4740   int i;
4741
4742   if (door_state == DOOR_GET_STATE)
4743     return (door1 | door2);
4744
4745   if (door_state & DOOR_SET_STATE)
4746   {
4747     if (door_state & DOOR_ACTION_1)
4748       door1 = door_state & DOOR_ACTION_1;
4749     if (door_state & DOOR_ACTION_2)
4750       door2 = door_state & DOOR_ACTION_2;
4751
4752     return (door1 | door2);
4753   }
4754
4755   if (!(door_state & DOOR_FORCE_REDRAW))
4756   {
4757     if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
4758       door_state &= ~DOOR_OPEN_1;
4759     else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
4760       door_state &= ~DOOR_CLOSE_1;
4761     if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
4762       door_state &= ~DOOR_OPEN_2;
4763     else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
4764       door_state &= ~DOOR_CLOSE_2;
4765   }
4766
4767   if (global.autoplay_leveldir)
4768   {
4769     door_state |= DOOR_NO_DELAY;
4770     door_state &= ~DOOR_CLOSE_ALL;
4771   }
4772
4773   if (game_status == GAME_MODE_EDITOR)
4774     door_state |= DOOR_NO_DELAY;
4775
4776   if (door_state & DOOR_ACTION)
4777   {
4778     boolean door_panel_drawn[NUM_DOORS];
4779     boolean panel_has_doors[NUM_DOORS];
4780     boolean door_part_skip[MAX_DOOR_PARTS];
4781     boolean door_part_done[MAX_DOOR_PARTS];
4782     boolean door_part_done_all;
4783     int num_steps[MAX_DOOR_PARTS];
4784     int max_move_delay = 0;     // delay for complete animations of all doors
4785     int max_step_delay = 0;     // delay (ms) between two animation frames
4786     int num_move_steps = 0;     // number of animation steps for all doors
4787     int max_move_delay_doors_only = 0;  // delay for doors only (no panel)
4788     int num_move_steps_doors_only = 0;  // steps for doors only (no panel)
4789     int current_move_delay = 0;
4790     int start = 0;
4791     int k;
4792
4793     for (i = 0; i < NUM_DOORS; i++)
4794       panel_has_doors[i] = FALSE;
4795
4796     for (i = 0; i < MAX_DOOR_PARTS; i++)
4797     {
4798       struct DoorPartControlInfo *dpc = &door_part_controls[i];
4799       struct GraphicInfo *g = &graphic_info[dpc->graphic];
4800       int door_token = dpc->door_token;
4801
4802       door_part_done[i] = FALSE;
4803       door_part_skip[i] = (!(door_state & door_token) ||
4804                            !g->bitmap);
4805     }
4806
4807     for (i = 0; i < MAX_DOOR_PARTS; i++)
4808     {
4809       int nr = door_part_order[i].nr;
4810       struct DoorPartControlInfo *dpc = &door_part_controls[nr];
4811       struct DoorPartPosInfo *pos = dpc->pos;
4812       struct GraphicInfo *g = &graphic_info[dpc->graphic];
4813       int door_token = dpc->door_token;
4814       int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
4815       boolean is_panel = DOOR_PART_IS_PANEL(nr);
4816       int step_xoffset = ABS(pos->step_xoffset);
4817       int step_yoffset = ABS(pos->step_yoffset);
4818       int step_delay = pos->step_delay;
4819       int current_door_state = door_state & door_token;
4820       boolean door_opening = ((current_door_state & DOOR_OPEN)  != 0);
4821       boolean door_closing = ((current_door_state & DOOR_CLOSE) != 0);
4822       boolean part_opening = (is_panel ? door_closing : door_opening);
4823       int start_step = (part_opening ? pos->start_step_opening :
4824                         pos->start_step_closing);
4825       float move_xsize = (step_xoffset ? g->width  : 0);
4826       float move_ysize = (step_yoffset ? g->height : 0);
4827       int move_xsteps = (step_xoffset ? ceil(move_xsize / step_xoffset) : 0);
4828       int move_ysteps = (step_yoffset ? ceil(move_ysize / step_yoffset) : 0);
4829       int move_steps = (move_xsteps && move_ysteps ?
4830                         MIN(move_xsteps, move_ysteps) :
4831                         move_xsteps ? move_xsteps : move_ysteps) - start_step;
4832       int move_delay = move_steps * step_delay;
4833
4834       if (door_part_skip[nr])
4835         continue;
4836
4837       max_move_delay = MAX(max_move_delay, move_delay);
4838       max_step_delay = (max_step_delay == 0 ? step_delay :
4839                         euclid(max_step_delay, step_delay));
4840       num_steps[nr] = move_steps;
4841
4842       if (!is_panel)
4843       {
4844         max_move_delay_doors_only = MAX(max_move_delay_doors_only, move_delay);
4845
4846         panel_has_doors[door_index] = TRUE;
4847       }
4848     }
4849
4850     max_step_delay = MAX(1, max_step_delay);    // prevent division by zero
4851
4852     num_move_steps = max_move_delay / max_step_delay;
4853     num_move_steps_doors_only = max_move_delay_doors_only / max_step_delay;
4854
4855     door_delay_value = max_step_delay;
4856
4857     if ((door_state & DOOR_NO_DELAY) || setup.quick_doors)
4858     {
4859       start = num_move_steps - 1;
4860     }
4861     else
4862     {
4863       /* opening door sound has priority over simultaneously closing door */
4864       if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
4865         PlayMenuSoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
4866       else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
4867         PlayMenuSoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
4868     }
4869
4870     for (k = start; k < num_move_steps; k++)
4871     {
4872       int last_frame = num_move_steps - 1;      // last frame of this "for" loop
4873
4874       door_part_done_all = TRUE;
4875
4876       for (i = 0; i < NUM_DOORS; i++)
4877         door_panel_drawn[i] = FALSE;
4878
4879       for (i = 0; i < MAX_DOOR_PARTS; i++)
4880       {
4881         int nr = door_part_order[i].nr;
4882         struct DoorPartControlInfo *dpc = &door_part_controls[nr];
4883         struct DoorPartPosInfo *pos = dpc->pos;
4884         struct GraphicInfo *g = &graphic_info[dpc->graphic];
4885         int door_token = dpc->door_token;
4886         int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
4887         boolean is_panel = DOOR_PART_IS_PANEL(nr);
4888         boolean is_panel_and_door_has_closed = FALSE;
4889         struct Rect *door_rect = &door_rect_list[door_index];
4890         Bitmap *bitmap_db_door = (door_token == DOOR_1 ? bitmap_db_door_1 :
4891                                   bitmap_db_door_2);
4892         Bitmap *bitmap = (is_panel ? bitmap_db_door : g->bitmap);
4893         int current_door_state = door_state & door_token;
4894         boolean door_opening = ((current_door_state & DOOR_OPEN)  != 0);
4895         boolean door_closing = !door_opening;
4896         boolean part_opening = (is_panel ? door_closing : door_opening);
4897         boolean part_closing = !part_opening;
4898         int start_step = (part_opening ? pos->start_step_opening :
4899                           pos->start_step_closing);
4900         int step_delay = pos->step_delay;
4901         int step_factor = step_delay / max_step_delay;
4902         int k1 = (step_factor ? k / step_factor + 1 : k);
4903         int k2 = (part_opening ? k1 + start_step : num_steps[nr] - k1);
4904         int kk = MAX(0, k2);
4905         int g_src_x = 0;
4906         int g_src_y = 0;
4907         int src_x, src_y, src_xx, src_yy;
4908         int dst_x, dst_y, dst_xx, dst_yy;
4909         int width, height;
4910
4911         if (door_part_skip[nr])
4912           continue;
4913
4914         if (!(door_state & door_token))
4915           continue;
4916
4917         if (!g->bitmap)
4918           continue;
4919
4920         if (!is_panel)
4921         {
4922           int k2_door = (door_opening ? k : num_move_steps_doors_only - k - 1);
4923           int kk_door = MAX(0, k2_door);
4924           int sync_frame = kk_door * door_delay_value;
4925           int frame = getGraphicAnimationFrame(dpc->graphic, sync_frame);
4926
4927           getFixedGraphicSource(dpc->graphic, frame, &bitmap,
4928                                 &g_src_x, &g_src_y);
4929         }
4930
4931         // draw door panel
4932
4933         if (!door_panel_drawn[door_index])
4934         {
4935           ClearRectangle(drawto, door_rect->x, door_rect->y,
4936                          door_rect->width, door_rect->height);
4937
4938           door_panel_drawn[door_index] = TRUE;
4939         }
4940
4941         // draw opening or closing door parts
4942
4943         if (pos->step_xoffset < 0)      // door part on right side
4944         {
4945           src_xx = 0;
4946           dst_xx = pos->x + ABS(kk * pos->step_xoffset);
4947           width = g->width;
4948
4949           if (dst_xx + width > door_rect->width)
4950             width = door_rect->width - dst_xx;
4951         }
4952         else                            // door part on left side
4953         {
4954           src_xx = 0;
4955           dst_xx = pos->x - kk * pos->step_xoffset;
4956
4957           if (dst_xx < 0)
4958           {
4959             src_xx = ABS(dst_xx);
4960             dst_xx = 0;
4961           }
4962
4963           width = g->width - src_xx;
4964
4965           if (width > door_rect->width)
4966             width = door_rect->width;
4967
4968           // printf("::: k == %d [%d] \n", k, start_step);
4969         }
4970
4971         if (pos->step_yoffset < 0)      // door part on bottom side
4972         {
4973           src_yy = 0;
4974           dst_yy = pos->y + ABS(kk * pos->step_yoffset);
4975           height = g->height;
4976
4977           if (dst_yy + height > door_rect->height)
4978             height = door_rect->height - dst_yy;
4979         }
4980         else                            // door part on top side
4981         {
4982           src_yy = 0;
4983           dst_yy = pos->y - kk * pos->step_yoffset;
4984
4985           if (dst_yy < 0)
4986           {
4987             src_yy = ABS(dst_yy);
4988             dst_yy = 0;
4989           }
4990
4991           height = g->height - src_yy;
4992         }
4993
4994         src_x = g_src_x + src_xx;
4995         src_y = g_src_y + src_yy;
4996
4997         dst_x = door_rect->x + dst_xx;
4998         dst_y = door_rect->y + dst_yy;
4999
5000         is_panel_and_door_has_closed =
5001           (is_panel &&
5002            door_closing &&
5003            panel_has_doors[door_index] &&
5004            k >= num_move_steps_doors_only - 1);
5005
5006         if (width  >= 0 && width  <= g->width &&
5007             height >= 0 && height <= g->height &&
5008             !is_panel_and_door_has_closed)
5009         {
5010           if (is_panel || !pos->draw_masked)
5011             BlitBitmap(bitmap, drawto, src_x, src_y, width, height,
5012                        dst_x, dst_y);
5013           else
5014             BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height,
5015                              dst_x, dst_y);
5016         }
5017
5018         redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
5019
5020         if ((part_opening && (width < 0         || height < 0)) ||
5021             (part_closing && (width >= g->width && height >= g->height)))
5022           door_part_done[nr] = TRUE;
5023
5024         // continue door part animations, but not panel after door has closed
5025         if (!door_part_done[nr] && !is_panel_and_door_has_closed)
5026           door_part_done_all = FALSE;
5027       }
5028
5029       if (!(door_state & DOOR_NO_DELAY))
5030       {
5031         BackToFront();
5032
5033         SkipUntilDelayReached(&door_delay, door_delay_value, &k, last_frame);
5034
5035         current_move_delay += max_step_delay;
5036
5037         /* prevent OS (Windows) from complaining about program not responding */
5038         CheckQuitEvent();
5039       }
5040
5041       if (door_part_done_all)
5042         break;
5043     }
5044   }
5045
5046   if (door_state & DOOR_ACTION_1)
5047     door1 = door_state & DOOR_ACTION_1;
5048   if (door_state & DOOR_ACTION_2)
5049     door2 = door_state & DOOR_ACTION_2;
5050
5051   // draw masked border over door area
5052   DrawMaskedBorder(REDRAW_DOOR_1);
5053   DrawMaskedBorder(REDRAW_DOOR_2);
5054
5055   return (door1 | door2);
5056 }
5057
5058 static boolean useSpecialEditorDoor()
5059 {
5060   int graphic = IMG_GLOBAL_BORDER_EDITOR;
5061   boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
5062
5063   // do not draw special editor door if editor border defined or redefined
5064   if (graphic_info[graphic].bitmap != NULL || redefined)
5065     return FALSE;
5066
5067   // do not draw special editor door if global border defined to be empty
5068   if (graphic_info[IMG_GLOBAL_BORDER].bitmap == NULL)
5069     return FALSE;
5070
5071   // do not draw special editor door if viewport definitions do not match
5072   if (EX != VX ||
5073       EY >= VY ||
5074       EXSIZE != VXSIZE ||
5075       EY + EYSIZE != VY + VYSIZE)
5076     return FALSE;
5077
5078   return TRUE;
5079 }
5080
5081 void DrawSpecialEditorDoor()
5082 {
5083   struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5084   int top_border_width = gfx1->width;
5085   int top_border_height = gfx1->height;
5086   int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5087   int ex = EX - outer_border;
5088   int ey = EY - outer_border;
5089   int vy = VY - outer_border;
5090   int exsize = EXSIZE + 2 * outer_border;
5091
5092   if (!useSpecialEditorDoor())
5093     return;
5094
5095   /* draw bigger level editor toolbox window */
5096   BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
5097              top_border_width, top_border_height, ex, ey - top_border_height);
5098   BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
5099              exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
5100
5101   redraw_mask |= REDRAW_ALL;
5102 }
5103
5104 void UndrawSpecialEditorDoor()
5105 {
5106   struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5107   int top_border_width = gfx1->width;
5108   int top_border_height = gfx1->height;
5109   int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5110   int ex = EX - outer_border;
5111   int ey = EY - outer_border;
5112   int ey_top = ey - top_border_height;
5113   int exsize = EXSIZE + 2 * outer_border;
5114   int eysize = EYSIZE + 2 * outer_border;
5115
5116   if (!useSpecialEditorDoor())
5117     return;
5118
5119   /* draw normal tape recorder window */
5120   if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
5121   {
5122     BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5123                ex, ey_top, top_border_width, top_border_height,
5124                ex, ey_top);
5125     BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5126                ex, ey, exsize, eysize, ex, ey);
5127   }
5128   else
5129   {
5130     // if screen background is set to "[NONE]", clear editor toolbox window
5131     ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
5132     ClearRectangle(drawto, ex, ey, exsize, eysize);
5133   }
5134
5135   redraw_mask |= REDRAW_ALL;
5136 }
5137
5138
5139 /* ---------- new tool button stuff ---------------------------------------- */
5140
5141 static struct
5142 {
5143   int graphic;
5144   struct TextPosInfo *pos;
5145   int gadget_id;
5146   char *infotext;
5147 } toolbutton_info[NUM_TOOL_BUTTONS] =
5148 {
5149   {
5150     IMG_GFX_REQUEST_BUTTON_YES,         &request.button.yes,
5151     TOOL_CTRL_ID_YES,                   "yes"
5152   },
5153   {
5154     IMG_GFX_REQUEST_BUTTON_NO,          &request.button.no,
5155     TOOL_CTRL_ID_NO,                    "no"
5156   },
5157   {
5158     IMG_GFX_REQUEST_BUTTON_CONFIRM,     &request.button.confirm,
5159     TOOL_CTRL_ID_CONFIRM,               "confirm"
5160   },
5161   {
5162     IMG_GFX_REQUEST_BUTTON_PLAYER_1,    &request.button.player_1,
5163     TOOL_CTRL_ID_PLAYER_1,              "player 1"
5164   },
5165   {
5166     IMG_GFX_REQUEST_BUTTON_PLAYER_2,    &request.button.player_2,
5167     TOOL_CTRL_ID_PLAYER_2,              "player 2"
5168   },
5169   {
5170     IMG_GFX_REQUEST_BUTTON_PLAYER_3,    &request.button.player_3,
5171     TOOL_CTRL_ID_PLAYER_3,              "player 3"
5172   },
5173   {
5174     IMG_GFX_REQUEST_BUTTON_PLAYER_4,    &request.button.player_4,
5175     TOOL_CTRL_ID_PLAYER_4,              "player 4"
5176   }
5177 };
5178
5179 void CreateToolButtons()
5180 {
5181   int i;
5182
5183   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5184   {
5185     struct GraphicInfo *gfx = &graphic_info[toolbutton_info[i].graphic];
5186     struct TextPosInfo *pos = toolbutton_info[i].pos;
5187     struct GadgetInfo *gi;
5188     Bitmap *deco_bitmap = None;
5189     int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
5190     unsigned int event_mask = GD_EVENT_RELEASED;
5191     int dx = DX;
5192     int dy = DY;
5193     int gd_x = gfx->src_x;
5194     int gd_y = gfx->src_y;
5195     int gd_xp = gfx->src_x + gfx->pressed_xoffset;
5196     int gd_yp = gfx->src_y + gfx->pressed_yoffset;
5197     int id = i;
5198
5199     if (global.use_envelope_request)
5200       setRequestPosition(&dx, &dy, TRUE);
5201
5202     if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
5203     {
5204       int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5205
5206       getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
5207                             pos->size, &deco_bitmap, &deco_x, &deco_y);
5208       deco_xpos = (gfx->width  - pos->size) / 2;
5209       deco_ypos = (gfx->height - pos->size) / 2;
5210     }
5211
5212     gi = CreateGadget(GDI_CUSTOM_ID, id,
5213                       GDI_INFO_TEXT, toolbutton_info[i].infotext,
5214                       GDI_X, dx + GDI_ACTIVE_POS(pos->x),
5215                       GDI_Y, dy + GDI_ACTIVE_POS(pos->y),
5216                       GDI_WIDTH, gfx->width,
5217                       GDI_HEIGHT, gfx->height,
5218                       GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
5219                       GDI_STATE, GD_BUTTON_UNPRESSED,
5220                       GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
5221                       GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
5222                       GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
5223                       GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
5224                       GDI_DECORATION_SIZE, pos->size, pos->size,
5225                       GDI_DECORATION_SHIFTING, 1, 1,
5226                       GDI_DIRECT_DRAW, FALSE,
5227                       GDI_EVENT_MASK, event_mask,
5228                       GDI_CALLBACK_ACTION, HandleToolButtons,
5229                       GDI_END);
5230
5231     if (gi == NULL)
5232       Error(ERR_EXIT, "cannot create gadget");
5233
5234     tool_gadget[id] = gi;
5235   }
5236 }
5237
5238 void FreeToolButtons()
5239 {
5240   int i;
5241
5242   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5243     FreeGadget(tool_gadget[i]);
5244 }
5245
5246 static void UnmapToolButtons()
5247 {
5248   int i;
5249
5250   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5251     UnmapGadget(tool_gadget[i]);
5252 }
5253
5254 static void HandleToolButtons(struct GadgetInfo *gi)
5255 {
5256   request_gadget_id = gi->custom_id;
5257 }
5258
5259 static struct Mapping_EM_to_RND_object
5260 {
5261   int element_em;
5262   boolean is_rnd_to_em_mapping;         /* unique mapping EM <-> RND */
5263   boolean is_backside;                  /* backside of moving element */
5264
5265   int element_rnd;
5266   int action;
5267   int direction;
5268 }
5269 em_object_mapping_list[] =
5270 {
5271   {
5272     Xblank,                             TRUE,   FALSE,
5273     EL_EMPTY,                           -1, -1
5274   },
5275   {
5276     Yacid_splash_eB,                    FALSE,  FALSE,
5277     EL_ACID_SPLASH_RIGHT,               -1, -1
5278   },
5279   {
5280     Yacid_splash_wB,                    FALSE,  FALSE,
5281     EL_ACID_SPLASH_LEFT,                -1, -1
5282   },
5283
5284 #ifdef EM_ENGINE_BAD_ROLL
5285   {
5286     Xstone_force_e,                     FALSE,  FALSE,
5287     EL_ROCK,                            -1, MV_BIT_RIGHT
5288   },
5289   {
5290     Xstone_force_w,                     FALSE,  FALSE,
5291     EL_ROCK,                            -1, MV_BIT_LEFT
5292   },
5293   {
5294     Xnut_force_e,                       FALSE,  FALSE,
5295     EL_NUT,                             -1, MV_BIT_RIGHT
5296   },
5297   {
5298     Xnut_force_w,                       FALSE,  FALSE,
5299     EL_NUT,                             -1, MV_BIT_LEFT
5300   },
5301   {
5302     Xspring_force_e,                    FALSE,  FALSE,
5303     EL_SPRING,                          -1, MV_BIT_RIGHT
5304   },
5305   {
5306     Xspring_force_w,                    FALSE,  FALSE,
5307     EL_SPRING,                          -1, MV_BIT_LEFT
5308   },
5309   {
5310     Xemerald_force_e,                   FALSE,  FALSE,
5311     EL_EMERALD,                         -1, MV_BIT_RIGHT
5312   },
5313   {
5314     Xemerald_force_w,                   FALSE,  FALSE,
5315     EL_EMERALD,                         -1, MV_BIT_LEFT
5316   },
5317   {
5318     Xdiamond_force_e,                   FALSE,  FALSE,
5319     EL_DIAMOND,                         -1, MV_BIT_RIGHT
5320   },
5321   {
5322     Xdiamond_force_w,                   FALSE,  FALSE,
5323     EL_DIAMOND,                         -1, MV_BIT_LEFT
5324   },
5325   {
5326     Xbomb_force_e,                      FALSE,  FALSE,
5327     EL_BOMB,                            -1, MV_BIT_RIGHT
5328   },
5329   {
5330     Xbomb_force_w,                      FALSE,  FALSE,
5331     EL_BOMB,                            -1, MV_BIT_LEFT
5332   },
5333 #endif  /* EM_ENGINE_BAD_ROLL */
5334
5335   {
5336     Xstone,                             TRUE,   FALSE,
5337     EL_ROCK,                            -1, -1
5338   },
5339   {
5340     Xstone_pause,                       FALSE,  FALSE,
5341     EL_ROCK,                            -1, -1
5342   },
5343   {
5344     Xstone_fall,                        FALSE,  FALSE,
5345     EL_ROCK,                            -1, -1
5346   },
5347   {
5348     Ystone_s,                           FALSE,  FALSE,
5349     EL_ROCK,                            ACTION_FALLING, -1
5350   },
5351   {
5352     Ystone_sB,                          FALSE,  TRUE,
5353     EL_ROCK,                            ACTION_FALLING, -1
5354   },
5355   {
5356     Ystone_e,                           FALSE,  FALSE,
5357     EL_ROCK,                            ACTION_MOVING, MV_BIT_RIGHT
5358   },
5359   {
5360     Ystone_eB,                          FALSE,  TRUE,
5361     EL_ROCK,                            ACTION_MOVING, MV_BIT_RIGHT
5362   },
5363   {
5364     Ystone_w,                           FALSE,  FALSE,
5365     EL_ROCK,                            ACTION_MOVING, MV_BIT_LEFT
5366   },
5367   {
5368     Ystone_wB,                          FALSE,  TRUE,
5369     EL_ROCK,                            ACTION_MOVING, MV_BIT_LEFT
5370   },
5371   {
5372     Xnut,                               TRUE,   FALSE,
5373     EL_NUT,                             -1, -1
5374   },
5375   {
5376     Xnut_pause,                         FALSE,  FALSE,
5377     EL_NUT,                             -1, -1
5378   },
5379   {
5380     Xnut_fall,                          FALSE,  FALSE,
5381     EL_NUT,                             -1, -1
5382   },
5383   {
5384     Ynut_s,                             FALSE,  FALSE,
5385     EL_NUT,                             ACTION_FALLING, -1
5386   },
5387   {
5388     Ynut_sB,                            FALSE,  TRUE,
5389     EL_NUT,                             ACTION_FALLING, -1
5390   },
5391   {
5392     Ynut_e,                             FALSE,  FALSE,
5393     EL_NUT,                             ACTION_MOVING, MV_BIT_RIGHT
5394   },
5395   {
5396     Ynut_eB,                            FALSE,  TRUE,
5397     EL_NUT,                             ACTION_MOVING, MV_BIT_RIGHT
5398   },
5399   {
5400     Ynut_w,                             FALSE,  FALSE,
5401     EL_NUT,                             ACTION_MOVING, MV_BIT_LEFT
5402   },
5403   {
5404     Ynut_wB,                            FALSE,  TRUE,
5405     EL_NUT,                             ACTION_MOVING, MV_BIT_LEFT
5406   },
5407   {
5408     Xbug_n,                             TRUE,   FALSE,
5409     EL_BUG_UP,                          -1, -1
5410   },
5411   {
5412     Xbug_e,                             TRUE,   FALSE,
5413     EL_BUG_RIGHT,                       -1, -1
5414   },
5415   {
5416     Xbug_s,                             TRUE,   FALSE,
5417     EL_BUG_DOWN,                        -1, -1
5418   },
5419   {
5420     Xbug_w,                             TRUE,   FALSE,
5421     EL_BUG_LEFT,                        -1, -1
5422   },
5423   {
5424     Xbug_gon,                           FALSE,  FALSE,
5425     EL_BUG_UP,                          -1, -1
5426   },
5427   {
5428     Xbug_goe,                           FALSE,  FALSE,
5429     EL_BUG_RIGHT,                       -1, -1
5430   },
5431   {
5432     Xbug_gos,                           FALSE,  FALSE,
5433     EL_BUG_DOWN,                        -1, -1
5434   },
5435   {
5436     Xbug_gow,                           FALSE,  FALSE,
5437     EL_BUG_LEFT,                        -1, -1
5438   },
5439   {
5440     Ybug_n,                             FALSE,  FALSE,
5441     EL_BUG,                             ACTION_MOVING, MV_BIT_UP
5442   },
5443   {
5444     Ybug_nB,                            FALSE,  TRUE,
5445     EL_BUG,                             ACTION_MOVING, MV_BIT_UP
5446   },
5447   {
5448     Ybug_e,                             FALSE,  FALSE,
5449     EL_BUG,                             ACTION_MOVING, MV_BIT_RIGHT
5450   },
5451   {
5452     Ybug_eB,                            FALSE,  TRUE,
5453     EL_BUG,                             ACTION_MOVING, MV_BIT_RIGHT
5454   },
5455   {
5456     Ybug_s,                             FALSE,  FALSE,
5457     EL_BUG,                             ACTION_MOVING, MV_BIT_DOWN
5458   },
5459   {
5460     Ybug_sB,                            FALSE,  TRUE,
5461     EL_BUG,                             ACTION_MOVING, MV_BIT_DOWN
5462   },
5463   {
5464     Ybug_w,                             FALSE,  FALSE,
5465     EL_BUG,                             ACTION_MOVING, MV_BIT_LEFT
5466   },
5467   {
5468     Ybug_wB,                            FALSE,  TRUE,
5469     EL_BUG,                             ACTION_MOVING, MV_BIT_LEFT
5470   },
5471   {
5472     Ybug_w_n,                           FALSE,  FALSE,
5473     EL_BUG,                             ACTION_TURNING_FROM_LEFT, MV_BIT_UP
5474   },
5475   {
5476     Ybug_n_e,                           FALSE,  FALSE,
5477     EL_BUG,                             ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
5478   },
5479   {
5480     Ybug_e_s,                           FALSE,  FALSE,
5481     EL_BUG,                             ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
5482   },
5483   {
5484     Ybug_s_w,                           FALSE,  FALSE,
5485     EL_BUG,                             ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
5486   },
5487   {
5488     Ybug_e_n,                           FALSE,  FALSE,
5489     EL_BUG,                             ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
5490   },
5491   {
5492     Ybug_s_e,                           FALSE,  FALSE,
5493     EL_BUG,                             ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
5494   },
5495   {
5496     Ybug_w_s,                           FALSE,  FALSE,
5497     EL_BUG,                             ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
5498   },
5499   {
5500     Ybug_n_w,                           FALSE,  FALSE,
5501     EL_BUG,                             ACTION_TURNING_FROM_UP, MV_BIT_LEFT
5502   },
5503   {
5504     Ybug_stone,                         FALSE,  FALSE,
5505     EL_BUG,                             ACTION_SMASHED_BY_ROCK, -1
5506   },
5507   {
5508     Ybug_spring,                        FALSE,  FALSE,
5509     EL_BUG,                             ACTION_SMASHED_BY_SPRING, -1
5510   },
5511   {
5512     Xtank_n,                            TRUE,   FALSE,
5513     EL_SPACESHIP_UP,                    -1, -1
5514   },
5515   {
5516     Xtank_e,                            TRUE,   FALSE,
5517     EL_SPACESHIP_RIGHT,                 -1, -1
5518   },
5519   {
5520     Xtank_s,                            TRUE,   FALSE,
5521     EL_SPACESHIP_DOWN,                  -1, -1
5522   },
5523   {
5524     Xtank_w,                            TRUE,   FALSE,
5525     EL_SPACESHIP_LEFT,                  -1, -1
5526   },
5527   {
5528     Xtank_gon,                          FALSE,  FALSE,
5529     EL_SPACESHIP_UP,                    -1, -1
5530   },
5531   {
5532     Xtank_goe,                          FALSE,  FALSE,
5533     EL_SPACESHIP_RIGHT,                 -1, -1
5534   },
5535   {
5536     Xtank_gos,                          FALSE,  FALSE,
5537     EL_SPACESHIP_DOWN,                  -1, -1
5538   },
5539   {
5540     Xtank_gow,                          FALSE,  FALSE,
5541     EL_SPACESHIP_LEFT,                  -1, -1
5542   },
5543   {
5544     Ytank_n,                            FALSE,  FALSE,
5545     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_UP
5546   },
5547   {
5548     Ytank_nB,                           FALSE,  TRUE,
5549     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_UP
5550   },
5551   {
5552     Ytank_e,                            FALSE,  FALSE,
5553     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_RIGHT
5554   },
5555   {
5556     Ytank_eB,                           FALSE,  TRUE,
5557     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_RIGHT
5558   },
5559   {
5560     Ytank_s,                            FALSE,  FALSE,
5561     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_DOWN
5562   },
5563   {
5564     Ytank_sB,                           FALSE,  TRUE,
5565     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_DOWN
5566   },
5567   {
5568     Ytank_w,                            FALSE,  FALSE,
5569     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_LEFT
5570   },
5571   {
5572     Ytank_wB,                           FALSE,  TRUE,
5573     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_LEFT
5574   },
5575   {
5576     Ytank_w_n,                          FALSE,  FALSE,
5577     EL_SPACESHIP,                       ACTION_TURNING_FROM_LEFT, MV_BIT_UP
5578   },
5579   {
5580     Ytank_n_e,                          FALSE,  FALSE,
5581     EL_SPACESHIP,                       ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
5582   },
5583   {
5584     Ytank_e_s,                          FALSE,  FALSE,
5585     EL_SPACESHIP,                       ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
5586   },
5587   {
5588     Ytank_s_w,                          FALSE,  FALSE,
5589     EL_SPACESHIP,                       ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
5590   },
5591   {
5592     Ytank_e_n,                          FALSE,  FALSE,
5593     EL_SPACESHIP,                       ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
5594   },
5595   {
5596     Ytank_s_e,                          FALSE,  FALSE,
5597     EL_SPACESHIP,                       ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
5598   },
5599   {
5600     Ytank_w_s,                          FALSE,  FALSE,
5601     EL_SPACESHIP,                       ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
5602   },
5603   {
5604     Ytank_n_w,                          FALSE,  FALSE,
5605     EL_SPACESHIP,                       ACTION_TURNING_FROM_UP, MV_BIT_LEFT
5606   },
5607   {
5608     Ytank_stone,                        FALSE,  FALSE,
5609     EL_SPACESHIP,                       ACTION_SMASHED_BY_ROCK, -1
5610   },
5611   {
5612     Ytank_spring,                       FALSE,  FALSE,
5613     EL_SPACESHIP,                       ACTION_SMASHED_BY_SPRING, -1
5614   },
5615   {
5616     Xandroid,                           TRUE,   FALSE,
5617     EL_EMC_ANDROID,                     ACTION_ACTIVE, -1
5618   },
5619   {
5620     Xandroid_1_n,                       FALSE,  FALSE,
5621     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_UP
5622   },
5623   {
5624     Xandroid_2_n,                       FALSE,  FALSE,
5625     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_UP
5626   },
5627   {
5628     Xandroid_1_e,                       FALSE,  FALSE,
5629     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_RIGHT
5630   },
5631   {
5632     Xandroid_2_e,                       FALSE,  FALSE,
5633     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_RIGHT
5634   },
5635   {
5636     Xandroid_1_w,                       FALSE,  FALSE,
5637     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_LEFT
5638   },
5639   {
5640     Xandroid_2_w,                       FALSE,  FALSE,
5641     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_LEFT
5642   },
5643   {
5644     Xandroid_1_s,                       FALSE,  FALSE,
5645     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_DOWN
5646   },
5647   {
5648     Xandroid_2_s,                       FALSE,  FALSE,
5649     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_DOWN
5650   },
5651   {
5652     Yandroid_n,                         FALSE,  FALSE,
5653     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_UP
5654   },
5655   {
5656     Yandroid_nB,                        FALSE,  TRUE,
5657     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_UP
5658   },
5659   {
5660     Yandroid_ne,                        FALSE,  FALSE,
5661     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_UPRIGHT
5662   },
5663   {
5664     Yandroid_neB,                       FALSE,  TRUE,
5665     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_UPRIGHT
5666   },
5667   {
5668     Yandroid_e,                         FALSE,  FALSE,
5669     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_RIGHT
5670   },
5671   {
5672     Yandroid_eB,                        FALSE,  TRUE,
5673     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_RIGHT
5674   },
5675   {
5676     Yandroid_se,                        FALSE,  FALSE,
5677     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_DOWNRIGHT
5678   },
5679   {
5680     Yandroid_seB,                       FALSE,  TRUE,
5681     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_DOWNRIGHT
5682   },
5683   {
5684     Yandroid_s,                         FALSE,  FALSE,
5685     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_DOWN
5686   },
5687   {
5688     Yandroid_sB,                        FALSE,  TRUE,
5689     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_DOWN
5690   },
5691   {
5692     Yandroid_sw,                        FALSE,  FALSE,
5693     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_DOWNLEFT
5694   },
5695   {
5696     Yandroid_swB,                       FALSE,  TRUE,
5697     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_DOWNLEFT
5698   },
5699   {
5700     Yandroid_w,                         FALSE,  FALSE,
5701     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_LEFT
5702   },
5703   {
5704     Yandroid_wB,                        FALSE,  TRUE,
5705     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_LEFT
5706   },
5707   {
5708     Yandroid_nw,                        FALSE,  FALSE,
5709     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_UPLEFT
5710   },
5711   {
5712     Yandroid_nwB,                       FALSE,  TRUE,
5713     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_UPLEFT
5714   },
5715   {
5716     Xspring,                            TRUE,   FALSE,
5717     EL_SPRING,                          -1, -1
5718   },
5719   {
5720     Xspring_pause,                      FALSE,  FALSE,
5721     EL_SPRING,                          -1, -1
5722   },
5723   {
5724     Xspring_e,                          FALSE,  FALSE,
5725     EL_SPRING,                          -1, -1
5726   },
5727   {
5728     Xspring_w,                          FALSE,  FALSE,
5729     EL_SPRING,                          -1, -1
5730   },
5731   {
5732     Xspring_fall,                       FALSE,  FALSE,
5733     EL_SPRING,                          -1, -1
5734   },
5735   {
5736     Yspring_s,                          FALSE,  FALSE,
5737     EL_SPRING,                          ACTION_FALLING, -1
5738   },
5739   {
5740     Yspring_sB,                         FALSE,  TRUE,
5741     EL_SPRING,                          ACTION_FALLING, -1
5742   },
5743   {
5744     Yspring_e,                          FALSE,  FALSE,
5745     EL_SPRING,                          ACTION_MOVING, MV_BIT_RIGHT
5746   },
5747   {
5748     Yspring_eB,                         FALSE,  TRUE,
5749     EL_SPRING,                          ACTION_MOVING, MV_BIT_RIGHT
5750   },
5751   {
5752     Yspring_w,                          FALSE,  FALSE,
5753     EL_SPRING,                          ACTION_MOVING, MV_BIT_LEFT
5754   },
5755   {
5756     Yspring_wB,                         FALSE,  TRUE,
5757     EL_SPRING,                          ACTION_MOVING, MV_BIT_LEFT
5758   },
5759   {
5760     Yspring_kill_e,                     FALSE,  FALSE,
5761     EL_SPRING,                          ACTION_EATING, MV_BIT_RIGHT
5762   },
5763   {
5764     Yspring_kill_eB,                    FALSE,  TRUE,
5765     EL_SPRING,                          ACTION_EATING, MV_BIT_RIGHT
5766   },
5767   {
5768     Yspring_kill_w,                     FALSE,  FALSE,
5769     EL_SPRING,                          ACTION_EATING, MV_BIT_LEFT
5770   },
5771   {
5772     Yspring_kill_wB,                    FALSE,  TRUE,
5773     EL_SPRING,                          ACTION_EATING, MV_BIT_LEFT
5774   },
5775   {
5776     Xeater_n,                           TRUE,   FALSE,
5777     EL_YAMYAM_UP,                       -1, -1
5778   },
5779   {
5780     Xeater_e,                           TRUE,   FALSE,
5781     EL_YAMYAM_RIGHT,                    -1, -1
5782   },
5783   {
5784     Xeater_w,                           TRUE,   FALSE,
5785     EL_YAMYAM_LEFT,                     -1, -1
5786   },
5787   {
5788     Xeater_s,                           TRUE,   FALSE,
5789     EL_YAMYAM_DOWN,                     -1, -1
5790   },
5791   {
5792     Yeater_n,                           FALSE,  FALSE,
5793     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_UP
5794   },
5795   {
5796     Yeater_nB,                          FALSE,  TRUE,
5797     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_UP
5798   },
5799   {
5800     Yeater_e,                           FALSE,  FALSE,
5801     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_RIGHT
5802   },
5803   {
5804     Yeater_eB,                          FALSE,  TRUE,
5805     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_RIGHT
5806   },
5807   {
5808     Yeater_s,                           FALSE,  FALSE,
5809     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_DOWN
5810   },
5811   {
5812     Yeater_sB,                          FALSE,  TRUE,
5813     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_DOWN
5814   },
5815   {
5816     Yeater_w,                           FALSE,  FALSE,
5817     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_LEFT
5818   },
5819   {
5820     Yeater_wB,                          FALSE,  TRUE,
5821     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_LEFT
5822   },
5823   {
5824     Yeater_stone,                       FALSE,  FALSE,
5825     EL_YAMYAM,                          ACTION_SMASHED_BY_ROCK, -1
5826   },
5827   {
5828     Yeater_spring,                      FALSE,  FALSE,
5829     EL_YAMYAM,                          ACTION_SMASHED_BY_SPRING, -1
5830   },
5831   {
5832     Xalien,                             TRUE,   FALSE,
5833     EL_ROBOT,                           -1, -1
5834   },
5835   {
5836     Xalien_pause,                       FALSE,  FALSE,
5837     EL_ROBOT,                           -1, -1
5838   },
5839   {
5840     Yalien_n,                           FALSE,  FALSE,
5841     EL_ROBOT,                           ACTION_MOVING, MV_BIT_UP
5842   },
5843   {
5844     Yalien_nB,                          FALSE,  TRUE,
5845     EL_ROBOT,                           ACTION_MOVING, MV_BIT_UP
5846   },
5847   {
5848     Yalien_e,                           FALSE,  FALSE,
5849     EL_ROBOT,                           ACTION_MOVING, MV_BIT_RIGHT
5850   },
5851   {
5852     Yalien_eB,                          FALSE,  TRUE,
5853     EL_ROBOT,                           ACTION_MOVING, MV_BIT_RIGHT
5854   },
5855   {
5856     Yalien_s,                           FALSE,  FALSE,
5857     EL_ROBOT,                           ACTION_MOVING, MV_BIT_DOWN
5858   },
5859   {
5860     Yalien_sB,                          FALSE,  TRUE,
5861     EL_ROBOT,                           ACTION_MOVING, MV_BIT_DOWN
5862   },
5863   {
5864     Yalien_w,                           FALSE,  FALSE,
5865     EL_ROBOT,                           ACTION_MOVING, MV_BIT_LEFT
5866   },
5867   {
5868     Yalien_wB,                          FALSE,  TRUE,
5869     EL_ROBOT,                           ACTION_MOVING, MV_BIT_LEFT
5870   },
5871   {
5872     Yalien_stone,                       FALSE,  FALSE,
5873     EL_ROBOT,                           ACTION_SMASHED_BY_ROCK, -1
5874   },
5875   {
5876     Yalien_spring,                      FALSE,  FALSE,
5877     EL_ROBOT,                           ACTION_SMASHED_BY_SPRING, -1
5878   },
5879   {
5880     Xemerald,                           TRUE,   FALSE,
5881     EL_EMERALD,                         -1, -1
5882   },
5883   {
5884     Xemerald_pause,                     FALSE,  FALSE,
5885     EL_EMERALD,                         -1, -1
5886   },
5887   {
5888     Xemerald_fall,                      FALSE,  FALSE,
5889     EL_EMERALD,                         -1, -1
5890   },
5891   {
5892     Xemerald_shine,                     FALSE,  FALSE,
5893     EL_EMERALD,                         ACTION_TWINKLING, -1
5894   },
5895   {
5896     Yemerald_s,                         FALSE,  FALSE,
5897     EL_EMERALD,                         ACTION_FALLING, -1
5898   },
5899   {
5900     Yemerald_sB,                        FALSE,  TRUE,
5901     EL_EMERALD,                         ACTION_FALLING, -1
5902   },
5903   {
5904     Yemerald_e,                         FALSE,  FALSE,
5905     EL_EMERALD,                         ACTION_MOVING, MV_BIT_RIGHT
5906   },
5907   {
5908     Yemerald_eB,                        FALSE,  TRUE,
5909     EL_EMERALD,                         ACTION_MOVING, MV_BIT_RIGHT
5910   },
5911   {
5912     Yemerald_w,                         FALSE,  FALSE,
5913     EL_EMERALD,                         ACTION_MOVING, MV_BIT_LEFT
5914   },
5915   {
5916     Yemerald_wB,                        FALSE,  TRUE,
5917     EL_EMERALD,                         ACTION_MOVING, MV_BIT_LEFT
5918   },
5919   {
5920     Yemerald_eat,                       FALSE,  FALSE,
5921     EL_EMERALD,                         ACTION_COLLECTING, -1
5922   },
5923   {
5924     Yemerald_stone,                     FALSE,  FALSE,
5925     EL_NUT,                             ACTION_BREAKING, -1
5926   },
5927   {
5928     Xdiamond,                           TRUE,   FALSE,
5929     EL_DIAMOND,                         -1, -1
5930   },
5931   {
5932     Xdiamond_pause,                     FALSE,  FALSE,
5933     EL_DIAMOND,                         -1, -1
5934   },
5935   {
5936     Xdiamond_fall,                      FALSE,  FALSE,
5937     EL_DIAMOND,                         -1, -1
5938   },
5939   {
5940     Xdiamond_shine,                     FALSE,  FALSE,
5941     EL_DIAMOND,                         ACTION_TWINKLING, -1
5942   },
5943   {
5944     Ydiamond_s,                         FALSE,  FALSE,
5945     EL_DIAMOND,                         ACTION_FALLING, -1
5946   },
5947   {
5948     Ydiamond_sB,                        FALSE,  TRUE,
5949     EL_DIAMOND,                         ACTION_FALLING, -1
5950   },
5951   {
5952     Ydiamond_e,                         FALSE,  FALSE,
5953     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_RIGHT
5954   },
5955   {
5956     Ydiamond_eB,                        FALSE,  TRUE,
5957     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_RIGHT
5958   },
5959   {
5960     Ydiamond_w,                         FALSE,  FALSE,
5961     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_LEFT
5962   },
5963   {
5964     Ydiamond_wB,                        FALSE,  TRUE,
5965     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_LEFT
5966   },
5967   {
5968     Ydiamond_eat,                       FALSE,  FALSE,
5969     EL_DIAMOND,                         ACTION_COLLECTING, -1
5970   },
5971   {
5972     Ydiamond_stone,                     FALSE,  FALSE,
5973     EL_DIAMOND,                         ACTION_SMASHED_BY_ROCK, -1
5974   },
5975   {
5976     Xdrip_fall,                         TRUE,   FALSE,
5977     EL_AMOEBA_DROP,                     -1, -1
5978   },
5979   {
5980     Xdrip_stretch,                      FALSE,  FALSE,
5981     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
5982   },
5983   {
5984     Xdrip_stretchB,                     FALSE,  TRUE,
5985     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
5986   },
5987   {
5988     Xdrip_eat,                          FALSE,  FALSE,
5989     EL_AMOEBA_DROP,                     ACTION_GROWING, -1
5990   },
5991   {
5992     Ydrip_s1,                           FALSE,  FALSE,
5993     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
5994   },
5995   {
5996     Ydrip_s1B,                          FALSE,  TRUE,
5997     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
5998   },
5999   {
6000     Ydrip_s2,                           FALSE,  FALSE,
6001     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
6002   },
6003   {
6004     Ydrip_s2B,                          FALSE,  TRUE,
6005     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
6006   },
6007   {
6008     Xbomb,                              TRUE,   FALSE,
6009     EL_BOMB,                            -1, -1
6010   },
6011   {
6012     Xbomb_pause,                        FALSE,  FALSE,
6013     EL_BOMB,                            -1, -1
6014   },
6015   {
6016     Xbomb_fall,                         FALSE,  FALSE,
6017     EL_BOMB,                            -1, -1
6018   },
6019   {
6020     Ybomb_s,                            FALSE,  FALSE,
6021     EL_BOMB,                            ACTION_FALLING, -1
6022   },
6023   {
6024     Ybomb_sB,                           FALSE,  TRUE,
6025     EL_BOMB,                            ACTION_FALLING, -1
6026   },
6027   {
6028     Ybomb_e,                            FALSE,  FALSE,
6029     EL_BOMB,                            ACTION_MOVING, MV_BIT_RIGHT
6030   },
6031   {
6032     Ybomb_eB,                           FALSE,  TRUE,
6033     EL_BOMB,                            ACTION_MOVING, MV_BIT_RIGHT
6034   },
6035   {
6036     Ybomb_w,                            FALSE,  FALSE,
6037     EL_BOMB,                            ACTION_MOVING, MV_BIT_LEFT
6038   },
6039   {
6040     Ybomb_wB,                           FALSE,  TRUE,
6041     EL_BOMB,                            ACTION_MOVING, MV_BIT_LEFT
6042   },
6043   {
6044     Ybomb_eat,                          FALSE,  FALSE,
6045     EL_BOMB,                            ACTION_ACTIVATING, -1
6046   },
6047   {
6048     Xballoon,                           TRUE,   FALSE,
6049     EL_BALLOON,                         -1, -1
6050   },
6051   {
6052     Yballoon_n,                         FALSE,  FALSE,
6053     EL_BALLOON,                         ACTION_MOVING, MV_BIT_UP
6054   },
6055   {
6056     Yballoon_nB,                        FALSE,  TRUE,
6057     EL_BALLOON,                         ACTION_MOVING, MV_BIT_UP
6058   },
6059   {
6060     Yballoon_e,                         FALSE,  FALSE,
6061     EL_BALLOON,                         ACTION_MOVING, MV_BIT_RIGHT
6062   },
6063   {
6064     Yballoon_eB,                        FALSE,  TRUE,
6065     EL_BALLOON,                         ACTION_MOVING, MV_BIT_RIGHT
6066   },
6067   {
6068     Yballoon_s,                         FALSE,  FALSE,
6069     EL_BALLOON,                         ACTION_MOVING, MV_BIT_DOWN
6070   },
6071   {
6072     Yballoon_sB,                        FALSE,  TRUE,
6073     EL_BALLOON,                         ACTION_MOVING, MV_BIT_DOWN
6074   },
6075   {
6076     Yballoon_w,                         FALSE,  FALSE,
6077     EL_BALLOON,                         ACTION_MOVING, MV_BIT_LEFT
6078   },
6079   {
6080     Yballoon_wB,                        FALSE,  TRUE,
6081     EL_BALLOON,                         ACTION_MOVING, MV_BIT_LEFT
6082   },
6083   {
6084     Xgrass,                             TRUE,   FALSE,
6085     EL_EMC_GRASS,                       -1, -1
6086   },
6087   {
6088     Ygrass_nB,                          FALSE,  FALSE,
6089     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_UP
6090   },
6091   {
6092     Ygrass_eB,                          FALSE,  FALSE,
6093     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_RIGHT
6094   },
6095   {
6096     Ygrass_sB,                          FALSE,  FALSE,
6097     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_DOWN
6098   },
6099   {
6100     Ygrass_wB,                          FALSE,  FALSE,
6101     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_LEFT
6102   },
6103   {
6104     Xdirt,                              TRUE,   FALSE,
6105     EL_SAND,                            -1, -1
6106   },
6107   {
6108     Ydirt_nB,                           FALSE,  FALSE,
6109     EL_SAND,                            ACTION_DIGGING, MV_BIT_UP
6110   },
6111   {
6112     Ydirt_eB,                           FALSE,  FALSE,
6113     EL_SAND,                            ACTION_DIGGING, MV_BIT_RIGHT
6114   },
6115   {
6116     Ydirt_sB,                           FALSE,  FALSE,
6117     EL_SAND,                            ACTION_DIGGING, MV_BIT_DOWN
6118   },
6119   {
6120     Ydirt_wB,                           FALSE,  FALSE,
6121     EL_SAND,                            ACTION_DIGGING, MV_BIT_LEFT
6122   },
6123   {
6124     Xacid_ne,                           TRUE,   FALSE,
6125     EL_ACID_POOL_TOPRIGHT,              -1, -1
6126   },
6127   {
6128     Xacid_se,                           TRUE,   FALSE,
6129     EL_ACID_POOL_BOTTOMRIGHT,           -1, -1
6130   },
6131   {
6132     Xacid_s,                            TRUE,   FALSE,
6133     EL_ACID_POOL_BOTTOM,                -1, -1
6134   },
6135   {
6136     Xacid_sw,                           TRUE,   FALSE,
6137     EL_ACID_POOL_BOTTOMLEFT,            -1, -1
6138   },
6139   {
6140     Xacid_nw,                           TRUE,   FALSE,
6141     EL_ACID_POOL_TOPLEFT,               -1, -1
6142   },
6143   {
6144     Xacid_1,                            TRUE,   FALSE,
6145     EL_ACID,                            -1, -1
6146   },
6147   {
6148     Xacid_2,                            FALSE,  FALSE,
6149     EL_ACID,                            -1, -1
6150   },
6151   {
6152     Xacid_3,                            FALSE,  FALSE,
6153     EL_ACID,                            -1, -1
6154   },
6155   {
6156     Xacid_4,                            FALSE,  FALSE,
6157     EL_ACID,                            -1, -1
6158   },
6159   {
6160     Xacid_5,                            FALSE,  FALSE,
6161     EL_ACID,                            -1, -1
6162   },
6163   {
6164     Xacid_6,                            FALSE,  FALSE,
6165     EL_ACID,                            -1, -1
6166   },
6167   {
6168     Xacid_7,                            FALSE,  FALSE,
6169     EL_ACID,                            -1, -1
6170   },
6171   {
6172     Xacid_8,                            FALSE,  FALSE,
6173     EL_ACID,                            -1, -1
6174   },
6175   {
6176     Xball_1,                            TRUE,   FALSE,
6177     EL_EMC_MAGIC_BALL,                  -1, -1
6178   },
6179   {
6180     Xball_1B,                           FALSE,  FALSE,
6181     EL_EMC_MAGIC_BALL,                  ACTION_ACTIVE, -1
6182   },
6183   {
6184     Xball_2,                            FALSE,  FALSE,
6185     EL_EMC_MAGIC_BALL,                  ACTION_ACTIVE, -1
6186   },
6187   {
6188     Xball_2B,                           FALSE,  FALSE,
6189     EL_EMC_MAGIC_BALL,                  ACTION_ACTIVE, -1
6190   },
6191   {
6192     Yball_eat,                          FALSE,  FALSE,
6193     EL_EMC_MAGIC_BALL,                  ACTION_DROPPING, -1
6194   },
6195   {
6196     Ykey_1_eat,                         FALSE,  FALSE,
6197     EL_EM_KEY_1,                        ACTION_COLLECTING, -1
6198   },
6199   {
6200     Ykey_2_eat,                         FALSE,  FALSE,
6201     EL_EM_KEY_2,                        ACTION_COLLECTING, -1
6202   },
6203   {
6204     Ykey_3_eat,                         FALSE,  FALSE,
6205     EL_EM_KEY_3,                        ACTION_COLLECTING, -1
6206   },
6207   {
6208     Ykey_4_eat,                         FALSE,  FALSE,
6209     EL_EM_KEY_4,                        ACTION_COLLECTING, -1
6210   },
6211   {
6212     Ykey_5_eat,                         FALSE,  FALSE,
6213     EL_EMC_KEY_5,                       ACTION_COLLECTING, -1
6214   },
6215   {
6216     Ykey_6_eat,                         FALSE,  FALSE,
6217     EL_EMC_KEY_6,                       ACTION_COLLECTING, -1
6218   },
6219   {
6220     Ykey_7_eat,                         FALSE,  FALSE,
6221     EL_EMC_KEY_7,                       ACTION_COLLECTING, -1
6222   },
6223   {
6224     Ykey_8_eat,                         FALSE,  FALSE,
6225     EL_EMC_KEY_8,                       ACTION_COLLECTING, -1
6226   },
6227   {
6228     Ylenses_eat,                        FALSE,  FALSE,
6229     EL_EMC_LENSES,                      ACTION_COLLECTING, -1
6230   },
6231   {
6232     Ymagnify_eat,                       FALSE,  FALSE,
6233     EL_EMC_MAGNIFIER,                   ACTION_COLLECTING, -1
6234   },
6235   {
6236     Ygrass_eat,                         FALSE,  FALSE,
6237     EL_EMC_GRASS,                       ACTION_SNAPPING, -1
6238   },
6239   {
6240     Ydirt_eat,                          FALSE,  FALSE,
6241     EL_SAND,                            ACTION_SNAPPING, -1
6242   },
6243   {
6244     Xgrow_ns,                           TRUE,   FALSE,
6245     EL_EXPANDABLE_WALL_VERTICAL,        -1, -1
6246   },
6247   {
6248     Ygrow_ns_eat,                       FALSE,  FALSE,
6249     EL_EXPANDABLE_WALL_VERTICAL,        ACTION_GROWING, -1
6250   },
6251   {
6252     Xgrow_ew,                           TRUE,   FALSE,
6253     EL_EXPANDABLE_WALL_HORIZONTAL,      -1, -1
6254   },
6255   {
6256     Ygrow_ew_eat,                       FALSE,  FALSE,
6257     EL_EXPANDABLE_WALL_HORIZONTAL,      ACTION_GROWING, -1
6258   },
6259   {
6260     Xwonderwall,                        TRUE,   FALSE,
6261     EL_MAGIC_WALL,                      -1, -1
6262   },
6263   {
6264     XwonderwallB,                       FALSE,  FALSE,
6265     EL_MAGIC_WALL,                      ACTION_ACTIVE, -1
6266   },
6267   {
6268     Xamoeba_1,                          TRUE,   FALSE,
6269     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
6270   },
6271   {
6272     Xamoeba_2,                          FALSE,  FALSE,
6273     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
6274   },
6275   {
6276     Xamoeba_3,                          FALSE,  FALSE,
6277     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
6278   },
6279   {
6280     Xamoeba_4,                          FALSE,  FALSE,
6281     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
6282   },
6283   {
6284     Xamoeba_5,                          TRUE,   FALSE,
6285     EL_AMOEBA_WET,                      ACTION_OTHER, -1
6286   },
6287   {
6288     Xamoeba_6,                          FALSE,  FALSE,
6289     EL_AMOEBA_WET,                      ACTION_OTHER, -1
6290   },
6291   {
6292     Xamoeba_7,                          FALSE,  FALSE,
6293     EL_AMOEBA_WET,                      ACTION_OTHER, -1
6294   },
6295   {
6296     Xamoeba_8,                          FALSE,  FALSE,
6297     EL_AMOEBA_WET,                      ACTION_OTHER, -1
6298   },
6299   {
6300     Xdoor_1,                            TRUE,   FALSE,
6301     EL_EM_GATE_1,                       -1, -1
6302   },
6303   {
6304     Xdoor_2,                            TRUE,   FALSE,
6305     EL_EM_GATE_2,                       -1, -1
6306   },
6307   {
6308     Xdoor_3,                            TRUE,   FALSE,
6309     EL_EM_GATE_3,                       -1, -1
6310   },
6311   {
6312     Xdoor_4,                            TRUE,   FALSE,
6313     EL_EM_GATE_4,                       -1, -1
6314   },
6315   {
6316     Xdoor_5,                            TRUE,   FALSE,
6317     EL_EMC_GATE_5,                      -1, -1
6318   },
6319   {
6320     Xdoor_6,                            TRUE,   FALSE,
6321     EL_EMC_GATE_6,                      -1, -1
6322   },
6323   {
6324     Xdoor_7,                            TRUE,   FALSE,
6325     EL_EMC_GATE_7,                      -1, -1
6326   },
6327   {
6328     Xdoor_8,                            TRUE,   FALSE,
6329     EL_EMC_GATE_8,                      -1, -1
6330   },
6331   {
6332     Xkey_1,                             TRUE,   FALSE,
6333     EL_EM_KEY_1,                        -1, -1
6334   },
6335   {
6336     Xkey_2,                             TRUE,   FALSE,
6337     EL_EM_KEY_2,                        -1, -1
6338   },
6339   {
6340     Xkey_3,                             TRUE,   FALSE,
6341     EL_EM_KEY_3,                        -1, -1
6342   },
6343   {
6344     Xkey_4,                             TRUE,   FALSE,
6345     EL_EM_KEY_4,                        -1, -1
6346   },
6347   {
6348     Xkey_5,                             TRUE,   FALSE,
6349     EL_EMC_KEY_5,                       -1, -1
6350   },
6351   {
6352     Xkey_6,                             TRUE,   FALSE,
6353     EL_EMC_KEY_6,                       -1, -1
6354   },
6355   {
6356     Xkey_7,                             TRUE,   FALSE,
6357     EL_EMC_KEY_7,                       -1, -1
6358   },
6359   {
6360     Xkey_8,                             TRUE,   FALSE,
6361     EL_EMC_KEY_8,                       -1, -1
6362   },
6363   {
6364     Xwind_n,                            TRUE,   FALSE,
6365     EL_BALLOON_SWITCH_UP,               -1, -1
6366   },
6367   {
6368     Xwind_e,                            TRUE,   FALSE,
6369     EL_BALLOON_SWITCH_RIGHT,            -1, -1
6370   },
6371   {
6372     Xwind_s,                            TRUE,   FALSE,
6373     EL_BALLOON_SWITCH_DOWN,             -1, -1
6374   },
6375   {
6376     Xwind_w,                            TRUE,   FALSE,
6377     EL_BALLOON_SWITCH_LEFT,             -1, -1
6378   },
6379   {
6380     Xwind_nesw,                         TRUE,   FALSE,
6381     EL_BALLOON_SWITCH_ANY,              -1, -1
6382   },
6383   {
6384     Xwind_stop,                         TRUE,   FALSE,
6385     EL_BALLOON_SWITCH_NONE,             -1, -1
6386   },
6387   {
6388     Xexit,                              TRUE,   FALSE,
6389     EL_EM_EXIT_CLOSED,                  -1, -1
6390   },
6391   {
6392     Xexit_1,                            TRUE,   FALSE,
6393     EL_EM_EXIT_OPEN,                    -1, -1
6394   },
6395   {
6396     Xexit_2,                            FALSE,  FALSE,
6397     EL_EM_EXIT_OPEN,                    -1, -1
6398   },
6399   {
6400     Xexit_3,                            FALSE,  FALSE,
6401     EL_EM_EXIT_OPEN,                    -1, -1
6402   },
6403   {
6404     Xdynamite,                          TRUE,   FALSE,
6405     EL_EM_DYNAMITE,                     -1, -1
6406   },
6407   {
6408     Ydynamite_eat,                      FALSE,  FALSE,
6409     EL_EM_DYNAMITE,                     ACTION_COLLECTING, -1
6410   },
6411   {
6412     Xdynamite_1,                        TRUE,   FALSE,
6413     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6414   },
6415   {
6416     Xdynamite_2,                        FALSE,  FALSE,
6417     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6418   },
6419   {
6420     Xdynamite_3,                        FALSE,  FALSE,
6421     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6422   },
6423   {
6424     Xdynamite_4,                        FALSE,  FALSE,
6425     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6426   },
6427   {
6428     Xbumper,                            TRUE,   FALSE,
6429     EL_EMC_SPRING_BUMPER,               -1, -1
6430   },
6431   {
6432     XbumperB,                           FALSE,  FALSE,
6433     EL_EMC_SPRING_BUMPER,               ACTION_ACTIVE, -1
6434   },
6435   {
6436     Xwheel,                             TRUE,   FALSE,
6437     EL_ROBOT_WHEEL,                     -1, -1
6438   },
6439   {
6440     XwheelB,                            FALSE,  FALSE,
6441     EL_ROBOT_WHEEL,                     ACTION_ACTIVE, -1
6442   },
6443   {
6444     Xswitch,                            TRUE,   FALSE,
6445     EL_EMC_MAGIC_BALL_SWITCH,           -1, -1
6446   },
6447   {
6448     XswitchB,                           FALSE,  FALSE,
6449     EL_EMC_MAGIC_BALL_SWITCH,           ACTION_ACTIVE, -1
6450   },
6451   {
6452     Xsand,                              TRUE,   FALSE,
6453     EL_QUICKSAND_EMPTY,                 -1, -1
6454   },
6455   {
6456     Xsand_stone,                        TRUE,   FALSE,
6457     EL_QUICKSAND_FULL,                  -1, -1
6458   },
6459   {
6460     Xsand_stonein_1,                    FALSE,  TRUE,
6461     EL_ROCK,                            ACTION_FILLING, -1
6462   },
6463   {
6464     Xsand_stonein_2,                    FALSE,  TRUE,
6465     EL_ROCK,                            ACTION_FILLING, -1
6466   },
6467   {
6468     Xsand_stonein_3,                    FALSE,  TRUE,
6469     EL_ROCK,                            ACTION_FILLING, -1
6470   },
6471   {
6472     Xsand_stonein_4,                    FALSE,  TRUE,
6473     EL_ROCK,                            ACTION_FILLING, -1
6474   },
6475   {
6476     Xsand_stonesand_1,                  FALSE,  FALSE,
6477     EL_QUICKSAND_EMPTYING,              -1, -1
6478   },
6479   {
6480     Xsand_stonesand_2,                  FALSE,  FALSE,
6481     EL_QUICKSAND_EMPTYING,              -1, -1
6482   },
6483   {
6484     Xsand_stonesand_3,                  FALSE,  FALSE,
6485     EL_QUICKSAND_EMPTYING,              -1, -1
6486   },
6487   {
6488     Xsand_stonesand_4,                  FALSE,  FALSE,
6489     EL_QUICKSAND_EMPTYING,              -1, -1
6490   },
6491   {
6492     Xsand_stonesand_quickout_1,         FALSE,  FALSE,
6493     EL_QUICKSAND_EMPTYING,              -1, -1
6494   },
6495   {
6496     Xsand_stonesand_quickout_2,         FALSE,  FALSE,
6497     EL_QUICKSAND_EMPTYING,              -1, -1
6498   },
6499   {
6500     Xsand_stoneout_1,                   FALSE,  FALSE,
6501     EL_ROCK,                            ACTION_EMPTYING, -1
6502   },
6503   {
6504     Xsand_stoneout_2,                   FALSE,  FALSE,
6505     EL_ROCK,                            ACTION_EMPTYING, -1
6506   },
6507   {
6508     Xsand_sandstone_1,                  FALSE,  FALSE,
6509     EL_QUICKSAND_FILLING,               -1, -1
6510   },
6511   {
6512     Xsand_sandstone_2,                  FALSE,  FALSE,
6513     EL_QUICKSAND_FILLING,               -1, -1
6514   },
6515   {
6516     Xsand_sandstone_3,                  FALSE,  FALSE,
6517     EL_QUICKSAND_FILLING,               -1, -1
6518   },
6519   {
6520     Xsand_sandstone_4,                  FALSE,  FALSE,
6521     EL_QUICKSAND_FILLING,               -1, -1
6522   },
6523   {
6524     Xplant,                             TRUE,   FALSE,
6525     EL_EMC_PLANT,                       -1, -1
6526   },
6527   {
6528     Yplant,                             FALSE,  FALSE,
6529     EL_EMC_PLANT,                       -1, -1
6530   },
6531   {
6532     Xlenses,                            TRUE,   FALSE,
6533     EL_EMC_LENSES,                      -1, -1
6534   },
6535   {
6536     Xmagnify,                           TRUE,   FALSE,
6537     EL_EMC_MAGNIFIER,                   -1, -1
6538   },
6539   {
6540     Xdripper,                           TRUE,   FALSE,
6541     EL_EMC_DRIPPER,                     -1, -1
6542   },
6543   {
6544     XdripperB,                          FALSE,  FALSE,
6545     EL_EMC_DRIPPER,                     ACTION_ACTIVE, -1
6546   },
6547   {
6548     Xfake_blank,                        TRUE,   FALSE,
6549     EL_INVISIBLE_WALL,                  -1, -1
6550   },
6551   {
6552     Xfake_blankB,                       FALSE,  FALSE,
6553     EL_INVISIBLE_WALL,                  ACTION_ACTIVE, -1
6554   },
6555   {
6556     Xfake_grass,                        TRUE,   FALSE,
6557     EL_EMC_FAKE_GRASS,                  -1, -1
6558   },
6559   {
6560     Xfake_grassB,                       FALSE,  FALSE,
6561     EL_EMC_FAKE_GRASS,                  ACTION_ACTIVE, -1
6562   },
6563   {
6564     Xfake_door_1,                       TRUE,   FALSE,
6565     EL_EM_GATE_1_GRAY,                  -1, -1
6566   },
6567   {
6568     Xfake_door_2,                       TRUE,   FALSE,
6569     EL_EM_GATE_2_GRAY,                  -1, -1
6570   },
6571   {
6572     Xfake_door_3,                       TRUE,   FALSE,
6573     EL_EM_GATE_3_GRAY,                  -1, -1
6574   },
6575   {
6576     Xfake_door_4,                       TRUE,   FALSE,
6577     EL_EM_GATE_4_GRAY,                  -1, -1
6578   },
6579   {
6580     Xfake_door_5,                       TRUE,   FALSE,
6581     EL_EMC_GATE_5_GRAY,                 -1, -1
6582   },
6583   {
6584     Xfake_door_6,                       TRUE,   FALSE,
6585     EL_EMC_GATE_6_GRAY,                 -1, -1
6586   },
6587   {
6588     Xfake_door_7,                       TRUE,   FALSE,
6589     EL_EMC_GATE_7_GRAY,                 -1, -1
6590   },
6591   {
6592     Xfake_door_8,                       TRUE,   FALSE,
6593     EL_EMC_GATE_8_GRAY,                 -1, -1
6594   },
6595   {
6596     Xfake_acid_1,                       TRUE,   FALSE,
6597     EL_EMC_FAKE_ACID,                   -1, -1
6598   },
6599   {
6600     Xfake_acid_2,                       FALSE,  FALSE,
6601     EL_EMC_FAKE_ACID,                   -1, -1
6602   },
6603   {
6604     Xfake_acid_3,                       FALSE,  FALSE,
6605     EL_EMC_FAKE_ACID,                   -1, -1
6606   },
6607   {
6608     Xfake_acid_4,                       FALSE,  FALSE,
6609     EL_EMC_FAKE_ACID,                   -1, -1
6610   },
6611   {
6612     Xfake_acid_5,                       FALSE,  FALSE,
6613     EL_EMC_FAKE_ACID,                   -1, -1
6614   },
6615   {
6616     Xfake_acid_6,                       FALSE,  FALSE,
6617     EL_EMC_FAKE_ACID,                   -1, -1
6618   },
6619   {
6620     Xfake_acid_7,                       FALSE,  FALSE,
6621     EL_EMC_FAKE_ACID,                   -1, -1
6622   },
6623   {
6624     Xfake_acid_8,                       FALSE,  FALSE,
6625     EL_EMC_FAKE_ACID,                   -1, -1
6626   },
6627   {
6628     Xsteel_1,                           TRUE,   FALSE,
6629     EL_STEELWALL,                       -1, -1
6630   },
6631   {
6632     Xsteel_2,                           TRUE,   FALSE,
6633     EL_EMC_STEELWALL_2,                 -1, -1
6634   },
6635   {
6636     Xsteel_3,                           TRUE,   FALSE,
6637     EL_EMC_STEELWALL_3,                 -1, -1
6638   },
6639   {
6640     Xsteel_4,                           TRUE,   FALSE,
6641     EL_EMC_STEELWALL_4,                 -1, -1
6642   },
6643   {
6644     Xwall_1,                            TRUE,   FALSE,
6645     EL_WALL,                            -1, -1
6646   },
6647   {
6648     Xwall_2,                            TRUE,   FALSE,
6649     EL_EMC_WALL_14,                     -1, -1
6650   },
6651   {
6652     Xwall_3,                            TRUE,   FALSE,
6653     EL_EMC_WALL_15,                     -1, -1
6654   },
6655   {
6656     Xwall_4,                            TRUE,   FALSE,
6657     EL_EMC_WALL_16,                     -1, -1
6658   },
6659   {
6660     Xround_wall_1,                      TRUE,   FALSE,
6661     EL_WALL_SLIPPERY,                   -1, -1
6662   },
6663   {
6664     Xround_wall_2,                      TRUE,   FALSE,
6665     EL_EMC_WALL_SLIPPERY_2,             -1, -1
6666   },
6667   {
6668     Xround_wall_3,                      TRUE,   FALSE,
6669     EL_EMC_WALL_SLIPPERY_3,             -1, -1
6670   },
6671   {
6672     Xround_wall_4,                      TRUE,   FALSE,
6673     EL_EMC_WALL_SLIPPERY_4,             -1, -1
6674   },
6675   {
6676     Xdecor_1,                           TRUE,   FALSE,
6677     EL_EMC_WALL_8,                      -1, -1
6678   },
6679   {
6680     Xdecor_2,                           TRUE,   FALSE,
6681     EL_EMC_WALL_6,                      -1, -1
6682   },
6683   {
6684     Xdecor_3,                           TRUE,   FALSE,
6685     EL_EMC_WALL_4,                      -1, -1
6686   },
6687   {
6688     Xdecor_4,                           TRUE,   FALSE,
6689     EL_EMC_WALL_7,                      -1, -1
6690   },
6691   {
6692     Xdecor_5,                           TRUE,   FALSE,
6693     EL_EMC_WALL_5,                      -1, -1
6694   },
6695   {
6696     Xdecor_6,                           TRUE,   FALSE,
6697     EL_EMC_WALL_9,                      -1, -1
6698   },
6699   {
6700     Xdecor_7,                           TRUE,   FALSE,
6701     EL_EMC_WALL_10,                     -1, -1
6702   },
6703   {
6704     Xdecor_8,                           TRUE,   FALSE,
6705     EL_EMC_WALL_1,                      -1, -1
6706   },
6707   {
6708     Xdecor_9,                           TRUE,   FALSE,
6709     EL_EMC_WALL_2,                      -1, -1
6710   },
6711   {
6712     Xdecor_10,                          TRUE,   FALSE,
6713     EL_EMC_WALL_3,                      -1, -1
6714   },
6715   {
6716     Xdecor_11,                          TRUE,   FALSE,
6717     EL_EMC_WALL_11,                     -1, -1
6718   },
6719   {
6720     Xdecor_12,                          TRUE,   FALSE,
6721     EL_EMC_WALL_12,                     -1, -1
6722   },
6723   {
6724     Xalpha_0,                           TRUE,   FALSE,
6725     EL_CHAR('0'),                       -1, -1
6726   },
6727   {
6728     Xalpha_1,                           TRUE,   FALSE,
6729     EL_CHAR('1'),                       -1, -1
6730   },
6731   {
6732     Xalpha_2,                           TRUE,   FALSE,
6733     EL_CHAR('2'),                       -1, -1
6734   },
6735   {
6736     Xalpha_3,                           TRUE,   FALSE,
6737     EL_CHAR('3'),                       -1, -1
6738   },
6739   {
6740     Xalpha_4,                           TRUE,   FALSE,
6741     EL_CHAR('4'),                       -1, -1
6742   },
6743   {
6744     Xalpha_5,                           TRUE,   FALSE,
6745     EL_CHAR('5'),                       -1, -1
6746   },
6747   {
6748     Xalpha_6,                           TRUE,   FALSE,
6749     EL_CHAR('6'),                       -1, -1
6750   },
6751   {
6752     Xalpha_7,                           TRUE,   FALSE,
6753     EL_CHAR('7'),                       -1, -1
6754   },
6755   {
6756     Xalpha_8,                           TRUE,   FALSE,
6757     EL_CHAR('8'),                       -1, -1
6758   },
6759   {
6760     Xalpha_9,                           TRUE,   FALSE,
6761     EL_CHAR('9'),                       -1, -1
6762   },
6763   {
6764     Xalpha_excla,                       TRUE,   FALSE,
6765     EL_CHAR('!'),                       -1, -1
6766   },
6767   {
6768     Xalpha_quote,                       TRUE,   FALSE,
6769     EL_CHAR('"'),                       -1, -1
6770   },
6771   {
6772     Xalpha_comma,                       TRUE,   FALSE,
6773     EL_CHAR(','),                       -1, -1
6774   },
6775   {
6776     Xalpha_minus,                       TRUE,   FALSE,
6777     EL_CHAR('-'),                       -1, -1
6778   },
6779   {
6780     Xalpha_perio,                       TRUE,   FALSE,
6781     EL_CHAR('.'),                       -1, -1
6782   },
6783   {
6784     Xalpha_colon,                       TRUE,   FALSE,
6785     EL_CHAR(':'),                       -1, -1
6786   },
6787   {
6788     Xalpha_quest,                       TRUE,   FALSE,
6789     EL_CHAR('?'),                       -1, -1
6790   },
6791   {
6792     Xalpha_a,                           TRUE,   FALSE,
6793     EL_CHAR('A'),                       -1, -1
6794   },
6795   {
6796     Xalpha_b,                           TRUE,   FALSE,
6797     EL_CHAR('B'),                       -1, -1
6798   },
6799   {
6800     Xalpha_c,                           TRUE,   FALSE,
6801     EL_CHAR('C'),                       -1, -1
6802   },
6803   {
6804     Xalpha_d,                           TRUE,   FALSE,
6805     EL_CHAR('D'),                       -1, -1
6806   },
6807   {
6808     Xalpha_e,                           TRUE,   FALSE,
6809     EL_CHAR('E'),                       -1, -1
6810   },
6811   {
6812     Xalpha_f,                           TRUE,   FALSE,
6813     EL_CHAR('F'),                       -1, -1
6814   },
6815   {
6816     Xalpha_g,                           TRUE,   FALSE,
6817     EL_CHAR('G'),                       -1, -1
6818   },
6819   {
6820     Xalpha_h,                           TRUE,   FALSE,
6821     EL_CHAR('H'),                       -1, -1
6822   },
6823   {
6824     Xalpha_i,                           TRUE,   FALSE,
6825     EL_CHAR('I'),                       -1, -1
6826   },
6827   {
6828     Xalpha_j,                           TRUE,   FALSE,
6829     EL_CHAR('J'),                       -1, -1
6830   },
6831   {
6832     Xalpha_k,                           TRUE,   FALSE,
6833     EL_CHAR('K'),                       -1, -1
6834   },
6835   {
6836     Xalpha_l,                           TRUE,   FALSE,
6837     EL_CHAR('L'),                       -1, -1
6838   },
6839   {
6840     Xalpha_m,                           TRUE,   FALSE,
6841     EL_CHAR('M'),                       -1, -1
6842   },
6843   {
6844     Xalpha_n,                           TRUE,   FALSE,
6845     EL_CHAR('N'),                       -1, -1
6846   },
6847   {
6848     Xalpha_o,                           TRUE,   FALSE,
6849     EL_CHAR('O'),                       -1, -1
6850   },
6851   {
6852     Xalpha_p,                           TRUE,   FALSE,
6853     EL_CHAR('P'),                       -1, -1
6854   },
6855   {
6856     Xalpha_q,                           TRUE,   FALSE,
6857     EL_CHAR('Q'),                       -1, -1
6858   },
6859   {
6860     Xalpha_r,                           TRUE,   FALSE,
6861     EL_CHAR('R'),                       -1, -1
6862   },
6863   {
6864     Xalpha_s,                           TRUE,   FALSE,
6865     EL_CHAR('S'),                       -1, -1
6866   },
6867   {
6868     Xalpha_t,                           TRUE,   FALSE,
6869     EL_CHAR('T'),                       -1, -1
6870   },
6871   {
6872     Xalpha_u,                           TRUE,   FALSE,
6873     EL_CHAR('U'),                       -1, -1
6874   },
6875   {
6876     Xalpha_v,                           TRUE,   FALSE,
6877     EL_CHAR('V'),                       -1, -1
6878   },
6879   {
6880     Xalpha_w,                           TRUE,   FALSE,
6881     EL_CHAR('W'),                       -1, -1
6882   },
6883   {
6884     Xalpha_x,                           TRUE,   FALSE,
6885     EL_CHAR('X'),                       -1, -1
6886   },
6887   {
6888     Xalpha_y,                           TRUE,   FALSE,
6889     EL_CHAR('Y'),                       -1, -1
6890   },
6891   {
6892     Xalpha_z,                           TRUE,   FALSE,
6893     EL_CHAR('Z'),                       -1, -1
6894   },
6895   {
6896     Xalpha_arrow_e,                     TRUE,   FALSE,
6897     EL_CHAR('>'),                       -1, -1
6898   },
6899   {
6900     Xalpha_arrow_w,                     TRUE,   FALSE,
6901     EL_CHAR('<'),                       -1, -1
6902   },
6903   {
6904     Xalpha_copyr,                       TRUE,   FALSE,
6905     EL_CHAR(CHAR_BYTE_COPYRIGHT),       -1, -1
6906   },
6907
6908   {
6909     Xboom_bug,                          FALSE,  FALSE,
6910     EL_BUG,                             ACTION_EXPLODING, -1
6911   },
6912   {
6913     Xboom_bomb,                         FALSE,  FALSE,
6914     EL_BOMB,                            ACTION_EXPLODING, -1
6915   },
6916   {
6917     Xboom_android,                      FALSE,  FALSE,
6918     EL_EMC_ANDROID,                     ACTION_OTHER, -1
6919   },
6920   {
6921     Xboom_1,                            FALSE,  FALSE,
6922     EL_DEFAULT,                         ACTION_EXPLODING, -1
6923   },
6924   {
6925     Xboom_2,                            FALSE,  FALSE,
6926     EL_DEFAULT,                         ACTION_EXPLODING, -1
6927   },
6928   {
6929     Znormal,                            FALSE,  FALSE,
6930     EL_EMPTY,                           -1, -1
6931   },
6932   {
6933     Zdynamite,                          FALSE,  FALSE,
6934     EL_EMPTY,                           -1, -1
6935   },
6936   {
6937     Zplayer,                            FALSE,  FALSE,
6938     EL_EMPTY,                           -1, -1
6939   },
6940   {
6941     ZBORDER,                            FALSE,  FALSE,
6942     EL_EMPTY,                           -1, -1
6943   },
6944
6945   {
6946     -1,                                 FALSE,  FALSE,
6947     -1,                                 -1, -1
6948   }
6949 };
6950
6951 static struct Mapping_EM_to_RND_player
6952 {
6953   int action_em;
6954   int player_nr;
6955
6956   int element_rnd;
6957   int action;
6958   int direction;
6959 }
6960 em_player_mapping_list[] =
6961 {
6962   {
6963     SPR_walk + 0,                       0,
6964     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_UP,
6965   },
6966   {
6967     SPR_walk + 1,                       0,
6968     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_RIGHT,
6969   },
6970   {
6971     SPR_walk + 2,                       0,
6972     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_DOWN,
6973   },
6974   {
6975     SPR_walk + 3,                       0,
6976     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_LEFT,
6977   },
6978   {
6979     SPR_push + 0,                       0,
6980     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_UP,
6981   },
6982   {
6983     SPR_push + 1,                       0,
6984     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_RIGHT,
6985   },
6986   {
6987     SPR_push + 2,                       0,
6988     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_DOWN,
6989   },
6990   {
6991     SPR_push + 3,                       0,
6992     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_LEFT,
6993   },
6994   {
6995     SPR_spray + 0,                      0,
6996     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_UP,
6997   },
6998   {
6999     SPR_spray + 1,                      0,
7000     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7001   },
7002   {
7003     SPR_spray + 2,                      0,
7004     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_DOWN,
7005   },
7006   {
7007     SPR_spray + 3,                      0,
7008     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_LEFT,
7009   },
7010   {
7011     SPR_walk + 0,                       1,
7012     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_UP,
7013   },
7014   {
7015     SPR_walk + 1,                       1,
7016     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_RIGHT,
7017   },
7018   {
7019     SPR_walk + 2,                       1,
7020     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_DOWN,
7021   },
7022   {
7023     SPR_walk + 3,                       1,
7024     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_LEFT,
7025   },
7026   {
7027     SPR_push + 0,                       1,
7028     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_UP,
7029   },
7030   {
7031     SPR_push + 1,                       1,
7032     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_RIGHT,
7033   },
7034   {
7035     SPR_push + 2,                       1,
7036     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_DOWN,
7037   },
7038   {
7039     SPR_push + 3,                       1,
7040     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_LEFT,
7041   },
7042   {
7043     SPR_spray + 0,                      1,
7044     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_UP,
7045   },
7046   {
7047     SPR_spray + 1,                      1,
7048     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7049   },
7050   {
7051     SPR_spray + 2,                      1,
7052     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_DOWN,
7053   },
7054   {
7055     SPR_spray + 3,                      1,
7056     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_LEFT,
7057   },
7058   {
7059     SPR_still,                          0,
7060     EL_PLAYER_1,                        ACTION_DEFAULT, -1,
7061   },
7062   {
7063     SPR_still,                          1,
7064     EL_PLAYER_2,                        ACTION_DEFAULT, -1,
7065   },
7066   {
7067     SPR_walk + 0,                       2,
7068     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_UP,
7069   },
7070   {
7071     SPR_walk + 1,                       2,
7072     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_RIGHT,
7073   },
7074   {
7075     SPR_walk + 2,                       2,
7076     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_DOWN,
7077   },
7078   {
7079     SPR_walk + 3,                       2,
7080     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_LEFT,
7081   },
7082   {
7083     SPR_push + 0,                       2,
7084     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_UP,
7085   },
7086   {
7087     SPR_push + 1,                       2,
7088     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_RIGHT,
7089   },
7090   {
7091     SPR_push + 2,                       2,
7092     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_DOWN,
7093   },
7094   {
7095     SPR_push + 3,                       2,
7096     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_LEFT,
7097   },
7098   {
7099     SPR_spray + 0,                      2,
7100     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_UP,
7101   },
7102   {
7103     SPR_spray + 1,                      2,
7104     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7105   },
7106   {
7107     SPR_spray + 2,                      2,
7108     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_DOWN,
7109   },
7110   {
7111     SPR_spray + 3,                      2,
7112     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_LEFT,
7113   },
7114   {
7115     SPR_walk + 0,                       3,
7116     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_UP,
7117   },
7118   {
7119     SPR_walk + 1,                       3,
7120     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_RIGHT,
7121   },
7122   {
7123     SPR_walk + 2,                       3,
7124     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_DOWN,
7125   },
7126   {
7127     SPR_walk + 3,                       3,
7128     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_LEFT,
7129   },
7130   {
7131     SPR_push + 0,                       3,
7132     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_UP,
7133   },
7134   {
7135     SPR_push + 1,                       3,
7136     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_RIGHT,
7137   },
7138   {
7139     SPR_push + 2,                       3,
7140     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_DOWN,
7141   },
7142   {
7143     SPR_push + 3,                       3,
7144     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_LEFT,
7145   },
7146   {
7147     SPR_spray + 0,                      3,
7148     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_UP,
7149   },
7150   {
7151     SPR_spray + 1,                      3,
7152     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7153   },
7154   {
7155     SPR_spray + 2,                      3,
7156     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_DOWN,
7157   },
7158   {
7159     SPR_spray + 3,                      3,
7160     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_LEFT,
7161   },
7162   {
7163     SPR_still,                          2,
7164     EL_PLAYER_3,                        ACTION_DEFAULT, -1,
7165   },
7166   {
7167     SPR_still,                          3,
7168     EL_PLAYER_4,                        ACTION_DEFAULT, -1,
7169   },
7170
7171   {
7172     -1,                                 -1,
7173     -1,                                 -1, -1
7174   }
7175 };
7176
7177 int map_element_RND_to_EM(int element_rnd)
7178 {
7179   static unsigned short mapping_RND_to_EM[NUM_FILE_ELEMENTS];
7180   static boolean mapping_initialized = FALSE;
7181
7182   if (!mapping_initialized)
7183   {
7184     int i;
7185
7186     /* return "Xalpha_quest" for all undefined elements in mapping array */
7187     for (i = 0; i < NUM_FILE_ELEMENTS; i++)
7188       mapping_RND_to_EM[i] = Xalpha_quest;
7189
7190     for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
7191       if (em_object_mapping_list[i].is_rnd_to_em_mapping)
7192         mapping_RND_to_EM[em_object_mapping_list[i].element_rnd] =
7193           em_object_mapping_list[i].element_em;
7194
7195     mapping_initialized = TRUE;
7196   }
7197
7198   if (element_rnd >= 0 && element_rnd < NUM_FILE_ELEMENTS)
7199     return mapping_RND_to_EM[element_rnd];
7200
7201   Error(ERR_WARN, "invalid RND level element %d", element_rnd);
7202
7203   return EL_UNKNOWN;
7204 }
7205
7206 int map_element_EM_to_RND(int element_em)
7207 {
7208   static unsigned short mapping_EM_to_RND[TILE_MAX];
7209   static boolean mapping_initialized = FALSE;
7210
7211   if (!mapping_initialized)
7212   {
7213     int i;
7214
7215     /* return "EL_UNKNOWN" for all undefined elements in mapping array */
7216     for (i = 0; i < TILE_MAX; i++)
7217       mapping_EM_to_RND[i] = EL_UNKNOWN;
7218
7219     for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
7220       mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
7221         em_object_mapping_list[i].element_rnd;
7222
7223     mapping_initialized = TRUE;
7224   }
7225
7226   if (element_em >= 0 && element_em < TILE_MAX)
7227     return mapping_EM_to_RND[element_em];
7228
7229   Error(ERR_WARN, "invalid EM level element %d", element_em);
7230
7231   return EL_UNKNOWN;
7232 }
7233
7234 void map_android_clone_elements_RND_to_EM(struct LevelInfo *level)
7235 {
7236   struct LevelInfo_EM *level_em = level->native_em_level;
7237   struct LEVEL *lev = level_em->lev;
7238   int i, j;
7239
7240   for (i = 0; i < TILE_MAX; i++)
7241     lev->android_array[i] = Xblank;
7242
7243   for (i = 0; i < level->num_android_clone_elements; i++)
7244   {
7245     int element_rnd = level->android_clone_element[i];
7246     int element_em = map_element_RND_to_EM(element_rnd);
7247
7248     for (j = 0; em_object_mapping_list[j].element_em != -1; j++)
7249       if (em_object_mapping_list[j].element_rnd == element_rnd)
7250         lev->android_array[em_object_mapping_list[j].element_em] = element_em;
7251   }
7252 }
7253
7254 void map_android_clone_elements_EM_to_RND(struct LevelInfo *level)
7255 {
7256   struct LevelInfo_EM *level_em = level->native_em_level;
7257   struct LEVEL *lev = level_em->lev;
7258   int i, j;
7259
7260   level->num_android_clone_elements = 0;
7261
7262   for (i = 0; i < TILE_MAX; i++)
7263   {
7264     int element_em = lev->android_array[i];
7265     int element_rnd;
7266     boolean element_found = FALSE;
7267
7268     if (element_em == Xblank)
7269       continue;
7270
7271     element_rnd = map_element_EM_to_RND(element_em);
7272
7273     for (j = 0; j < level->num_android_clone_elements; j++)
7274       if (level->android_clone_element[j] == element_rnd)
7275         element_found = TRUE;
7276
7277     if (!element_found)
7278     {
7279       level->android_clone_element[level->num_android_clone_elements++] =
7280         element_rnd;
7281
7282       if (level->num_android_clone_elements == MAX_ANDROID_ELEMENTS)
7283         break;
7284     }
7285   }
7286
7287   if (level->num_android_clone_elements == 0)
7288   {
7289     level->num_android_clone_elements = 1;
7290     level->android_clone_element[0] = EL_EMPTY;
7291   }
7292 }
7293
7294 int map_direction_RND_to_EM(int direction)
7295 {
7296   return (direction == MV_UP    ? 0 :
7297           direction == MV_RIGHT ? 1 :
7298           direction == MV_DOWN  ? 2 :
7299           direction == MV_LEFT  ? 3 :
7300           -1);
7301 }
7302
7303 int map_direction_EM_to_RND(int direction)
7304 {
7305   return (direction == 0 ? MV_UP    :
7306           direction == 1 ? MV_RIGHT :
7307           direction == 2 ? MV_DOWN  :
7308           direction == 3 ? MV_LEFT  :
7309           MV_NONE);
7310 }
7311
7312 int map_element_RND_to_SP(int element_rnd)
7313 {
7314   int element_sp = 0x20;        /* map unknown elements to yellow "hardware" */
7315
7316   if (element_rnd >= EL_SP_START &&
7317       element_rnd <= EL_SP_END)
7318     element_sp = element_rnd - EL_SP_START;
7319   else if (element_rnd == EL_EMPTY_SPACE)
7320     element_sp = 0x00;
7321   else if (element_rnd == EL_INVISIBLE_WALL)
7322     element_sp = 0x28;
7323
7324   return element_sp;
7325 }
7326
7327 int map_element_SP_to_RND(int element_sp)
7328 {
7329   int element_rnd = EL_UNKNOWN;
7330
7331   if (element_sp >= 0x00 &&
7332       element_sp <= 0x27)
7333     element_rnd = EL_SP_START + element_sp;
7334   else if (element_sp == 0x28)
7335     element_rnd = EL_INVISIBLE_WALL;
7336
7337   return element_rnd;
7338 }
7339
7340 int map_action_SP_to_RND(int action_sp)
7341 {
7342   switch (action_sp)
7343   {
7344     case actActive:             return ACTION_ACTIVE;
7345     case actImpact:             return ACTION_IMPACT;
7346     case actExploding:          return ACTION_EXPLODING;
7347     case actDigging:            return ACTION_DIGGING;
7348     case actSnapping:           return ACTION_SNAPPING;
7349     case actCollecting:         return ACTION_COLLECTING;
7350     case actPassing:            return ACTION_PASSING;
7351     case actPushing:            return ACTION_PUSHING;
7352     case actDropping:           return ACTION_DROPPING;
7353
7354     default:                    return ACTION_DEFAULT;
7355   }
7356 }
7357
7358 int map_element_RND_to_MM(int element_rnd)
7359 {
7360   return (element_rnd >= EL_MM_START_1 &&
7361           element_rnd <= EL_MM_END_1 ?
7362           EL_MM_START_1_NATIVE + element_rnd - EL_MM_START_1 :
7363
7364           element_rnd >= EL_MM_START_2 &&
7365           element_rnd <= EL_MM_END_2 ?
7366           EL_MM_START_2_NATIVE + element_rnd - EL_MM_START_2 :
7367
7368           element_rnd >= EL_CHAR_START &&
7369           element_rnd <= EL_CHAR_END ?
7370           EL_MM_CHAR_START_NATIVE + element_rnd - EL_CHAR_START :
7371
7372           element_rnd >= EL_MM_RUNTIME_START &&
7373           element_rnd <= EL_MM_RUNTIME_END ?
7374           EL_MM_RUNTIME_START_NATIVE + element_rnd - EL_MM_RUNTIME_START :
7375
7376           element_rnd >= EL_MM_DUMMY_START &&
7377           element_rnd <= EL_MM_DUMMY_END ?
7378           EL_MM_DUMMY_START_NATIVE + element_rnd - EL_MM_DUMMY_START :
7379
7380           EL_MM_EMPTY_NATIVE);
7381 }
7382
7383 int map_element_MM_to_RND(int element_mm)
7384 {
7385   return (element_mm == EL_MM_EMPTY_NATIVE ||
7386           element_mm == EL_DF_EMPTY_NATIVE ?
7387           EL_EMPTY :
7388
7389           element_mm >= EL_MM_START_1_NATIVE &&
7390           element_mm <= EL_MM_END_1_NATIVE ?
7391           EL_MM_START_1 + element_mm - EL_MM_START_1_NATIVE :
7392
7393           element_mm >= EL_MM_START_2_NATIVE &&
7394           element_mm <= EL_MM_END_2_NATIVE ?
7395           EL_MM_START_2 + element_mm - EL_MM_START_2_NATIVE :
7396
7397           element_mm >= EL_MM_CHAR_START_NATIVE &&
7398           element_mm <= EL_MM_CHAR_END_NATIVE ?
7399           EL_CHAR_START + element_mm - EL_MM_CHAR_START_NATIVE :
7400
7401           element_mm >= EL_MM_RUNTIME_START_NATIVE &&
7402           element_mm <= EL_MM_RUNTIME_END_NATIVE ?
7403           EL_MM_RUNTIME_START + element_mm - EL_MM_RUNTIME_START_NATIVE :
7404
7405           element_mm >= EL_MM_DUMMY_START_NATIVE &&
7406           element_mm <= EL_MM_DUMMY_END_NATIVE ?
7407           EL_MM_DUMMY_START + element_mm - EL_MM_DUMMY_START_NATIVE :
7408
7409           EL_EMPTY);
7410 }
7411
7412 int map_action_MM_to_RND(int action_mm)
7413 {
7414   /* all MM actions are defined to exactly match their RND counterparts */
7415   return action_mm;
7416 }
7417
7418 int map_sound_MM_to_RND(int sound_mm)
7419 {
7420   switch (sound_mm)
7421   {
7422     case SND_MM_GAME_LEVELTIME_CHARGING:
7423       return SND_GAME_LEVELTIME_CHARGING;
7424
7425     case SND_MM_GAME_HEALTH_CHARGING:
7426       return SND_GAME_HEALTH_CHARGING;
7427
7428     default:
7429       return SND_UNDEFINED;
7430   }
7431 }
7432
7433 int map_mm_wall_element(int element)
7434 {
7435   return (element >= EL_MM_STEEL_WALL_START &&
7436           element <= EL_MM_STEEL_WALL_END ?
7437           EL_MM_STEEL_WALL :
7438
7439           element >= EL_MM_WOODEN_WALL_START &&
7440           element <= EL_MM_WOODEN_WALL_END ?
7441           EL_MM_WOODEN_WALL :
7442
7443           element >= EL_MM_ICE_WALL_START &&
7444           element <= EL_MM_ICE_WALL_END ?
7445           EL_MM_ICE_WALL :
7446
7447           element >= EL_MM_AMOEBA_WALL_START &&
7448           element <= EL_MM_AMOEBA_WALL_END ?
7449           EL_MM_AMOEBA_WALL :
7450
7451           element >= EL_DF_STEEL_WALL_START &&
7452           element <= EL_DF_STEEL_WALL_END ?
7453           EL_DF_STEEL_WALL :
7454
7455           element >= EL_DF_WOODEN_WALL_START &&
7456           element <= EL_DF_WOODEN_WALL_END ?
7457           EL_DF_WOODEN_WALL :
7458
7459           element);
7460 }
7461
7462 int map_mm_wall_element_editor(int element)
7463 {
7464   switch (element)
7465   {
7466     case EL_MM_STEEL_WALL:      return EL_MM_STEEL_WALL_START;
7467     case EL_MM_WOODEN_WALL:     return EL_MM_WOODEN_WALL_START;
7468     case EL_MM_ICE_WALL:        return EL_MM_ICE_WALL_START;
7469     case EL_MM_AMOEBA_WALL:     return EL_MM_AMOEBA_WALL_START;
7470     case EL_DF_STEEL_WALL:      return EL_DF_STEEL_WALL_START;
7471     case EL_DF_WOODEN_WALL:     return EL_DF_WOODEN_WALL_START;
7472
7473     default:                    return element;
7474   }
7475 }
7476
7477 int get_next_element(int element)
7478 {
7479   switch (element)
7480   {
7481     case EL_QUICKSAND_FILLING:          return EL_QUICKSAND_FULL;
7482     case EL_QUICKSAND_EMPTYING:         return EL_QUICKSAND_EMPTY;
7483     case EL_QUICKSAND_FAST_FILLING:     return EL_QUICKSAND_FAST_FULL;
7484     case EL_QUICKSAND_FAST_EMPTYING:    return EL_QUICKSAND_FAST_EMPTY;
7485     case EL_MAGIC_WALL_FILLING:         return EL_MAGIC_WALL_FULL;
7486     case EL_MAGIC_WALL_EMPTYING:        return EL_MAGIC_WALL_ACTIVE;
7487     case EL_BD_MAGIC_WALL_FILLING:      return EL_BD_MAGIC_WALL_FULL;
7488     case EL_BD_MAGIC_WALL_EMPTYING:     return EL_BD_MAGIC_WALL_ACTIVE;
7489     case EL_DC_MAGIC_WALL_FILLING:      return EL_DC_MAGIC_WALL_FULL;
7490     case EL_DC_MAGIC_WALL_EMPTYING:     return EL_DC_MAGIC_WALL_ACTIVE;
7491     case EL_AMOEBA_DROPPING:            return EL_AMOEBA_WET;
7492
7493     default:                            return element;
7494   }
7495 }
7496
7497 int el2img_mm(int element_mm)
7498 {
7499   return el2img(map_element_MM_to_RND(element_mm));
7500 }
7501
7502 int el_act_dir2img(int element, int action, int direction)
7503 {
7504   element = GFX_ELEMENT(element);
7505   direction = MV_DIR_TO_BIT(direction); /* default: MV_NONE => MV_DOWN */
7506
7507   /* direction_graphic[][] == graphic[] for undefined direction graphics */
7508   return element_info[element].direction_graphic[action][direction];
7509 }
7510
7511 static int el_act_dir2crm(int element, int action, int direction)
7512 {
7513   element = GFX_ELEMENT(element);
7514   direction = MV_DIR_TO_BIT(direction); /* default: MV_NONE => MV_DOWN */
7515
7516   /* direction_graphic[][] == graphic[] for undefined direction graphics */
7517   return element_info[element].direction_crumbled[action][direction];
7518 }
7519
7520 int el_act2img(int element, int action)
7521 {
7522   element = GFX_ELEMENT(element);
7523
7524   return element_info[element].graphic[action];
7525 }
7526
7527 int el_act2crm(int element, int action)
7528 {
7529   element = GFX_ELEMENT(element);
7530
7531   return element_info[element].crumbled[action];
7532 }
7533
7534 int el_dir2img(int element, int direction)
7535 {
7536   element = GFX_ELEMENT(element);
7537
7538   return el_act_dir2img(element, ACTION_DEFAULT, direction);
7539 }
7540
7541 int el2baseimg(int element)
7542 {
7543   return element_info[element].graphic[ACTION_DEFAULT];
7544 }
7545
7546 int el2img(int element)
7547 {
7548   element = GFX_ELEMENT(element);
7549
7550   return element_info[element].graphic[ACTION_DEFAULT];
7551 }
7552
7553 int el2edimg(int element)
7554 {
7555   element = GFX_ELEMENT(element);
7556
7557   return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
7558 }
7559
7560 int el2preimg(int element)
7561 {
7562   element = GFX_ELEMENT(element);
7563
7564   return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
7565 }
7566
7567 int el2panelimg(int element)
7568 {
7569   element = GFX_ELEMENT(element);
7570
7571   return element_info[element].special_graphic[GFX_SPECIAL_ARG_PANEL];
7572 }
7573
7574 int font2baseimg(int font_nr)
7575 {
7576   return font_info[font_nr].special_graphic[GFX_SPECIAL_ARG_DEFAULT];
7577 }
7578
7579 int getBeltNrFromBeltElement(int element)
7580 {
7581   return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
7582           element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
7583           element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
7584 }
7585
7586 int getBeltNrFromBeltActiveElement(int element)
7587 {
7588   return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
7589           element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
7590           element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
7591 }
7592
7593 int getBeltNrFromBeltSwitchElement(int element)
7594 {
7595   return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
7596           element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
7597           element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
7598 }
7599
7600 int getBeltDirNrFromBeltElement(int element)
7601 {
7602   static int belt_base_element[4] =
7603   {
7604     EL_CONVEYOR_BELT_1_LEFT,
7605     EL_CONVEYOR_BELT_2_LEFT,
7606     EL_CONVEYOR_BELT_3_LEFT,
7607     EL_CONVEYOR_BELT_4_LEFT
7608   };
7609
7610   int belt_nr = getBeltNrFromBeltElement(element);
7611   int belt_dir_nr = element - belt_base_element[belt_nr];
7612
7613   return (belt_dir_nr % 3);
7614 }
7615
7616 int getBeltDirNrFromBeltSwitchElement(int element)
7617 {
7618   static int belt_base_element[4] =
7619   {
7620     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
7621     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
7622     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
7623     EL_CONVEYOR_BELT_4_SWITCH_LEFT
7624   };
7625
7626   int belt_nr = getBeltNrFromBeltSwitchElement(element);
7627   int belt_dir_nr = element - belt_base_element[belt_nr];
7628
7629   return (belt_dir_nr % 3);
7630 }
7631
7632 int getBeltDirFromBeltElement(int element)
7633 {
7634   static int belt_move_dir[3] =
7635   {
7636     MV_LEFT,
7637     MV_NONE,
7638     MV_RIGHT
7639   };
7640
7641   int belt_dir_nr = getBeltDirNrFromBeltElement(element);
7642
7643   return belt_move_dir[belt_dir_nr];
7644 }
7645
7646 int getBeltDirFromBeltSwitchElement(int element)
7647 {
7648   static int belt_move_dir[3] =
7649   {
7650     MV_LEFT,
7651     MV_NONE,
7652     MV_RIGHT
7653   };
7654
7655   int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
7656
7657   return belt_move_dir[belt_dir_nr];
7658 }
7659
7660 int getBeltElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
7661 {
7662   static int belt_base_element[4] =
7663   {
7664     EL_CONVEYOR_BELT_1_LEFT,
7665     EL_CONVEYOR_BELT_2_LEFT,
7666     EL_CONVEYOR_BELT_3_LEFT,
7667     EL_CONVEYOR_BELT_4_LEFT
7668   };
7669
7670   return belt_base_element[belt_nr] + belt_dir_nr;
7671 }
7672
7673 int getBeltElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
7674 {
7675   int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
7676
7677   return getBeltElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
7678 }
7679
7680 int getBeltSwitchElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
7681 {
7682   static int belt_base_element[4] =
7683   {
7684     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
7685     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
7686     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
7687     EL_CONVEYOR_BELT_4_SWITCH_LEFT
7688   };
7689
7690   return belt_base_element[belt_nr] + belt_dir_nr;
7691 }
7692
7693 int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
7694 {
7695   int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
7696
7697   return getBeltSwitchElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
7698 }
7699
7700 boolean getTeamMode_EM()
7701 {
7702   return game.team_mode;
7703 }
7704
7705 int getGameFrameDelay_EM(int native_em_game_frame_delay)
7706 {
7707   int game_frame_delay_value;
7708
7709   game_frame_delay_value =
7710     (tape.playing && tape.fast_forward ? FfwdFrameDelay :
7711      GameFrameDelay == GAME_FRAME_DELAY ? native_em_game_frame_delay :
7712      GameFrameDelay);
7713
7714   if (tape.playing && tape.warp_forward && !tape.pausing)
7715     game_frame_delay_value = 0;
7716
7717   return game_frame_delay_value;
7718 }
7719
7720 unsigned int InitRND(int seed)
7721 {
7722   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
7723     return InitEngineRandom_EM(seed);
7724   else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
7725     return InitEngineRandom_SP(seed);
7726   else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
7727     return InitEngineRandom_MM(seed);
7728   else
7729     return InitEngineRandom_RND(seed);
7730 }
7731
7732 static struct Mapping_EM_to_RND_object object_mapping[TILE_MAX];
7733 static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][SPR_MAX];
7734
7735 inline static int get_effective_element_EM(int tile, int frame_em)
7736 {
7737   int element             = object_mapping[tile].element_rnd;
7738   int action              = object_mapping[tile].action;
7739   boolean is_backside     = object_mapping[tile].is_backside;
7740   boolean action_removing = (action == ACTION_DIGGING ||
7741                              action == ACTION_SNAPPING ||
7742                              action == ACTION_COLLECTING);
7743
7744   if (frame_em < 7)
7745   {
7746     switch (tile)
7747     {
7748       case Yacid_splash_eB:
7749       case Yacid_splash_wB:
7750         return (frame_em > 5 ? EL_EMPTY : element);
7751
7752       default:
7753         return element;
7754     }
7755   }
7756   else  /* frame_em == 7 */
7757   {
7758     switch (tile)
7759     {
7760       case Yacid_splash_eB:
7761       case Yacid_splash_wB:
7762         return EL_EMPTY;
7763
7764       case Yemerald_stone:
7765         return EL_EMERALD;
7766
7767       case Ydiamond_stone:
7768         return EL_ROCK;
7769
7770       case Xdrip_stretch:
7771       case Xdrip_stretchB:
7772       case Ydrip_s1:
7773       case Ydrip_s1B:
7774       case Xball_1B:
7775       case Xball_2:
7776       case Xball_2B:
7777       case Yball_eat:
7778       case Ykey_1_eat:
7779       case Ykey_2_eat:
7780       case Ykey_3_eat:
7781       case Ykey_4_eat:
7782       case Ykey_5_eat:
7783       case Ykey_6_eat:
7784       case Ykey_7_eat:
7785       case Ykey_8_eat:
7786       case Ylenses_eat:
7787       case Ymagnify_eat:
7788       case Ygrass_eat:
7789       case Ydirt_eat:
7790       case Xsand_stonein_1:
7791       case Xsand_stonein_2:
7792       case Xsand_stonein_3:
7793       case Xsand_stonein_4:
7794         return element;
7795
7796       default:
7797         return (is_backside || action_removing ? EL_EMPTY : element);
7798     }
7799   }
7800 }
7801
7802 inline static boolean check_linear_animation_EM(int tile)
7803 {
7804   switch (tile)
7805   {
7806     case Xsand_stonesand_1:
7807     case Xsand_stonesand_quickout_1:
7808     case Xsand_sandstone_1:
7809     case Xsand_stonein_1:
7810     case Xsand_stoneout_1:
7811     case Xboom_1:
7812     case Xdynamite_1:
7813     case Ybug_w_n:
7814     case Ybug_n_e:
7815     case Ybug_e_s:
7816     case Ybug_s_w:
7817     case Ybug_e_n:
7818     case Ybug_s_e:
7819     case Ybug_w_s:
7820     case Ybug_n_w:
7821     case Ytank_w_n:
7822     case Ytank_n_e:
7823     case Ytank_e_s:
7824     case Ytank_s_w:
7825     case Ytank_e_n:
7826     case Ytank_s_e:
7827     case Ytank_w_s:
7828     case Ytank_n_w:
7829     case Yacid_splash_eB:
7830     case Yacid_splash_wB:
7831     case Yemerald_stone:
7832       return TRUE;
7833   }
7834
7835   return FALSE;
7836 }
7837
7838 inline static void set_crumbled_graphics_EM(struct GraphicInfo_EM *g_em,
7839                                             boolean has_crumbled_graphics,
7840                                             int crumbled, int sync_frame)
7841 {
7842   /* if element can be crumbled, but certain action graphics are just empty
7843      space (like instantly snapping sand to empty space in 1 frame), do not
7844      treat these empty space graphics as crumbled graphics in EMC engine */
7845   if (crumbled == IMG_EMPTY_SPACE)
7846     has_crumbled_graphics = FALSE;
7847
7848   if (has_crumbled_graphics)
7849   {
7850     struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
7851     int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
7852                                            g_crumbled->anim_delay,
7853                                            g_crumbled->anim_mode,
7854                                            g_crumbled->anim_start_frame,
7855                                            sync_frame);
7856
7857     getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
7858                      &g_em->crumbled_src_x, &g_em->crumbled_src_y);
7859
7860     g_em->crumbled_border_size = graphic_info[crumbled].border_size;
7861     g_em->crumbled_tile_size = graphic_info[crumbled].tile_size;
7862
7863     g_em->has_crumbled_graphics = TRUE;
7864   }
7865   else
7866   {
7867     g_em->crumbled_bitmap = NULL;
7868     g_em->crumbled_src_x = 0;
7869     g_em->crumbled_src_y = 0;
7870     g_em->crumbled_border_size = 0;
7871     g_em->crumbled_tile_size = 0;
7872
7873     g_em->has_crumbled_graphics = FALSE;
7874   }
7875 }
7876
7877 void ResetGfxAnimation_EM(int x, int y, int tile)
7878 {
7879   GfxFrame[x][y] = 0;
7880 }
7881
7882 void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
7883                         int tile, int frame_em, int x, int y)
7884 {
7885   int action = object_mapping[tile].action;
7886   int direction = object_mapping[tile].direction;
7887   int effective_element = get_effective_element_EM(tile, frame_em);
7888   int graphic = (direction == MV_NONE ?
7889                  el_act2img(effective_element, action) :
7890                  el_act_dir2img(effective_element, action, direction));
7891   struct GraphicInfo *g = &graphic_info[graphic];
7892   int sync_frame;
7893   boolean action_removing = (action == ACTION_DIGGING ||
7894                              action == ACTION_SNAPPING ||
7895                              action == ACTION_COLLECTING);
7896   boolean action_moving   = (action == ACTION_FALLING ||
7897                              action == ACTION_MOVING ||
7898                              action == ACTION_PUSHING ||
7899                              action == ACTION_EATING ||
7900                              action == ACTION_FILLING ||
7901                              action == ACTION_EMPTYING);
7902   boolean action_falling  = (action == ACTION_FALLING ||
7903                              action == ACTION_FILLING ||
7904                              action == ACTION_EMPTYING);
7905
7906   /* special case: graphic uses "2nd movement tile" and has defined
7907      7 frames for movement animation (or less) => use default graphic
7908      for last (8th) frame which ends the movement animation */
7909   if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
7910   {
7911     action = ACTION_DEFAULT;    /* (keep action_* unchanged for now) */
7912     graphic = (direction == MV_NONE ?
7913                el_act2img(effective_element, action) :
7914                el_act_dir2img(effective_element, action, direction));
7915
7916     g = &graphic_info[graphic];
7917   }
7918
7919   if ((action_removing || check_linear_animation_EM(tile)) && frame_em == 0)
7920   {
7921     GfxFrame[x][y] = 0;
7922   }
7923   else if (action_moving)
7924   {
7925     boolean is_backside = object_mapping[tile].is_backside;
7926
7927     if (is_backside)
7928     {
7929       int direction = object_mapping[tile].direction;
7930       int move_dir = (action_falling ? MV_DOWN : direction);
7931
7932       GfxFrame[x][y]++;
7933
7934 #if 1
7935       /* !!! TEST !!! NEW !!! DOES NOT WORK RIGHT YET !!! */
7936       if (g->double_movement && frame_em == 0)
7937         GfxFrame[x][y] = 0;
7938 #endif
7939
7940       if (move_dir == MV_LEFT)
7941         GfxFrame[x - 1][y] = GfxFrame[x][y];
7942       else if (move_dir == MV_RIGHT)
7943         GfxFrame[x + 1][y] = GfxFrame[x][y];
7944       else if (move_dir == MV_UP)
7945         GfxFrame[x][y - 1] = GfxFrame[x][y];
7946       else if (move_dir == MV_DOWN)
7947         GfxFrame[x][y + 1] = GfxFrame[x][y];
7948     }
7949   }
7950   else
7951   {
7952     GfxFrame[x][y]++;
7953
7954     /* special case: animation for Xsand_stonesand_quickout_1/2 twice as fast */
7955     if (tile == Xsand_stonesand_quickout_1 ||
7956         tile == Xsand_stonesand_quickout_2)
7957       GfxFrame[x][y]++;
7958   }
7959
7960   if (graphic_info[graphic].anim_global_sync)
7961     sync_frame = FrameCounter;
7962   else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
7963     sync_frame = GfxFrame[x][y];
7964   else
7965     sync_frame = 0;     /* playfield border (pseudo steel) */
7966
7967   SetRandomAnimationValue(x, y);
7968
7969   int frame = getAnimationFrame(g->anim_frames,
7970                                 g->anim_delay,
7971                                 g->anim_mode,
7972                                 g->anim_start_frame,
7973                                 sync_frame);
7974
7975   g_em->unique_identifier =
7976     (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
7977 }
7978
7979 void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
7980                                   int tile, int frame_em, int x, int y)
7981 {
7982   int action = object_mapping[tile].action;
7983   int direction = object_mapping[tile].direction;
7984   boolean is_backside = object_mapping[tile].is_backside;
7985   int effective_element = get_effective_element_EM(tile, frame_em);
7986   int effective_action = action;
7987   int graphic = (direction == MV_NONE ?
7988                  el_act2img(effective_element, effective_action) :
7989                  el_act_dir2img(effective_element, effective_action,
7990                                 direction));
7991   int crumbled = (direction == MV_NONE ?
7992                   el_act2crm(effective_element, effective_action) :
7993                   el_act_dir2crm(effective_element, effective_action,
7994                                  direction));
7995   int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
7996   int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
7997   boolean has_crumbled_graphics = (base_crumbled != base_graphic);
7998   struct GraphicInfo *g = &graphic_info[graphic];
7999   int sync_frame;
8000
8001   /* special case: graphic uses "2nd movement tile" and has defined
8002      7 frames for movement animation (or less) => use default graphic
8003      for last (8th) frame which ends the movement animation */
8004   if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
8005   {
8006     effective_action = ACTION_DEFAULT;
8007     graphic = (direction == MV_NONE ?
8008                el_act2img(effective_element, effective_action) :
8009                el_act_dir2img(effective_element, effective_action,
8010                               direction));
8011     crumbled = (direction == MV_NONE ?
8012                 el_act2crm(effective_element, effective_action) :
8013                 el_act_dir2crm(effective_element, effective_action,
8014                                direction));
8015
8016     g = &graphic_info[graphic];
8017   }
8018
8019   if (graphic_info[graphic].anim_global_sync)
8020     sync_frame = FrameCounter;
8021   else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
8022     sync_frame = GfxFrame[x][y];
8023   else
8024     sync_frame = 0;     /* playfield border (pseudo steel) */
8025
8026   SetRandomAnimationValue(x, y);
8027
8028   int frame = getAnimationFrame(g->anim_frames,
8029                                 g->anim_delay,
8030                                 g->anim_mode,
8031                                 g->anim_start_frame,
8032                                 sync_frame);
8033
8034   getGraphicSourceExt(graphic, frame, &g_em->bitmap, &g_em->src_x, &g_em->src_y,
8035                       g->double_movement && is_backside);
8036
8037   /* (updating the "crumbled" graphic definitions is probably not really needed,
8038      as animations for crumbled graphics can't be longer than one EMC cycle) */
8039   set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
8040                            sync_frame);
8041 }
8042
8043 void getGraphicSourcePlayerExt_EM(struct GraphicInfo_EM *g_em,
8044                                   int player_nr, int anim, int frame_em)
8045 {
8046   int element   = player_mapping[player_nr][anim].element_rnd;
8047   int action    = player_mapping[player_nr][anim].action;
8048   int direction = player_mapping[player_nr][anim].direction;
8049   int graphic = (direction == MV_NONE ?
8050                  el_act2img(element, action) :
8051                  el_act_dir2img(element, action, direction));
8052   struct GraphicInfo *g = &graphic_info[graphic];
8053   int sync_frame;
8054
8055   InitPlayerGfxAnimation(&stored_player[player_nr], action, direction);
8056
8057   stored_player[player_nr].StepFrame = frame_em;
8058
8059   sync_frame = stored_player[player_nr].Frame;
8060
8061   int frame = getAnimationFrame(g->anim_frames,
8062                                 g->anim_delay,
8063                                 g->anim_mode,
8064                                 g->anim_start_frame,
8065                                 sync_frame);
8066
8067   getGraphicSourceExt(graphic, frame, &g_em->bitmap,
8068                       &g_em->src_x, &g_em->src_y, FALSE);
8069 }
8070
8071 void InitGraphicInfo_EM(void)
8072 {
8073   int i, j, p;
8074
8075 #if DEBUG_EM_GFX
8076   int num_em_gfx_errors = 0;
8077
8078   if (graphic_info_em_object[0][0].bitmap == NULL)
8079   {
8080     /* EM graphics not yet initialized in em_open_all() */
8081
8082     return;
8083   }
8084
8085   printf("::: [4 errors can be ignored (1 x 'bomb', 3 x 'em_dynamite']\n");
8086 #endif
8087
8088   /* always start with reliable default values */
8089   for (i = 0; i < TILE_MAX; i++)
8090   {
8091     object_mapping[i].element_rnd = EL_UNKNOWN;
8092     object_mapping[i].is_backside = FALSE;
8093     object_mapping[i].action = ACTION_DEFAULT;
8094     object_mapping[i].direction = MV_NONE;
8095   }
8096
8097   /* always start with reliable default values */
8098   for (p = 0; p < MAX_PLAYERS; p++)
8099   {
8100     for (i = 0; i < SPR_MAX; i++)
8101     {
8102       player_mapping[p][i].element_rnd = EL_UNKNOWN;
8103       player_mapping[p][i].action = ACTION_DEFAULT;
8104       player_mapping[p][i].direction = MV_NONE;
8105     }
8106   }
8107
8108   for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8109   {
8110     int e = em_object_mapping_list[i].element_em;
8111
8112     object_mapping[e].element_rnd = em_object_mapping_list[i].element_rnd;
8113     object_mapping[e].is_backside = em_object_mapping_list[i].is_backside;
8114
8115     if (em_object_mapping_list[i].action != -1)
8116       object_mapping[e].action = em_object_mapping_list[i].action;
8117
8118     if (em_object_mapping_list[i].direction != -1)
8119       object_mapping[e].direction =
8120         MV_DIR_FROM_BIT(em_object_mapping_list[i].direction);
8121   }
8122
8123   for (i = 0; em_player_mapping_list[i].action_em != -1; i++)
8124   {
8125     int a = em_player_mapping_list[i].action_em;
8126     int p = em_player_mapping_list[i].player_nr;
8127
8128     player_mapping[p][a].element_rnd = em_player_mapping_list[i].element_rnd;
8129
8130     if (em_player_mapping_list[i].action != -1)
8131       player_mapping[p][a].action = em_player_mapping_list[i].action;
8132
8133     if (em_player_mapping_list[i].direction != -1)
8134       player_mapping[p][a].direction =
8135         MV_DIR_FROM_BIT(em_player_mapping_list[i].direction);
8136   }
8137
8138   for (i = 0; i < TILE_MAX; i++)
8139   {
8140     int element = object_mapping[i].element_rnd;
8141     int action = object_mapping[i].action;
8142     int direction = object_mapping[i].direction;
8143     boolean is_backside = object_mapping[i].is_backside;
8144     boolean action_exploding = ((action == ACTION_EXPLODING ||
8145                                  action == ACTION_SMASHED_BY_ROCK ||
8146                                  action == ACTION_SMASHED_BY_SPRING) &&
8147                                 element != EL_DIAMOND);
8148     boolean action_active = (action == ACTION_ACTIVE);
8149     boolean action_other = (action == ACTION_OTHER);
8150
8151     for (j = 0; j < 8; j++)
8152     {
8153       int effective_element = get_effective_element_EM(i, j);
8154       int effective_action = (j < 7 ? action :
8155                               i == Xdrip_stretch ? action :
8156                               i == Xdrip_stretchB ? action :
8157                               i == Ydrip_s1 ? action :
8158                               i == Ydrip_s1B ? action :
8159                               i == Xball_1B ? action :
8160                               i == Xball_2 ? action :
8161                               i == Xball_2B ? action :
8162                               i == Yball_eat ? action :
8163                               i == Ykey_1_eat ? action :
8164                               i == Ykey_2_eat ? action :
8165                               i == Ykey_3_eat ? action :
8166                               i == Ykey_4_eat ? action :
8167                               i == Ykey_5_eat ? action :
8168                               i == Ykey_6_eat ? action :
8169                               i == Ykey_7_eat ? action :
8170                               i == Ykey_8_eat ? action :
8171                               i == Ylenses_eat ? action :
8172                               i == Ymagnify_eat ? action :
8173                               i == Ygrass_eat ? action :
8174                               i == Ydirt_eat ? action :
8175                               i == Xsand_stonein_1 ? action :
8176                               i == Xsand_stonein_2 ? action :
8177                               i == Xsand_stonein_3 ? action :
8178                               i == Xsand_stonein_4 ? action :
8179                               i == Xsand_stoneout_1 ? action :
8180                               i == Xsand_stoneout_2 ? action :
8181                               i == Xboom_android ? ACTION_EXPLODING :
8182                               action_exploding ? ACTION_EXPLODING :
8183                               action_active ? action :
8184                               action_other ? action :
8185                               ACTION_DEFAULT);
8186       int graphic = (el_act_dir2img(effective_element, effective_action,
8187                                     direction));
8188       int crumbled = (el_act_dir2crm(effective_element, effective_action,
8189                                      direction));
8190       int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
8191       int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
8192       boolean has_action_graphics = (graphic != base_graphic);
8193       boolean has_crumbled_graphics = (base_crumbled != base_graphic);
8194       struct GraphicInfo *g = &graphic_info[graphic];
8195       struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][7 - j];
8196       Bitmap *src_bitmap;
8197       int src_x, src_y;
8198       /* ensure to get symmetric 3-frame, 2-delay animations as used in EM */
8199       boolean special_animation = (action != ACTION_DEFAULT &&
8200                                    g->anim_frames == 3 &&
8201                                    g->anim_delay == 2 &&
8202                                    g->anim_mode & ANIM_LINEAR);
8203       int sync_frame = (i == Xdrip_stretch ? 7 :
8204                         i == Xdrip_stretchB ? 7 :
8205                         i == Ydrip_s2 ? j + 8 :
8206                         i == Ydrip_s2B ? j + 8 :
8207                         i == Xacid_1 ? 0 :
8208                         i == Xacid_2 ? 10 :
8209                         i == Xacid_3 ? 20 :
8210                         i == Xacid_4 ? 30 :
8211                         i == Xacid_5 ? 40 :
8212                         i == Xacid_6 ? 50 :
8213                         i == Xacid_7 ? 60 :
8214                         i == Xacid_8 ? 70 :
8215                         i == Xfake_acid_1 ? 0 :
8216                         i == Xfake_acid_2 ? 10 :
8217                         i == Xfake_acid_3 ? 20 :
8218                         i == Xfake_acid_4 ? 30 :
8219                         i == Xfake_acid_5 ? 40 :
8220                         i == Xfake_acid_6 ? 50 :
8221                         i == Xfake_acid_7 ? 60 :
8222                         i == Xfake_acid_8 ? 70 :
8223                         i == Xball_2 ? 7 :
8224                         i == Xball_2B ? j + 8 :
8225                         i == Yball_eat ? j + 1 :
8226                         i == Ykey_1_eat ? j + 1 :
8227                         i == Ykey_2_eat ? j + 1 :
8228                         i == Ykey_3_eat ? j + 1 :
8229                         i == Ykey_4_eat ? j + 1 :
8230                         i == Ykey_5_eat ? j + 1 :
8231                         i == Ykey_6_eat ? j + 1 :
8232                         i == Ykey_7_eat ? j + 1 :
8233                         i == Ykey_8_eat ? j + 1 :
8234                         i == Ylenses_eat ? j + 1 :
8235                         i == Ymagnify_eat ? j + 1 :
8236                         i == Ygrass_eat ? j + 1 :
8237                         i == Ydirt_eat ? j + 1 :
8238                         i == Xamoeba_1 ? 0 :
8239                         i == Xamoeba_2 ? 1 :
8240                         i == Xamoeba_3 ? 2 :
8241                         i == Xamoeba_4 ? 3 :
8242                         i == Xamoeba_5 ? 0 :
8243                         i == Xamoeba_6 ? 1 :
8244                         i == Xamoeba_7 ? 2 :
8245                         i == Xamoeba_8 ? 3 :
8246                         i == Xexit_2 ? j + 8 :
8247                         i == Xexit_3 ? j + 16 :
8248                         i == Xdynamite_1 ? 0 :
8249                         i == Xdynamite_2 ? 8 :
8250                         i == Xdynamite_3 ? 16 :
8251                         i == Xdynamite_4 ? 24 :
8252                         i == Xsand_stonein_1 ? j + 1 :
8253                         i == Xsand_stonein_2 ? j + 9 :
8254                         i == Xsand_stonein_3 ? j + 17 :
8255                         i == Xsand_stonein_4 ? j + 25 :
8256                         i == Xsand_stoneout_1 && j == 0 ? 0 :
8257                         i == Xsand_stoneout_1 && j == 1 ? 0 :
8258                         i == Xsand_stoneout_1 && j == 2 ? 1 :
8259                         i == Xsand_stoneout_1 && j == 3 ? 2 :
8260                         i == Xsand_stoneout_1 && j == 4 ? 2 :
8261                         i == Xsand_stoneout_1 && j == 5 ? 3 :
8262                         i == Xsand_stoneout_1 && j == 6 ? 4 :
8263                         i == Xsand_stoneout_1 && j == 7 ? 4 :
8264                         i == Xsand_stoneout_2 && j == 0 ? 5 :
8265                         i == Xsand_stoneout_2 && j == 1 ? 6 :
8266                         i == Xsand_stoneout_2 && j == 2 ? 7 :
8267                         i == Xsand_stoneout_2 && j == 3 ? 8 :
8268                         i == Xsand_stoneout_2 && j == 4 ? 9 :
8269                         i == Xsand_stoneout_2 && j == 5 ? 11 :
8270                         i == Xsand_stoneout_2 && j == 6 ? 13 :
8271                         i == Xsand_stoneout_2 && j == 7 ? 15 :
8272                         i == Xboom_bug && j == 1 ? 2 :
8273                         i == Xboom_bug && j == 2 ? 2 :
8274                         i == Xboom_bug && j == 3 ? 4 :
8275                         i == Xboom_bug && j == 4 ? 4 :
8276                         i == Xboom_bug && j == 5 ? 2 :
8277                         i == Xboom_bug && j == 6 ? 2 :
8278                         i == Xboom_bug && j == 7 ? 0 :
8279                         i == Xboom_bomb && j == 1 ? 2 :
8280                         i == Xboom_bomb && j == 2 ? 2 :
8281                         i == Xboom_bomb && j == 3 ? 4 :
8282                         i == Xboom_bomb && j == 4 ? 4 :
8283                         i == Xboom_bomb && j == 5 ? 2 :
8284                         i == Xboom_bomb && j == 6 ? 2 :
8285                         i == Xboom_bomb && j == 7 ? 0 :
8286                         i == Xboom_android && j == 7 ? 6 :
8287                         i == Xboom_1 && j == 1 ? 2 :
8288                         i == Xboom_1 && j == 2 ? 2 :
8289                         i == Xboom_1 && j == 3 ? 4 :
8290                         i == Xboom_1 && j == 4 ? 4 :
8291                         i == Xboom_1 && j == 5 ? 6 :
8292                         i == Xboom_1 && j == 6 ? 6 :
8293                         i == Xboom_1 && j == 7 ? 8 :
8294                         i == Xboom_2 && j == 0 ? 8 :
8295                         i == Xboom_2 && j == 1 ? 8 :
8296                         i == Xboom_2 && j == 2 ? 10 :
8297                         i == Xboom_2 && j == 3 ? 10 :
8298                         i == Xboom_2 && j == 4 ? 10 :
8299                         i == Xboom_2 && j == 5 ? 12 :
8300                         i == Xboom_2 && j == 6 ? 12 :
8301                         i == Xboom_2 && j == 7 ? 12 :
8302                         special_animation && j == 4 ? 3 :
8303                         effective_action != action ? 0 :
8304                         j);
8305
8306 #if DEBUG_EM_GFX
8307       Bitmap *debug_bitmap = g_em->bitmap;
8308       int debug_src_x = g_em->src_x;
8309       int debug_src_y = g_em->src_y;
8310 #endif
8311
8312       int frame = getAnimationFrame(g->anim_frames,
8313                                     g->anim_delay,
8314                                     g->anim_mode,
8315                                     g->anim_start_frame,
8316                                     sync_frame);
8317
8318       getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y,
8319                           g->double_movement && is_backside);
8320
8321       g_em->bitmap = src_bitmap;
8322       g_em->src_x = src_x;
8323       g_em->src_y = src_y;
8324       g_em->src_offset_x = 0;
8325       g_em->src_offset_y = 0;
8326       g_em->dst_offset_x = 0;
8327       g_em->dst_offset_y = 0;
8328       g_em->width  = TILEX;
8329       g_em->height = TILEY;
8330
8331       g_em->preserve_background = FALSE;
8332
8333       set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
8334                                sync_frame);
8335
8336       if ((!g->double_movement && (effective_action == ACTION_FALLING ||
8337                                    effective_action == ACTION_MOVING  ||
8338                                    effective_action == ACTION_PUSHING ||
8339                                    effective_action == ACTION_EATING)) ||
8340           (!has_action_graphics && (effective_action == ACTION_FILLING ||
8341                                     effective_action == ACTION_EMPTYING)))
8342       {
8343         int move_dir =
8344           (effective_action == ACTION_FALLING ||
8345            effective_action == ACTION_FILLING ||
8346            effective_action == ACTION_EMPTYING ? MV_DOWN : direction);
8347         int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? 1 : 0);
8348         int dy = (move_dir == MV_UP   ? -1 : move_dir == MV_DOWN  ? 1 : 0);
8349         int num_steps = (i == Ydrip_s1  ? 16 :
8350                          i == Ydrip_s1B ? 16 :
8351                          i == Ydrip_s2  ? 16 :
8352                          i == Ydrip_s2B ? 16 :
8353                          i == Xsand_stonein_1 ? 32 :
8354                          i == Xsand_stonein_2 ? 32 :
8355                          i == Xsand_stonein_3 ? 32 :
8356                          i == Xsand_stonein_4 ? 32 :
8357                          i == Xsand_stoneout_1 ? 16 :
8358                          i == Xsand_stoneout_2 ? 16 : 8);
8359         int cx = ABS(dx) * (TILEX / num_steps);
8360         int cy = ABS(dy) * (TILEY / num_steps);
8361         int step_frame = (i == Ydrip_s2         ? j + 8 :
8362                           i == Ydrip_s2B        ? j + 8 :
8363                           i == Xsand_stonein_2  ? j + 8 :
8364                           i == Xsand_stonein_3  ? j + 16 :
8365                           i == Xsand_stonein_4  ? j + 24 :
8366                           i == Xsand_stoneout_2 ? j + 8 : j) + 1;
8367         int step = (is_backside ? step_frame : num_steps - step_frame);
8368
8369         if (is_backside)        /* tile where movement starts */
8370         {
8371           if (dx < 0 || dy < 0)
8372           {
8373             g_em->src_offset_x = cx * step;
8374             g_em->src_offset_y = cy * step;
8375           }
8376           else
8377           {
8378             g_em->dst_offset_x = cx * step;
8379             g_em->dst_offset_y = cy * step;
8380           }
8381         }
8382         else                    /* tile where movement ends */
8383         {
8384           if (dx < 0 || dy < 0)
8385           {
8386             g_em->dst_offset_x = cx * step;
8387             g_em->dst_offset_y = cy * step;
8388           }
8389           else
8390           {
8391             g_em->src_offset_x = cx * step;
8392             g_em->src_offset_y = cy * step;
8393           }
8394         }
8395
8396         g_em->width  = TILEX - cx * step;
8397         g_em->height = TILEY - cy * step;
8398       }
8399
8400       /* create unique graphic identifier to decide if tile must be redrawn */
8401       /* bit 31 - 16 (16 bit): EM style graphic
8402          bit 15 - 12 ( 4 bit): EM style frame
8403          bit 11 -  6 ( 6 bit): graphic width
8404          bit  5 -  0 ( 6 bit): graphic height */
8405       g_em->unique_identifier =
8406         (graphic << 16) | (frame << 12) | (g_em->width << 6) | g_em->height;
8407
8408 #if DEBUG_EM_GFX
8409
8410       /* skip check for EMC elements not contained in original EMC artwork */
8411       if (element == EL_EMC_FAKE_ACID)
8412         continue;
8413
8414       if (g_em->bitmap != debug_bitmap ||
8415           g_em->src_x != debug_src_x ||
8416           g_em->src_y != debug_src_y ||
8417           g_em->src_offset_x != 0 ||
8418           g_em->src_offset_y != 0 ||
8419           g_em->dst_offset_x != 0 ||
8420           g_em->dst_offset_y != 0 ||
8421           g_em->width != TILEX ||
8422           g_em->height != TILEY)
8423       {
8424         static int last_i = -1;
8425
8426         if (i != last_i)
8427         {
8428           printf("\n");
8429           last_i = i;
8430         }
8431
8432         printf("::: EMC GFX ERROR for element %d -> %d ('%s', '%s', %d)",
8433                i, element, element_info[element].token_name,
8434                element_action_info[effective_action].suffix, direction);
8435
8436         if (element != effective_element)
8437           printf(" [%d ('%s')]",
8438                  effective_element,
8439                  element_info[effective_element].token_name);
8440
8441         printf("\n");
8442
8443         if (g_em->bitmap != debug_bitmap)
8444           printf("    %d (%d): different bitmap! (0x%08x != 0x%08x)\n",
8445                  j, is_backside, (int)(g_em->bitmap), (int)(debug_bitmap));
8446
8447         if (g_em->src_x != debug_src_x ||
8448             g_em->src_y != debug_src_y)
8449           printf("    frame %d (%c): %d,%d (%d,%d) should be %d,%d (%d,%d)\n",
8450                  j, (is_backside ? 'B' : 'F'),
8451                  g_em->src_x, g_em->src_y,
8452                  g_em->src_x / 32, g_em->src_y / 32,
8453                  debug_src_x, debug_src_y,
8454                  debug_src_x / 32, debug_src_y / 32);
8455
8456         if (g_em->src_offset_x != 0 ||
8457             g_em->src_offset_y != 0 ||
8458             g_em->dst_offset_x != 0 ||
8459             g_em->dst_offset_y != 0)
8460           printf("    %d (%d): offsets %d,%d and %d,%d should be all 0\n",
8461                  j, is_backside,
8462                  g_em->src_offset_x, g_em->src_offset_y,
8463                  g_em->dst_offset_x, g_em->dst_offset_y);
8464
8465         if (g_em->width != TILEX ||
8466             g_em->height != TILEY)
8467           printf("    %d (%d): size %d,%d should be %d,%d\n",
8468                  j, is_backside,
8469                  g_em->width, g_em->height, TILEX, TILEY);
8470
8471         num_em_gfx_errors++;
8472       }
8473 #endif
8474
8475     }
8476   }
8477
8478   for (i = 0; i < TILE_MAX; i++)
8479   {
8480     for (j = 0; j < 8; j++)
8481     {
8482       int element = object_mapping[i].element_rnd;
8483       int action = object_mapping[i].action;
8484       int direction = object_mapping[i].direction;
8485       boolean is_backside = object_mapping[i].is_backside;
8486       int graphic_action  = el_act_dir2img(element, action, direction);
8487       int graphic_default = el_act_dir2img(element, ACTION_DEFAULT, direction);
8488
8489       if ((action == ACTION_SMASHED_BY_ROCK ||
8490            action == ACTION_SMASHED_BY_SPRING ||
8491            action == ACTION_EATING) &&
8492           graphic_action == graphic_default)
8493       {
8494         int e = (action == ACTION_SMASHED_BY_ROCK   ? Ystone_s  :
8495                  action == ACTION_SMASHED_BY_SPRING ? Yspring_s :
8496                  direction == MV_LEFT  ? (is_backside? Yspring_wB: Yspring_w) :
8497                  direction == MV_RIGHT ? (is_backside? Yspring_eB: Yspring_e) :
8498                  Xspring);
8499
8500         /* no separate animation for "smashed by rock" -- use rock instead */
8501         struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][7 - j];
8502         struct GraphicInfo_EM *g_xx = &graphic_info_em_object[e][7 - j];
8503
8504         g_em->bitmap            = g_xx->bitmap;
8505         g_em->src_x             = g_xx->src_x;
8506         g_em->src_y             = g_xx->src_y;
8507         g_em->src_offset_x      = g_xx->src_offset_x;
8508         g_em->src_offset_y      = g_xx->src_offset_y;
8509         g_em->dst_offset_x      = g_xx->dst_offset_x;
8510         g_em->dst_offset_y      = g_xx->dst_offset_y;
8511         g_em->width             = g_xx->width;
8512         g_em->height            = g_xx->height;
8513         g_em->unique_identifier = g_xx->unique_identifier;
8514
8515         if (!is_backside)
8516           g_em->preserve_background = TRUE;
8517       }
8518     }
8519   }
8520
8521   for (p = 0; p < MAX_PLAYERS; p++)
8522   {
8523     for (i = 0; i < SPR_MAX; i++)
8524     {
8525       int element = player_mapping[p][i].element_rnd;
8526       int action = player_mapping[p][i].action;
8527       int direction = player_mapping[p][i].direction;
8528
8529       for (j = 0; j < 8; j++)
8530       {
8531         int effective_element = element;
8532         int effective_action = action;
8533         int graphic = (direction == MV_NONE ?
8534                        el_act2img(effective_element, effective_action) :
8535                        el_act_dir2img(effective_element, effective_action,
8536                                       direction));
8537         struct GraphicInfo *g = &graphic_info[graphic];
8538         struct GraphicInfo_EM *g_em = &graphic_info_em_player[p][i][7 - j];
8539         Bitmap *src_bitmap;
8540         int src_x, src_y;
8541         int sync_frame = j;
8542
8543 #if DEBUG_EM_GFX
8544         Bitmap *debug_bitmap = g_em->bitmap;
8545         int debug_src_x = g_em->src_x;
8546         int debug_src_y = g_em->src_y;
8547 #endif
8548
8549         int frame = getAnimationFrame(g->anim_frames,
8550                                       g->anim_delay,
8551                                       g->anim_mode,
8552                                       g->anim_start_frame,
8553                                       sync_frame);
8554
8555         getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
8556
8557         g_em->bitmap = src_bitmap;
8558         g_em->src_x = src_x;
8559         g_em->src_y = src_y;
8560         g_em->src_offset_x = 0;
8561         g_em->src_offset_y = 0;
8562         g_em->dst_offset_x = 0;
8563         g_em->dst_offset_y = 0;
8564         g_em->width  = TILEX;
8565         g_em->height = TILEY;
8566
8567 #if DEBUG_EM_GFX
8568
8569         /* skip check for EMC elements not contained in original EMC artwork */
8570         if (element == EL_PLAYER_3 ||
8571             element == EL_PLAYER_4)
8572           continue;
8573
8574         if (g_em->bitmap != debug_bitmap ||
8575             g_em->src_x != debug_src_x ||
8576             g_em->src_y != debug_src_y)
8577         {
8578           static int last_i = -1;
8579
8580           if (i != last_i)
8581           {
8582             printf("\n");
8583             last_i = i;
8584           }
8585
8586           printf("::: EMC GFX ERROR for p/a %d/%d -> %d ('%s', '%s', %d)",
8587                  p, i, element, element_info[element].token_name,
8588                  element_action_info[effective_action].suffix, direction);
8589
8590           if (element != effective_element)
8591             printf(" [%d ('%s')]",
8592                    effective_element,
8593                    element_info[effective_element].token_name);
8594
8595           printf("\n");
8596
8597           if (g_em->bitmap != debug_bitmap)
8598             printf("    %d: different bitmap! (0x%08x != 0x%08x)\n",
8599                    j, (int)(g_em->bitmap), (int)(debug_bitmap));
8600
8601           if (g_em->src_x != debug_src_x ||
8602               g_em->src_y != debug_src_y)
8603             printf("    frame %d: %d,%d (%d,%d) should be %d,%d (%d,%d)\n",
8604                    j,
8605                    g_em->src_x, g_em->src_y,
8606                    g_em->src_x / 32, g_em->src_y / 32,
8607                    debug_src_x, debug_src_y,
8608                    debug_src_x / 32, debug_src_y / 32);
8609
8610           num_em_gfx_errors++;
8611         }
8612 #endif
8613
8614       }
8615     }
8616   }
8617
8618 #if DEBUG_EM_GFX
8619   printf("\n");
8620   printf("::: [%d errors found]\n", num_em_gfx_errors);
8621
8622   exit(0);
8623 #endif
8624 }
8625
8626 void CheckSaveEngineSnapshot_EM(byte action[MAX_PLAYERS], int frame,
8627                                 boolean any_player_moving,
8628                                 boolean any_player_snapping,
8629                                 boolean any_player_dropping)
8630 {
8631   if (frame == 0 && !any_player_dropping)
8632   {
8633     if (!local_player->was_waiting)
8634     {
8635       if (!CheckSaveEngineSnapshotToList())
8636         return;
8637
8638       local_player->was_waiting = TRUE;
8639     }
8640   }
8641   else if (any_player_moving || any_player_snapping || any_player_dropping)
8642   {
8643     local_player->was_waiting = FALSE;
8644   }
8645 }
8646
8647 void CheckSaveEngineSnapshot_SP(boolean murphy_is_waiting,
8648                                 boolean murphy_is_dropping)
8649 {
8650   if (murphy_is_waiting)
8651   {
8652     if (!local_player->was_waiting)
8653     {
8654       if (!CheckSaveEngineSnapshotToList())
8655         return;
8656
8657       local_player->was_waiting = TRUE;
8658     }
8659   }
8660   else
8661   {
8662     local_player->was_waiting = FALSE;
8663   }
8664 }
8665
8666 void CheckSingleStepMode_EM(byte action[MAX_PLAYERS], int frame,
8667                             boolean any_player_moving,
8668                             boolean any_player_snapping,
8669                             boolean any_player_dropping)
8670 {
8671   if (tape.single_step && tape.recording && !tape.pausing)
8672     if (frame == 0 && !any_player_dropping)
8673       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
8674
8675   CheckSaveEngineSnapshot_EM(action, frame, any_player_moving,
8676                              any_player_snapping, any_player_dropping);
8677 }
8678
8679 void CheckSingleStepMode_SP(boolean murphy_is_waiting,
8680                             boolean murphy_is_dropping)
8681 {
8682   boolean murphy_starts_dropping = FALSE;
8683   int i;
8684
8685   for (i = 0; i < MAX_PLAYERS; i++)
8686     if (stored_player[i].force_dropping)
8687       murphy_starts_dropping = TRUE;
8688
8689   if (tape.single_step && tape.recording && !tape.pausing)
8690     if (murphy_is_waiting && !murphy_starts_dropping)
8691       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
8692
8693   CheckSaveEngineSnapshot_SP(murphy_is_waiting, murphy_is_dropping);
8694 }
8695
8696 void getGraphicSource_SP(struct GraphicInfo_SP *g_sp,
8697                          int graphic, int sync_frame, int x, int y)
8698 {
8699   int frame = getGraphicAnimationFrame(graphic, sync_frame);
8700
8701   getGraphicSource(graphic, frame, &g_sp->bitmap, &g_sp->src_x, &g_sp->src_y);
8702 }
8703
8704 boolean isNextAnimationFrame_SP(int graphic, int sync_frame)
8705 {
8706   return (IS_NEXT_FRAME(sync_frame, graphic));
8707 }
8708
8709 int getGraphicInfo_Delay(int graphic)
8710 {
8711   return graphic_info[graphic].anim_delay;
8712 }
8713
8714 void PlayMenuSoundExt(int sound)
8715 {
8716   if (sound == SND_UNDEFINED)
8717     return;
8718
8719   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
8720       (!setup.sound_loops && IS_LOOP_SOUND(sound)))
8721     return;
8722
8723   if (IS_LOOP_SOUND(sound))
8724     PlaySoundLoop(sound);
8725   else
8726     PlaySound(sound);
8727 }
8728
8729 void PlayMenuSound()
8730 {
8731   PlayMenuSoundExt(menu.sound[game_status]);
8732 }
8733
8734 void PlayMenuSoundStereo(int sound, int stereo_position)
8735 {
8736   if (sound == SND_UNDEFINED)
8737     return;
8738
8739   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
8740       (!setup.sound_loops && IS_LOOP_SOUND(sound)))
8741     return;
8742
8743   if (IS_LOOP_SOUND(sound))
8744     PlaySoundExt(sound, SOUND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_LOOP);
8745   else
8746     PlaySoundStereo(sound, stereo_position);
8747 }
8748
8749 void PlayMenuSoundIfLoopExt(int sound)
8750 {
8751   if (sound == SND_UNDEFINED)
8752     return;
8753
8754   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
8755       (!setup.sound_loops && IS_LOOP_SOUND(sound)))
8756     return;
8757
8758   if (IS_LOOP_SOUND(sound))
8759     PlaySoundLoop(sound);
8760 }
8761
8762 void PlayMenuSoundIfLoop()
8763 {
8764   PlayMenuSoundIfLoopExt(menu.sound[game_status]);
8765 }
8766
8767 void PlayMenuMusicExt(int music)
8768 {
8769   if (music == MUS_UNDEFINED)
8770     return;
8771
8772   if (!setup.sound_music)
8773     return;
8774
8775   PlayMusic(music);
8776 }
8777
8778 void PlayMenuMusic()
8779 {
8780   char *curr_music = getCurrentlyPlayingMusicFilename();
8781   char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
8782
8783   if (!strEqual(curr_music, next_music))
8784     PlayMenuMusicExt(menu.music[game_status]);
8785 }
8786
8787 void PlayMenuSoundsAndMusic()
8788 {
8789   PlayMenuSound();
8790   PlayMenuMusic();
8791 }
8792
8793 static void FadeMenuSounds()
8794 {
8795   FadeSounds();
8796 }
8797
8798 static void FadeMenuMusic()
8799 {
8800   char *curr_music = getCurrentlyPlayingMusicFilename();
8801   char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
8802
8803   if (!strEqual(curr_music, next_music))
8804     FadeMusic();
8805 }
8806
8807 void FadeMenuSoundsAndMusic()
8808 {
8809   FadeMenuSounds();
8810   FadeMenuMusic();
8811 }
8812
8813 void PlaySoundActivating()
8814 {
8815 #if 0
8816   PlaySound(SND_MENU_ITEM_ACTIVATING);
8817 #endif
8818 }
8819
8820 void PlaySoundSelecting()
8821 {
8822 #if 0
8823   PlaySound(SND_MENU_ITEM_SELECTING);
8824 #endif
8825 }
8826
8827 void ToggleFullscreenOrChangeWindowScalingIfNeeded()
8828 {
8829   boolean change_fullscreen = (setup.fullscreen !=
8830                                video.fullscreen_enabled);
8831   boolean change_window_scaling_percent = (!video.fullscreen_enabled &&
8832                                            setup.window_scaling_percent !=
8833                                            video.window_scaling_percent);
8834
8835   if (change_window_scaling_percent && video.fullscreen_enabled)
8836     return;
8837
8838   if (!change_window_scaling_percent && !video.fullscreen_available)
8839     return;
8840
8841 #if defined(TARGET_SDL2)
8842   if (change_window_scaling_percent)
8843   {
8844     SDLSetWindowScaling(setup.window_scaling_percent);
8845
8846     return;
8847   }
8848   else if (change_fullscreen)
8849   {
8850     SDLSetWindowFullscreen(setup.fullscreen);
8851
8852     /* set setup value according to successfully changed fullscreen mode */
8853     setup.fullscreen = video.fullscreen_enabled;
8854
8855     return;
8856   }
8857 #endif
8858
8859   if (change_fullscreen ||
8860       change_window_scaling_percent)
8861   {
8862     Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
8863
8864     /* save backbuffer content which gets lost when toggling fullscreen mode */
8865     BlitBitmap(backbuffer, tmp_backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
8866
8867     if (change_window_scaling_percent)
8868     {
8869       /* keep window mode, but change window scaling */
8870       video.fullscreen_enabled = TRUE;          /* force new window scaling */
8871     }
8872
8873     /* toggle fullscreen */
8874     ChangeVideoModeIfNeeded(setup.fullscreen);
8875
8876     /* set setup value according to successfully changed fullscreen mode */
8877     setup.fullscreen = video.fullscreen_enabled;
8878
8879     /* restore backbuffer content from temporary backbuffer backup bitmap */
8880     BlitBitmap(tmp_backbuffer, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
8881
8882     FreeBitmap(tmp_backbuffer);
8883
8884     /* update visible window/screen */
8885     BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
8886   }
8887 }
8888
8889 void JoinRectangles(int *x, int *y, int *width, int *height,
8890                     int x2, int y2, int width2, int height2)
8891 {
8892   // do not join with "off-screen" rectangle
8893   if (x2 == -1 || y2 == -1)
8894     return;
8895
8896   *x = MIN(*x, x2);
8897   *y = MIN(*y, y2);
8898   *width = MAX(*width, width2);
8899   *height = MAX(*height, height2);
8900 }
8901
8902 void SetAnimStatus(int anim_status_new)
8903 {
8904   if (anim_status_new == GAME_MODE_MAIN)
8905     anim_status_new = GAME_MODE_PSEUDO_MAINONLY;
8906   else if (anim_status_new == GAME_MODE_SCORES)
8907     anim_status_new = GAME_MODE_PSEUDO_SCORESOLD;
8908
8909   global.anim_status_next = anim_status_new;
8910
8911   // directly set screen modes that are entered without fading
8912   if ((global.anim_status      == GAME_MODE_PSEUDO_MAINONLY &&
8913        global.anim_status_next == GAME_MODE_PSEUDO_TYPENAME) ||
8914       (global.anim_status      == GAME_MODE_PSEUDO_TYPENAME &&
8915        global.anim_status_next == GAME_MODE_PSEUDO_MAINONLY))
8916     global.anim_status = global.anim_status_next;
8917 }
8918
8919 void SetGameStatus(int game_status_new)
8920 {
8921   if (game_status_new != game_status)
8922     game_status_last_screen = game_status;
8923
8924   game_status = game_status_new;
8925
8926   SetAnimStatus(game_status_new);
8927 }
8928
8929 void SetFontStatus(int game_status_new)
8930 {
8931   static int last_game_status = -1;
8932
8933   if (game_status_new != -1)
8934   {
8935     // set game status for font use after storing last game status
8936     last_game_status = game_status;
8937     game_status = game_status_new;
8938   }
8939   else
8940   {
8941     // reset game status after font use from last stored game status
8942     game_status = last_game_status;
8943   }
8944 }
8945
8946 void ResetFontStatus()
8947 {
8948   SetFontStatus(-1);
8949 }
8950
8951 void ChangeViewportPropertiesIfNeeded()
8952 {
8953   boolean use_mini_tilesize = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
8954                                FALSE : setup.small_game_graphics);
8955   int gfx_game_mode = game_status;
8956   int gfx_game_mode2 = (game_status == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
8957                         game_status);
8958   struct RectWithBorder *vp_window    = &viewport.window[gfx_game_mode];
8959   struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
8960   struct RectWithBorder *vp_door_1    = &viewport.door_1[gfx_game_mode];
8961   struct RectWithBorder *vp_door_2    = &viewport.door_2[gfx_game_mode2];
8962   struct RectWithBorder *vp_door_3    = &viewport.door_2[GAME_MODE_EDITOR];
8963   int new_win_xsize     = vp_window->width;
8964   int new_win_ysize     = vp_window->height;
8965   int border_size       = vp_playfield->border_size;
8966   int new_sx            = vp_playfield->x + border_size;
8967   int new_sy            = vp_playfield->y + border_size;
8968   int new_sxsize        = vp_playfield->width  - 2 * border_size;
8969   int new_sysize        = vp_playfield->height - 2 * border_size;
8970   int new_real_sx       = vp_playfield->x;
8971   int new_real_sy       = vp_playfield->y;
8972   int new_full_sxsize   = vp_playfield->width;
8973   int new_full_sysize   = vp_playfield->height;
8974   int new_dx            = vp_door_1->x;
8975   int new_dy            = vp_door_1->y;
8976   int new_dxsize        = vp_door_1->width;
8977   int new_dysize        = vp_door_1->height;
8978   int new_vx            = vp_door_2->x;
8979   int new_vy            = vp_door_2->y;
8980   int new_vxsize        = vp_door_2->width;
8981   int new_vysize        = vp_door_2->height;
8982   int new_ex            = vp_door_3->x;
8983   int new_ey            = vp_door_3->y;
8984   int new_exsize        = vp_door_3->width;
8985   int new_eysize        = vp_door_3->height;
8986   int new_tilesize_var = (use_mini_tilesize ? MINI_TILESIZE : game.tile_size);
8987   int tilesize = (gfx_game_mode == GAME_MODE_PLAYING ? new_tilesize_var :
8988                   gfx_game_mode == GAME_MODE_EDITOR ? MINI_TILESIZE : TILESIZE);
8989   int new_scr_fieldx = new_sxsize / tilesize;
8990   int new_scr_fieldy = new_sysize / tilesize;
8991   int new_scr_fieldx_buffers = new_sxsize / new_tilesize_var;
8992   int new_scr_fieldy_buffers = new_sysize / new_tilesize_var;
8993   boolean init_gfx_buffers = FALSE;
8994   boolean init_video_buffer = FALSE;
8995   boolean init_gadgets_and_anims = FALSE;
8996   boolean init_em_graphics = FALSE;
8997
8998   if (new_win_xsize != WIN_XSIZE ||
8999       new_win_ysize != WIN_YSIZE)
9000   {
9001     WIN_XSIZE = new_win_xsize;
9002     WIN_YSIZE = new_win_ysize;
9003
9004     init_video_buffer = TRUE;
9005     init_gfx_buffers = TRUE;
9006     init_gadgets_and_anims = TRUE;
9007
9008     // printf("::: video: init_video_buffer, init_gfx_buffers\n");
9009   }
9010
9011   if (new_scr_fieldx != SCR_FIELDX ||
9012       new_scr_fieldy != SCR_FIELDY)
9013   {
9014     /* this always toggles between MAIN and GAME when using small tile size */
9015
9016     SCR_FIELDX = new_scr_fieldx;
9017     SCR_FIELDY = new_scr_fieldy;
9018
9019     // printf("::: new_scr_fieldx != SCR_FIELDX ...\n");
9020   }
9021
9022   if (new_sx != SX ||
9023       new_sy != SY ||
9024       new_dx != DX ||
9025       new_dy != DY ||
9026       new_vx != VX ||
9027       new_vy != VY ||
9028       new_ex != EX ||
9029       new_ey != EY ||
9030       new_sxsize != SXSIZE ||
9031       new_sysize != SYSIZE ||
9032       new_dxsize != DXSIZE ||
9033       new_dysize != DYSIZE ||
9034       new_vxsize != VXSIZE ||
9035       new_vysize != VYSIZE ||
9036       new_exsize != EXSIZE ||
9037       new_eysize != EYSIZE ||
9038       new_real_sx != REAL_SX ||
9039       new_real_sy != REAL_SY ||
9040       new_full_sxsize != FULL_SXSIZE ||
9041       new_full_sysize != FULL_SYSIZE ||
9042       new_tilesize_var != TILESIZE_VAR
9043       )
9044   {
9045     // ------------------------------------------------------------------------
9046     // determine next fading area for changed viewport definitions
9047     // ------------------------------------------------------------------------
9048
9049     // start with current playfield area (default fading area)
9050     FADE_SX = REAL_SX;
9051     FADE_SY = REAL_SY;
9052     FADE_SXSIZE = FULL_SXSIZE;
9053     FADE_SYSIZE = FULL_SYSIZE;
9054
9055     // add new playfield area if position or size has changed
9056     if (new_real_sx != REAL_SX || new_real_sy != REAL_SY ||
9057         new_full_sxsize != FULL_SXSIZE || new_full_sysize != FULL_SYSIZE)
9058     {
9059       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9060                      new_real_sx, new_real_sy, new_full_sxsize,new_full_sysize);
9061     }
9062
9063     // add current and new door 1 area if position or size has changed
9064     if (new_dx != DX || new_dy != DY ||
9065         new_dxsize != DXSIZE || new_dysize != DYSIZE)
9066     {
9067       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9068                      DX, DY, DXSIZE, DYSIZE);
9069       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9070                      new_dx, new_dy, new_dxsize, new_dysize);
9071     }
9072
9073     // add current and new door 2 area if position or size has changed
9074     if (new_dx != VX || new_dy != VY ||
9075         new_dxsize != VXSIZE || new_dysize != VYSIZE)
9076     {
9077       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9078                      VX, VY, VXSIZE, VYSIZE);
9079       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9080                      new_vx, new_vy, new_vxsize, new_vysize);
9081     }
9082
9083     // ------------------------------------------------------------------------
9084     // handle changed tile size
9085     // ------------------------------------------------------------------------
9086
9087     if (new_tilesize_var != TILESIZE_VAR)
9088     {
9089       // printf("::: new_tilesize_var != TILESIZE_VAR\n");
9090
9091       // changing tile size invalidates scroll values of engine snapshots
9092       FreeEngineSnapshotSingle();
9093
9094       // changing tile size requires update of graphic mapping for EM engine
9095       init_em_graphics = TRUE;
9096     }
9097
9098     SX = new_sx;
9099     SY = new_sy;
9100     DX = new_dx;
9101     DY = new_dy;
9102     VX = new_vx;
9103     VY = new_vy;
9104     EX = new_ex;
9105     EY = new_ey;
9106     SXSIZE = new_sxsize;
9107     SYSIZE = new_sysize;
9108     DXSIZE = new_dxsize;
9109     DYSIZE = new_dysize;
9110     VXSIZE = new_vxsize;
9111     VYSIZE = new_vysize;
9112     EXSIZE = new_exsize;
9113     EYSIZE = new_eysize;
9114     REAL_SX = new_real_sx;
9115     REAL_SY = new_real_sy;
9116     FULL_SXSIZE = new_full_sxsize;
9117     FULL_SYSIZE = new_full_sysize;
9118     TILESIZE_VAR = new_tilesize_var;
9119
9120     init_gfx_buffers = TRUE;
9121     init_gadgets_and_anims = TRUE;
9122
9123     // printf("::: viewports: init_gfx_buffers\n");
9124     // printf("::: viewports: init_gadgets_and_anims\n");
9125   }
9126
9127   if (init_gfx_buffers)
9128   {
9129     // printf("::: init_gfx_buffers\n");
9130
9131     SCR_FIELDX = new_scr_fieldx_buffers;
9132     SCR_FIELDY = new_scr_fieldy_buffers;
9133
9134     InitGfxBuffers();
9135
9136     SCR_FIELDX = new_scr_fieldx;
9137     SCR_FIELDY = new_scr_fieldy;
9138
9139     SetDrawDeactivationMask(REDRAW_NONE);
9140     SetDrawBackgroundMask(REDRAW_FIELD);
9141   }
9142
9143   if (init_video_buffer)
9144   {
9145     // printf("::: init_video_buffer\n");
9146
9147     InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen);
9148     InitImageTextures();
9149   }
9150
9151   if (init_gadgets_and_anims)
9152   {
9153     // printf("::: init_gadgets_and_anims\n");
9154
9155     InitGadgets();
9156     InitGlobalAnimations();
9157   }
9158
9159   if (init_em_graphics)
9160   {
9161       InitGraphicInfo_EM();
9162   }
9163 }