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 //                  https://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 #define DEBUG_FRAME_TIME        FALSE
  27
  28 // tool button identifiers
  29 #define TOOL_CTRL_ID_YES        0
  30 #define TOOL_CTRL_ID_NO         1
  31 #define TOOL_CTRL_ID_CONFIRM    2
  32 #define TOOL_CTRL_ID_PLAYER_1   3
  33 #define TOOL_CTRL_ID_PLAYER_2   4
  34 #define TOOL_CTRL_ID_PLAYER_3   5
  35 #define TOOL_CTRL_ID_PLAYER_4   6
  36 #define TOOL_CTRL_ID_TOUCH_YES  7
  37 #define TOOL_CTRL_ID_TOUCH_NO   8
  38 #define TOOL_CTRL_ID_TOUCH_CONFIRM 9
  39
  40 #define NUM_TOOL_BUTTONS        10
  41
  42 // constants for number of doors and door parts
  43 #define NUM_DOORS               2
  44 #define NUM_PANELS              NUM_DOORS
  45 // #define NUM_PANELS           0
  46 #define MAX_PARTS_PER_DOOR      8
  47 #define MAX_DOOR_PARTS          (NUM_DOORS * MAX_PARTS_PER_DOOR + NUM_PANELS)
  48 #define DOOR_PART_IS_PANEL(i)   ((i) >= NUM_DOORS * MAX_PARTS_PER_DOOR)
  49
  50
  51 struct DoorPartOrderInfo
  52 {
  53   int nr;
  54   int sort_priority;
  55 };
  56
  57 static struct DoorPartOrderInfo door_part_order[MAX_DOOR_PARTS];
  58
  59 struct DoorPartControlInfo
  60 {
  61   int door_token;
  62   int graphic;
  63   struct DoorPartPosInfo *pos;
  64 };
  65
  66 static struct DoorPartControlInfo door_part_controls[] =
  67 {
  68   {
  69     DOOR_1,
  70     IMG_GFX_DOOR_1_PART_1,
  71     &door_1.part_1
  72   },
  73   {
  74     DOOR_1,
  75     IMG_GFX_DOOR_1_PART_2,
  76     &door_1.part_2
  77   },
  78   {
  79     DOOR_1,
  80     IMG_GFX_DOOR_1_PART_3,
  81     &door_1.part_3
  82   },
  83   {
  84     DOOR_1,
  85     IMG_GFX_DOOR_1_PART_4,
  86     &door_1.part_4
  87   },
  88   {
  89     DOOR_1,
  90     IMG_GFX_DOOR_1_PART_5,
  91     &door_1.part_5
  92   },
  93   {
  94     DOOR_1,
  95     IMG_GFX_DOOR_1_PART_6,
  96     &door_1.part_6
  97   },
  98   {
  99     DOOR_1,
 100     IMG_GFX_DOOR_1_PART_7,
 101     &door_1.part_7
 102   },
 103   {
 104     DOOR_1,
 105     IMG_GFX_DOOR_1_PART_8,
 106     &door_1.part_8
 107   },
 108
 109   {
 110     DOOR_2,
 111     IMG_GFX_DOOR_2_PART_1,
 112     &door_2.part_1
 113   },
 114   {
 115     DOOR_2,
 116     IMG_GFX_DOOR_2_PART_2,
 117     &door_2.part_2
 118   },
 119   {
 120     DOOR_2,
 121     IMG_GFX_DOOR_2_PART_3,
 122     &door_2.part_3
 123   },
 124   {
 125     DOOR_2,
 126     IMG_GFX_DOOR_2_PART_4,
 127     &door_2.part_4
 128   },
 129   {
 130     DOOR_2,
 131     IMG_GFX_DOOR_2_PART_5,
 132     &door_2.part_5
 133   },
 134   {
 135     DOOR_2,
 136     IMG_GFX_DOOR_2_PART_6,
 137     &door_2.part_6
 138   },
 139   {
 140     DOOR_2,
 141     IMG_GFX_DOOR_2_PART_7,
 142     &door_2.part_7
 143   },
 144   {
 145     DOOR_2,
 146     IMG_GFX_DOOR_2_PART_8,
 147     &door_2.part_8
 148   },
 149
 150   {
 151     DOOR_1,
 152     IMG_BACKGROUND_PANEL,
 153     &door_1.panel
 154   },
 155   {
 156     DOOR_2,
 157     IMG_BACKGROUND_TAPE,
 158     &door_2.panel
 159   },
 160
 161   {
 162     -1,
 163     -1,
 164     NULL
 165   }
 166 };
 167
 168 static struct XY xy_topdown[] =
 169 {
 170   {  0, -1 },
 171   { -1,  0 },
 172   { +1,  0 },
 173   {  0, +1 }
 174 };
 175
 176
 177 // forward declaration for internal use
 178 static void MapToolButtons(unsigned int);
 179 static void UnmapToolButtons(void);
 180 static void HandleToolButtons(struct GadgetInfo *);
 181 static int el_act_dir2crm(int, int, int);
 182 static int el_act2crm(int, int);
 183
 184 static struct GadgetInfo *tool_gadget[NUM_TOOL_BUTTONS];
 185 static int request_gadget_id = -1;
 186
 187 static char *print_if_not_empty(int element)
 188 {
 189   static char *s = NULL;
 190   char *token_name = element_info[element].token_name;
 191
 192   if (s != NULL)
 193     free(s);
 194
 195   s = checked_malloc(strlen(token_name) + 10 + 1);
 196
 197   if (element != EL_EMPTY)
 198     sprintf(s, "%d\t['%s']", element, token_name);
 199   else
 200     sprintf(s, "%d", element);
 201
 202   return s;
 203 }
 204
 205 int getFieldbufferOffsetX_RND(int dir, int pos)
 206 {
 207   int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
 208   int dx = (dir & MV_HORIZONTAL ? pos : 0);
 209   int dx_var = dx * TILESIZE_VAR / TILESIZE;
 210   int fx = FX;
 211
 212   if (EVEN(SCR_FIELDX))
 213   {
 214     int sbx_right = SBX_Right + (BorderElement != EL_EMPTY ? 1 : 0);
 215     int ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx_var;
 216
 217     if (ffx < sbx_right * TILEX_VAR + TILEX_VAR / 2)
 218       fx += dx_var - MIN(ffx, TILEX_VAR / 2) + TILEX_VAR;
 219     else
 220       fx += (dx_var > 0 ? TILEX_VAR : 0);
 221   }
 222   else
 223   {
 224     fx += dx_var;
 225   }
 226
 227   if (full_lev_fieldx <= SCR_FIELDX)
 228   {
 229     if (EVEN(SCR_FIELDX))
 230       fx = 2 * TILEX_VAR - (ODD(lev_fieldx)  ? TILEX_VAR / 2 : 0);
 231     else
 232       fx = 2 * TILEX_VAR - (EVEN(lev_fieldx) ? TILEX_VAR / 2 : 0);
 233   }
 234
 235   return fx;
 236 }
 237
 238 int getFieldbufferOffsetY_RND(int dir, int pos)
 239 {
 240   int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
 241   int dy = (dir & MV_VERTICAL ? pos : 0);
 242   int dy_var = dy * TILESIZE_VAR / TILESIZE;
 243   int fy = FY;
 244
 245   if (EVEN(SCR_FIELDY))
 246   {
 247     int sby_lower = SBY_Lower + (BorderElement != EL_EMPTY ? 1 : 0);
 248     int ffy = (scroll_y - SBY_Upper) * TILEY_VAR + dy_var;
 249
 250     if (ffy < sby_lower * TILEY_VAR + TILEY_VAR / 2)
 251       fy += dy_var - MIN(ffy, TILEY_VAR / 2) + TILEY_VAR;
 252     else
 253       fy += (dy_var > 0 ? TILEY_VAR : 0);
 254   }
 255   else
 256   {
 257     fy += dy_var;
 258   }
 259
 260   if (full_lev_fieldy <= SCR_FIELDY)
 261   {
 262     if (EVEN(SCR_FIELDY))
 263       fy = 2 * TILEY_VAR - (ODD(lev_fieldy)  ? TILEY_VAR / 2 : 0);
 264     else
 265       fy = 2 * TILEY_VAR - (EVEN(lev_fieldy) ? TILEY_VAR / 2 : 0);
 266   }
 267
 268   return fy;
 269 }
 270
 271 static int getLevelFromScreenX_RND(int sx)
 272 {
 273   int fx = getFieldbufferOffsetX_RND(ScreenMovDir, ScreenGfxPos);
 274   int dx = fx - FX;
 275   int px = sx - SX;
 276   int lx = LEVELX((px + dx) / TILESIZE_VAR);
 277
 278   return lx;
 279 }
 280
 281 static int getLevelFromScreenY_RND(int sy)
 282 {
 283   int fy = getFieldbufferOffsetY_RND(ScreenMovDir, ScreenGfxPos);
 284   int dy = fy - FY;
 285   int py = sy - SY;
 286   int ly = LEVELY((py + dy) / TILESIZE_VAR);
 287
 288   return ly;
 289 }
 290
 291 static int getLevelFromScreenX_EM(int sx)
 292 {
 293   int level_xsize = level.native_em_level->cav->width;
 294   int full_xsize = level_xsize * TILESIZE_VAR;
 295
 296   sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
 297
 298   int fx = getFieldbufferOffsetX_EM();
 299   int dx = fx;
 300   int px = sx - SX;
 301   int lx = LEVELX((px + dx) / TILESIZE_VAR);
 302
 303   return lx;
 304 }
 305
 306 static int getLevelFromScreenY_EM(int sy)
 307 {
 308   int level_ysize = level.native_em_level->cav->height;
 309   int full_ysize = level_ysize * TILESIZE_VAR;
 310
 311   sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
 312
 313   int fy = getFieldbufferOffsetY_EM();
 314   int dy = fy;
 315   int py = sy - SY;
 316   int ly = LEVELY((py + dy) / TILESIZE_VAR);
 317
 318   return ly;
 319 }
 320
 321 static int getLevelFromScreenX_SP(int sx)
 322 {
 323   int menBorder = setup.sp_show_border_elements;
 324   int level_xsize = level.native_sp_level->width;
 325   int full_xsize = (level_xsize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
 326
 327   sx += (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
 328
 329   int fx = getFieldbufferOffsetX_SP();
 330   int dx = fx - FX;
 331   int px = sx - SX;
 332   int lx = LEVELX((px + dx) / TILESIZE_VAR);
 333
 334   return lx;
 335 }
 336
 337 static int getLevelFromScreenY_SP(int sy)
 338 {
 339   int menBorder = setup.sp_show_border_elements;
 340   int level_ysize = level.native_sp_level->height;
 341   int full_ysize = (level_ysize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
 342
 343   sy += (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
 344
 345   int fy = getFieldbufferOffsetY_SP();
 346   int dy = fy - FY;
 347   int py = sy - SY;
 348   int ly = LEVELY((py + dy) / TILESIZE_VAR);
 349
 350   return ly;
 351 }
 352
 353 static int getLevelFromScreenX_MM(int sx)
 354 {
 355   int level_xsize = level.native_mm_level->fieldx;
 356   int full_xsize = level_xsize * TILESIZE_VAR;
 357
 358   sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
 359
 360   int px = sx - SX;
 361   int lx = (px + TILESIZE_VAR) / TILESIZE_VAR - 1;
 362
 363   return lx;
 364 }
 365
 366 static int getLevelFromScreenY_MM(int sy)
 367 {
 368   int level_ysize = level.native_mm_level->fieldy;
 369   int full_ysize = level_ysize * TILESIZE_VAR;
 370
 371   sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
 372
 373   int py = sy - SY;
 374   int ly = (py + TILESIZE_VAR) / TILESIZE_VAR - 1;
 375
 376   return ly;
 377 }
 378
 379 int getLevelFromScreenX(int x)
 380 {
 381   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 382     return getLevelFromScreenX_EM(x);
 383   if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 384     return getLevelFromScreenX_SP(x);
 385   if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 386     return getLevelFromScreenX_MM(x);
 387   else
 388     return getLevelFromScreenX_RND(x);
 389 }
 390
 391 int getLevelFromScreenY(int y)
 392 {
 393   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 394     return getLevelFromScreenY_EM(y);
 395   if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 396     return getLevelFromScreenY_SP(y);
 397   if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 398     return getLevelFromScreenY_MM(y);
 399   else
 400     return getLevelFromScreenY_RND(y);
 401 }
 402
 403 int getScreenFieldSizeX(void)
 404 {
 405   return (tape.playing ? tape.scr_fieldx : SCR_FIELDX);
 406 }
 407
 408 int getScreenFieldSizeY(void)
 409 {
 410   return (tape.playing ? tape.scr_fieldy : SCR_FIELDY);
 411 }
 412
 413 void DumpTile(int x, int y)
 414 {
 415   int sx = SCREENX(x);
 416   int sy = SCREENY(y);
 417   char *token_name;
 418
 419   Info("---");
 420   Info("Field Info: SCREEN(%d, %d), LEVEL(%d, %d)", sx, sy, x, y);
 421   Info("---");
 422
 423   if (!IN_LEV_FIELD(x, y))
 424   {
 425     Info("(not in level field)");
 426     Info("");
 427
 428     return;
 429   }
 430
 431   token_name = element_info[Tile[x][y]].token_name;
 432
 433   Info("Tile:        %d\t['%s']",       Tile[x][y], token_name);
 434   Info("Back:        %s",               print_if_not_empty(Back[x][y]));
 435   Info("Store:       %s",               print_if_not_empty(Store[x][y]));
 436   Info("Store2:      %s",               print_if_not_empty(Store2[x][y]));
 437   Info("StorePlayer: %s",               print_if_not_empty(StorePlayer[x][y]));
 438   Info("MovPos:      %d",               MovPos[x][y]);
 439   Info("MovDir:      %d",               MovDir[x][y]);
 440   Info("MovDelay:    %d",               MovDelay[x][y]);
 441   Info("ChangeDelay: %d",               ChangeDelay[x][y]);
 442   Info("CustomValue: %d",               CustomValue[x][y]);
 443   Info("GfxElement:  %d",               GfxElement[x][y]);
 444   Info("GfxAction:   %d",               GfxAction[x][y]);
 445   Info("GfxFrame:    %d [%d]",          GfxFrame[x][y], FrameCounter);
 446   Info("Player x/y:  %d, %d",           local_player->jx, local_player->jy);
 447   Info("");
 448 }
 449
 450 void DumpTileFromScreen(int sx, int sy)
 451 {
 452   int lx = getLevelFromScreenX(sx);
 453   int ly = getLevelFromScreenY(sy);
 454
 455   DumpTile(lx, ly);
 456 }
 457
 458 void SetDrawtoField(int mode)
 459 {
 460   if (mode == DRAW_TO_FIELDBUFFER)
 461   {
 462     FX = 2 * TILEX_VAR;
 463     FY = 2 * TILEY_VAR;
 464     BX1 = -2;
 465     BY1 = -2;
 466     BX2 = SCR_FIELDX + 1;
 467     BY2 = SCR_FIELDY + 1;
 468
 469     drawto_field = fieldbuffer;
 470   }
 471   else  // DRAW_TO_BACKBUFFER
 472   {
 473     FX = SX;
 474     FY = SY;
 475     BX1 = 0;
 476     BY1 = 0;
 477     BX2 = SCR_FIELDX - 1;
 478     BY2 = SCR_FIELDY - 1;
 479
 480     drawto_field = backbuffer;
 481   }
 482 }
 483
 484 int GetDrawtoField(void)
 485 {
 486   return (drawto_field == fieldbuffer ? DRAW_TO_FIELDBUFFER : DRAW_TO_BACKBUFFER);
 487 }
 488
 489 static void RedrawPlayfield_RND(void)
 490 {
 491   if (game.envelope_active)
 492     return;
 493
 494   DrawLevel(REDRAW_ALL);
 495   DrawAllPlayers();
 496 }
 497
 498 void RedrawPlayfield(void)
 499 {
 500   if (game_status != GAME_MODE_PLAYING)
 501     return;
 502
 503   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 504     RedrawPlayfield_EM(TRUE);
 505   else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 506     RedrawPlayfield_SP(TRUE);
 507   else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 508     RedrawPlayfield_MM();
 509   else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
 510     RedrawPlayfield_RND();
 511
 512   BlitScreenToBitmap(backbuffer);
 513
 514   BlitBitmap(drawto, window, gfx.sx, gfx.sy, gfx.sxsize, gfx.sysize,
 515              gfx.sx, gfx.sy);
 516 }
 517
 518 static void DrawMaskedBorderExt_Rect(int x, int y, int width, int height,
 519                                      int draw_target)
 520 {
 521   Bitmap *src_bitmap = getGlobalBorderBitmapFromStatus(global.border_status);
 522   Bitmap *dst_bitmap = gfx.masked_border_bitmap_ptr;
 523
 524   // may happen for "border.draw_masked.*" with undefined "global.border.*"
 525   if (src_bitmap == NULL)
 526     return;
 527
 528   if (x == -1 && y == -1)
 529     return;
 530
 531   if (draw_target == DRAW_TO_SCREEN)
 532     BlitToScreenMasked(src_bitmap, x, y, width, height, x, y);
 533   else
 534     BlitBitmapMasked(src_bitmap, dst_bitmap, x, y, width, height, x, y);
 535 }
 536
 537 static void DrawMaskedBorderExt_FIELD(int draw_target)
 538 {
 539   if (global.border_status >= GAME_MODE_MAIN &&
 540       global.border_status <= GAME_MODE_PLAYING &&
 541       border.draw_masked[global.border_status])
 542     DrawMaskedBorderExt_Rect(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
 543                              draw_target);
 544 }
 545
 546 static void DrawMaskedBorderExt_DOOR_1(int draw_target)
 547 {
 548   // when drawing to backbuffer, never draw border over open doors
 549   if (draw_target == DRAW_TO_BACKBUFFER &&
 550       (GetDoorState() & DOOR_OPEN_1))
 551     return;
 552
 553   if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
 554       (global.border_status != GAME_MODE_EDITOR ||
 555        border.draw_masked[GFX_SPECIAL_ARG_EDITOR]))
 556     DrawMaskedBorderExt_Rect(DX, DY, DXSIZE, DYSIZE, draw_target);
 557 }
 558
 559 static void DrawMaskedBorderExt_DOOR_2(int draw_target)
 560 {
 561   // when drawing to backbuffer, never draw border over open doors
 562   if (draw_target == DRAW_TO_BACKBUFFER &&
 563       (GetDoorState() & DOOR_OPEN_2))
 564     return;
 565
 566   if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
 567       global.border_status != GAME_MODE_EDITOR)
 568     DrawMaskedBorderExt_Rect(VX, VY, VXSIZE, VYSIZE, draw_target);
 569 }
 570
 571 static void DrawMaskedBorderExt_DOOR_3(int draw_target)
 572 {
 573   // currently not available
 574 }
 575
 576 static void DrawMaskedBorderExt_ALL(int draw_target)
 577 {
 578   DrawMaskedBorderExt_FIELD(draw_target);
 579   DrawMaskedBorderExt_DOOR_1(draw_target);
 580   DrawMaskedBorderExt_DOOR_2(draw_target);
 581   DrawMaskedBorderExt_DOOR_3(draw_target);
 582 }
 583
 584 static void DrawMaskedBorderExt(int redraw_mask, int draw_target)
 585 {
 586   // never draw masked screen borders on borderless screens
 587   if (global.border_status == GAME_MODE_LOADING ||
 588       global.border_status == GAME_MODE_TITLE)
 589     return;
 590
 591   if (redraw_mask & REDRAW_ALL)
 592     DrawMaskedBorderExt_ALL(draw_target);
 593   else
 594   {
 595     if (redraw_mask & REDRAW_FIELD)
 596       DrawMaskedBorderExt_FIELD(draw_target);
 597     if (redraw_mask & REDRAW_DOOR_1)
 598       DrawMaskedBorderExt_DOOR_1(draw_target);
 599     if (redraw_mask & REDRAW_DOOR_2)
 600       DrawMaskedBorderExt_DOOR_2(draw_target);
 601     if (redraw_mask & REDRAW_DOOR_3)
 602       DrawMaskedBorderExt_DOOR_3(draw_target);
 603   }
 604 }
 605
 606 void DrawMaskedBorder_FIELD(void)
 607 {
 608   DrawMaskedBorderExt_FIELD(DRAW_TO_BACKBUFFER);
 609 }
 610
 611 void DrawMaskedBorder(int redraw_mask)
 612 {
 613   DrawMaskedBorderExt(redraw_mask, DRAW_TO_BACKBUFFER);
 614 }
 615
 616 void DrawMaskedBorderToTarget(int draw_target)
 617 {
 618   if (draw_target == DRAW_TO_BACKBUFFER ||
 619       draw_target == DRAW_TO_SCREEN)
 620   {
 621     DrawMaskedBorderExt(REDRAW_ALL, draw_target);
 622   }
 623   else
 624   {
 625     int last_border_status = global.border_status;
 626
 627     if (draw_target == DRAW_TO_FADE_SOURCE)
 628     {
 629       global.border_status = gfx.fade_border_source_status;
 630       gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_source;
 631     }
 632     else if (draw_target == DRAW_TO_FADE_TARGET)
 633     {
 634       global.border_status = gfx.fade_border_target_status;
 635       gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_target;
 636     }
 637
 638     // always use global border for PLAYING when restarting the game
 639     if (global.border_status == GAME_MODE_PSEUDO_RESTARTING)
 640       global.border_status = GAME_MODE_PLAYING;
 641
 642     DrawMaskedBorderExt(REDRAW_ALL, draw_target);
 643
 644     global.border_status = last_border_status;
 645     gfx.masked_border_bitmap_ptr = backbuffer;
 646   }
 647 }
 648
 649 void DrawTileCursor(int draw_target)
 650 {
 651   DrawTileCursor_MM(draw_target, game_status == GAME_MODE_PLAYING);
 652 }
 653
 654 void BlitScreenToBitmapExt_RND(Bitmap *target_bitmap, int fx, int fy)
 655 {
 656   BlitBitmap(drawto_field, target_bitmap, fx, fy, SXSIZE, SYSIZE, SX, SY);
 657 }
 658
 659 void BlitScreenToBitmap_RND(Bitmap *target_bitmap)
 660 {
 661   int fx = getFieldbufferOffsetX_RND(ScreenMovDir, ScreenGfxPos);
 662   int fy = getFieldbufferOffsetY_RND(ScreenMovDir, ScreenGfxPos);
 663
 664   BlitScreenToBitmapExt_RND(target_bitmap, fx, fy);
 665 }
 666
 667 void BlitScreenToBitmap(Bitmap *target_bitmap)
 668 {
 669   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
 670     BlitScreenToBitmap_EM(target_bitmap);
 671   else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
 672     BlitScreenToBitmap_SP(target_bitmap);
 673   else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
 674     BlitScreenToBitmap_MM(target_bitmap);
 675   else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
 676     BlitScreenToBitmap_RND(target_bitmap);
 677
 678   redraw_mask |= REDRAW_FIELD;
 679 }
 680
 681 static void DrawFramesPerSecond(void)
 682 {
 683   char text[100];
 684   int font_nr = FONT_TEXT_2;
 685   int font_width = getFontWidth(font_nr);
 686   int draw_deactivation_mask = GetDrawDeactivationMask();
 687   boolean draw_masked = (draw_deactivation_mask == REDRAW_NONE);
 688
 689   // draw FPS with leading space (needed if field buffer deactivated)
 690   sprintf(text, " %04.1f fps", global.frames_per_second);
 691
 692   // override draw deactivation mask (required for invisible warp mode)
 693   SetDrawDeactivationMask(REDRAW_NONE);
 694
 695   // draw opaque FPS if field buffer deactivated, else draw masked FPS
 696   DrawTextExt(backbuffer, SX + SXSIZE - font_width * strlen(text), SY, text,
 697               font_nr, (draw_masked ? BLIT_MASKED : BLIT_OPAQUE));
 698
 699   // set draw deactivation mask to previous value
 700   SetDrawDeactivationMask(draw_deactivation_mask);
 701
 702   // force full-screen redraw in this frame
 703   redraw_mask = REDRAW_ALL;
 704 }
 705
 706 #if DEBUG_FRAME_TIME
 707 static void PrintFrameTimeDebugging(void)
 708 {
 709   static unsigned int last_counter = 0;
 710   unsigned int counter = Counter();
 711   int diff_1 = counter - last_counter;
 712   int diff_2 = diff_1 - GAME_FRAME_DELAY;
 713   int diff_2_max = 20;
 714   int diff_2_cut = MIN(ABS(diff_2), diff_2_max);
 715   char diff_bar[2 * diff_2_max + 5];
 716   int pos = 0;
 717   int i;
 718
 719   diff_bar[pos++] = (diff_2 < -diff_2_max ? '<' : ' ');
 720
 721   for (i = 0; i < diff_2_max; i++)
 722     diff_bar[pos++] = (diff_2 >= 0 ? ' ' :
 723                        i >= diff_2_max - diff_2_cut ? '-' : ' ');
 724
 725   diff_bar[pos++] = '|';
 726
 727   for (i = 0; i < diff_2_max; i++)
 728     diff_bar[pos++] = (diff_2 <= 0 ? ' ' : i < diff_2_cut ? '+' : ' ');
 729
 730   diff_bar[pos++] = (diff_2 > diff_2_max ? '>' : ' ');
 731
 732   diff_bar[pos++] = '\0';
 733
 734   Debug("time:frame", "%06d [%02d] [%c%02d] %s",
 735         counter,
 736         diff_1,
 737         (diff_2 < 0 ? '-' : diff_2 > 0 ? '+' : ' '), ABS(diff_2),
 738         diff_bar);
 739
 740   last_counter = counter;
 741 }
 742 #endif
 743
 744 static int unifiedRedrawMask(int mask)
 745 {
 746   if (mask & REDRAW_ALL)
 747     return REDRAW_ALL;
 748
 749   if (mask & REDRAW_FIELD && mask & REDRAW_DOORS)
 750     return REDRAW_ALL;
 751
 752   return mask;
 753 }
 754
 755 static boolean equalRedrawMasks(int mask_1, int mask_2)
 756 {
 757   return unifiedRedrawMask(mask_1) == unifiedRedrawMask(mask_2);
 758 }
 759
 760 void BackToFront(void)
 761 {
 762   static int last_redraw_mask = REDRAW_NONE;
 763
 764   // force screen redraw in every frame to continue drawing global animations
 765   // (but always use the last redraw mask to prevent unwanted side effects)
 766   if (redraw_mask == REDRAW_NONE)
 767     redraw_mask = last_redraw_mask;
 768
 769   last_redraw_mask = redraw_mask;
 770
 771 #if 1
 772   // masked border now drawn immediately when blitting backbuffer to window
 773 #else
 774   // draw masked border to all viewports, if defined
 775   DrawMaskedBorder(redraw_mask);
 776 #endif
 777
 778   // draw frames per second (only if debug mode is enabled)
 779   if (redraw_mask & REDRAW_FPS)
 780     DrawFramesPerSecond();
 781
 782   // remove playfield redraw before potentially merging with doors redraw
 783   if (DrawingDeactivated(REAL_SX, REAL_SY))
 784     redraw_mask &= ~REDRAW_FIELD;
 785
 786   // redraw complete window if both playfield and (some) doors need redraw
 787   if (redraw_mask & REDRAW_FIELD && redraw_mask & REDRAW_DOORS)
 788     redraw_mask = REDRAW_ALL;
 789
 790   /* although redrawing the whole window would be fine for normal gameplay,
 791      being able to only redraw the playfield is required for deactivating
 792      certain drawing areas (mainly playfield) to work, which is needed for
 793      warp-forward to be fast enough (by skipping redraw of most frames) */
 794
 795   if (redraw_mask & REDRAW_ALL)
 796   {
 797     BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
 798   }
 799   else if (redraw_mask & REDRAW_FIELD)
 800   {
 801     BlitBitmap(backbuffer, window,
 802                REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
 803   }
 804   else if (redraw_mask & REDRAW_DOORS)
 805   {
 806     // merge door areas to prevent calling screen redraw more than once
 807     int x1 = WIN_XSIZE;
 808     int y1 = WIN_YSIZE;
 809     int x2 = 0;
 810     int y2 = 0;
 811
 812     if (redraw_mask & REDRAW_DOOR_1)
 813     {
 814       x1 = MIN(x1, DX);
 815       y1 = MIN(y1, DY);
 816       x2 = MAX(x2, DX + DXSIZE);
 817       y2 = MAX(y2, DY + DYSIZE);
 818     }
 819
 820     if (redraw_mask & REDRAW_DOOR_2)
 821     {
 822       x1 = MIN(x1, VX);
 823       y1 = MIN(y1, VY);
 824       x2 = MAX(x2, VX + VXSIZE);
 825       y2 = MAX(y2, VY + VYSIZE);
 826     }
 827
 828     if (redraw_mask & REDRAW_DOOR_3)
 829     {
 830       x1 = MIN(x1, EX);
 831       y1 = MIN(y1, EY);
 832       x2 = MAX(x2, EX + EXSIZE);
 833       y2 = MAX(y2, EY + EYSIZE);
 834     }
 835
 836     // make sure that at least one pixel is blitted, and inside the screen
 837     // (else nothing is blitted, causing the animations not to be updated)
 838     x1 = MIN(MAX(0, x1), WIN_XSIZE - 1);
 839     y1 = MIN(MAX(0, y1), WIN_YSIZE - 1);
 840     x2 = MIN(MAX(1, x2), WIN_XSIZE);
 841     y2 = MIN(MAX(1, y2), WIN_YSIZE);
 842
 843     BlitBitmap(backbuffer, window, x1, y1, x2 - x1, y2 - y1, x1, y1);
 844   }
 845
 846   redraw_mask = REDRAW_NONE;
 847
 848 #if DEBUG_FRAME_TIME
 849   PrintFrameTimeDebugging();
 850 #endif
 851 }
 852
 853 void BackToFront_WithFrameDelay(unsigned int frame_delay_value)
 854 {
 855   unsigned int frame_delay_value_old = GetVideoFrameDelay();
 856
 857   SetVideoFrameDelay(frame_delay_value);
 858
 859   BackToFront();
 860
 861   SetVideoFrameDelay(frame_delay_value_old);
 862 }
 863
 864 static int fade_type_skip = FADE_TYPE_NONE;
 865
 866 static void FadeExt(int fade_mask, int fade_mode, int fade_type)
 867 {
 868   void (*draw_border_function)(void) = NULL;
 869   int x, y, width, height;
 870   int fade_delay, post_delay;
 871
 872   if (fade_type == FADE_TYPE_FADE_OUT)
 873   {
 874     if (fade_type_skip != FADE_TYPE_NONE)
 875     {
 876       // skip all fade operations until specified fade operation
 877       if (fade_type & fade_type_skip)
 878         fade_type_skip = FADE_TYPE_NONE;
 879
 880       return;
 881     }
 882
 883     if (fading.fade_mode & FADE_TYPE_TRANSFORM)
 884       return;
 885   }
 886
 887   redraw_mask |= fade_mask;
 888
 889   if (fade_type == FADE_TYPE_SKIP)
 890   {
 891     fade_type_skip = fade_mode;
 892
 893     return;
 894   }
 895
 896   fade_delay = fading.fade_delay;
 897   post_delay = (fade_mode == FADE_MODE_FADE_OUT ? fading.post_delay : 0);
 898
 899   if (fade_type_skip != FADE_TYPE_NONE)
 900   {
 901     // skip all fade operations until specified fade operation
 902     if (fade_type & fade_type_skip)
 903       fade_type_skip = FADE_TYPE_NONE;
 904
 905     fade_delay = 0;
 906   }
 907
 908   if (global.autoplay_leveldir)
 909   {
 910     return;
 911   }
 912
 913   if (fade_mask == REDRAW_FIELD)
 914   {
 915     x = FADE_SX;
 916     y = FADE_SY;
 917     width  = FADE_SXSIZE;
 918     height = FADE_SYSIZE;
 919
 920     if (border.draw_masked_when_fading)
 921       draw_border_function = DrawMaskedBorder_FIELD;    // update when fading
 922     else
 923       DrawMaskedBorder_FIELD();                         // draw once
 924   }
 925   else          // REDRAW_ALL
 926   {
 927     x = 0;
 928     y = 0;
 929     width  = WIN_XSIZE;
 930     height = WIN_YSIZE;
 931   }
 932
 933   // when switching screens without fading, set fade delay to zero
 934   if (!setup.fade_screens || fading.fade_mode == FADE_MODE_NONE)
 935     fade_delay = 0;
 936
 937   // do not display black frame when fading out without fade delay
 938   if (fade_mode == FADE_MODE_FADE_OUT && fade_delay == 0)
 939     return;
 940
 941   FadeRectangle(x, y, width, height, fade_mode, fade_delay, post_delay,
 942                 draw_border_function);
 943
 944   redraw_mask &= ~fade_mask;
 945
 946   ClearAutoRepeatKeyEvents();
 947 }
 948
 949 static void SetScreenStates_BeforeFadingIn(void)
 950 {
 951   // temporarily set screen mode for animations to screen after fading in
 952   global.anim_status = global.anim_status_next;
 953
 954   // store backbuffer with all animations that will be started after fading in
 955   PrepareFadeBitmap(DRAW_TO_FADE_TARGET);
 956
 957   // set screen mode for animations back to fading
 958   global.anim_status = GAME_MODE_PSEUDO_FADING;
 959 }
 960
 961 static void SetScreenStates_AfterFadingIn(void)
 962 {
 963   // store new source screen (to use correct masked border for fading)
 964   gfx.fade_border_source_status = global.border_status;
 965
 966   global.anim_status = global.anim_status_next;
 967 }
 968
 969 static void SetScreenStates_BeforeFadingOut(void)
 970 {
 971   // store new target screen (to use correct masked border for fading)
 972   gfx.fade_border_target_status = game_status;
 973
 974   // set screen mode for animations to fading
 975   global.anim_status = GAME_MODE_PSEUDO_FADING;
 976
 977   // store backbuffer with all animations that will be stopped for fading out
 978   PrepareFadeBitmap(DRAW_TO_FADE_SOURCE);
 979 }
 980
 981 static void SetScreenStates_AfterFadingOut(void)
 982 {
 983   global.border_status = game_status;
 984
 985   // always use global border for PLAYING when restarting the game
 986   if (global.border_status == GAME_MODE_PSEUDO_RESTARTING)
 987     global.border_status = GAME_MODE_PLAYING;
 988 }
 989
 990 void FadeIn(int fade_mask)
 991 {
 992   SetScreenStates_BeforeFadingIn();
 993
 994 #if 1
 995   DrawMaskedBorder(REDRAW_ALL);
 996 #endif
 997
 998   if (fading.fade_mode & FADE_TYPE_TRANSFORM)
 999     FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_IN);
1000   else
1001     FadeExt(fade_mask, FADE_MODE_FADE_IN, FADE_TYPE_FADE_IN);
1002
1003   FADE_SX = REAL_SX;
1004   FADE_SY = REAL_SY;
1005   FADE_SXSIZE = FULL_SXSIZE;
1006   FADE_SYSIZE = FULL_SYSIZE;
1007
1008   // activate virtual buttons depending on upcoming game status
1009   if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS) &&
1010       game_status == GAME_MODE_PLAYING && !tape.playing)
1011     SetOverlayActive(TRUE);
1012
1013   SetScreenStates_AfterFadingIn();
1014
1015   // force update of global animation status in case of rapid screen changes
1016   redraw_mask = REDRAW_ALL;
1017   BackToFront();
1018 }
1019
1020 void FadeOut(int fade_mask)
1021 {
1022   // update screen if areas covered by "fade_mask" and "redraw_mask" differ
1023   if (!equalRedrawMasks(fade_mask, redraw_mask) &&
1024       fade_type_skip != FADE_MODE_SKIP_FADE_OUT)
1025     BackToFront();
1026
1027   SetScreenStates_BeforeFadingOut();
1028
1029   SetTileCursorActive(FALSE);
1030   SetOverlayActive(FALSE);
1031
1032 #if 0
1033   DrawMaskedBorder(REDRAW_ALL);
1034 #endif
1035
1036   if (fading.fade_mode & FADE_TYPE_TRANSFORM)
1037     FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_OUT);
1038   else
1039     FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
1040
1041   SetScreenStates_AfterFadingOut();
1042 }
1043
1044 static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
1045 {
1046   static struct TitleFadingInfo fading_leave_stored;
1047
1048   if (set)
1049     fading_leave_stored = fading_leave;
1050   else
1051     fading = fading_leave_stored;
1052 }
1053
1054 void FadeSetEnterMenu(void)
1055 {
1056   fading = menu.enter_menu;
1057
1058   FadeSetLeaveNext(fading, TRUE);       // (keep same fade mode)
1059 }
1060
1061 void FadeSetLeaveMenu(void)
1062 {
1063   fading = menu.leave_menu;
1064
1065   FadeSetLeaveNext(fading, TRUE);       // (keep same fade mode)
1066 }
1067
1068 void FadeSetEnterScreen(void)
1069 {
1070   fading = menu.enter_screen[game_status];
1071
1072   FadeSetLeaveNext(menu.leave_screen[game_status], TRUE);       // store
1073 }
1074
1075 void FadeSetNextScreen(void)
1076 {
1077   fading = menu.next_screen[game_status];
1078
1079   // (do not overwrite fade mode set by FadeSetEnterScreen)
1080   // FadeSetLeaveNext(fading, TRUE);    // (keep same fade mode)
1081 }
1082
1083 void FadeSetLeaveScreen(void)
1084 {
1085   FadeSetLeaveNext(menu.leave_screen[game_status], FALSE);      // recall
1086 }
1087
1088 void FadeSetFromType(int type)
1089 {
1090   if (type & TYPE_ENTER_SCREEN)
1091     FadeSetEnterScreen();
1092   else if (type & TYPE_ENTER)
1093     FadeSetEnterMenu();
1094   else if (type & TYPE_LEAVE)
1095     FadeSetLeaveMenu();
1096 }
1097
1098 void FadeSetDisabled(void)
1099 {
1100   static struct TitleFadingInfo fading_none = { FADE_MODE_NONE, -1, -1, -1 };
1101
1102   fading = fading_none;
1103 }
1104
1105 void FadeSkipNextFadeIn(void)
1106 {
1107   FadeExt(0, FADE_MODE_SKIP_FADE_IN, FADE_TYPE_SKIP);
1108 }
1109
1110 void FadeSkipNextFadeOut(void)
1111 {
1112   FadeExt(0, FADE_MODE_SKIP_FADE_OUT, FADE_TYPE_SKIP);
1113 }
1114
1115 static int getGlobalGameStatus(int status)
1116 {
1117   return (status == GAME_MODE_PSEUDO_TYPENAME ? GAME_MODE_MAIN :
1118           status == GAME_MODE_SCOREINFO       ? GAME_MODE_SCORES :
1119           status);
1120 }
1121
1122 int getImageFromGraphicOrDefault(int graphic, int default_graphic)
1123 {
1124   if (graphic == IMG_UNDEFINED)
1125     return IMG_UNDEFINED;
1126
1127   boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
1128
1129   return (graphic_info[graphic].bitmap != NULL || redefined ?
1130           graphic : default_graphic);
1131 }
1132
1133 static int getBackgroundImage(int graphic)
1134 {
1135   return getImageFromGraphicOrDefault(graphic, IMG_BACKGROUND);
1136 }
1137
1138 static int getGlobalBorderImage(int graphic)
1139 {
1140   return getImageFromGraphicOrDefault(graphic, IMG_GLOBAL_BORDER);
1141 }
1142
1143 Bitmap *getGlobalBorderBitmapFromStatus(int status_raw)
1144 {
1145   int status = getGlobalGameStatus(status_raw);
1146   int graphic =
1147     (status == GAME_MODE_MAIN    ? IMG_GLOBAL_BORDER_MAIN :
1148      status == GAME_MODE_SCORES  ? IMG_GLOBAL_BORDER_SCORES :
1149      status == GAME_MODE_EDITOR  ? IMG_GLOBAL_BORDER_EDITOR :
1150      status == GAME_MODE_PLAYING ? IMG_GLOBAL_BORDER_PLAYING :
1151      IMG_GLOBAL_BORDER);
1152   int graphic_final = getGlobalBorderImage(graphic);
1153
1154   return graphic_info[graphic_final].bitmap;
1155 }
1156
1157 void SetBackgroundImage(int graphic, int redraw_mask)
1158 {
1159   struct GraphicInfo *g = &graphic_info[graphic];
1160   struct GraphicInfo g_undefined = { 0 };
1161
1162   if (graphic == IMG_UNDEFINED)
1163     g = &g_undefined;
1164
1165   // always use original size bitmap for backgrounds, if existing
1166   Bitmap *bitmap = (g->bitmaps != NULL &&
1167                     g->bitmaps[IMG_BITMAP_PTR_ORIGINAL] != NULL ?
1168                     g->bitmaps[IMG_BITMAP_PTR_ORIGINAL] : g->bitmap);
1169
1170   // remove every mask before setting mask for window, and
1171   // remove window area mask before setting mask for main or door area
1172   int remove_mask = (redraw_mask == REDRAW_ALL ? 0xffff : REDRAW_ALL);
1173
1174   // (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!)
1175   SetBackgroundBitmap(NULL, remove_mask, 0, 0, 0, 0);   // !!! FIX THIS !!!
1176   SetBackgroundBitmap(bitmap, redraw_mask,
1177                       g->src_x, g->src_y,
1178                       g->width, g->height);
1179 }
1180
1181 void SetWindowBackgroundImageIfDefined(int graphic)
1182 {
1183   if (graphic_info[graphic].bitmap)
1184     SetBackgroundImage(graphic, REDRAW_ALL);
1185 }
1186
1187 void SetMainBackgroundImageIfDefined(int graphic)
1188 {
1189   if (graphic_info[graphic].bitmap)
1190     SetBackgroundImage(graphic, REDRAW_FIELD);
1191 }
1192
1193 void SetDoorBackgroundImageIfDefined(int graphic)
1194 {
1195   if (graphic_info[graphic].bitmap)
1196     SetBackgroundImage(graphic, REDRAW_DOOR_1);
1197 }
1198
1199 void SetWindowBackgroundImage(int graphic)
1200 {
1201   SetBackgroundImage(getBackgroundImage(graphic), REDRAW_ALL);
1202 }
1203
1204 void SetMainBackgroundImage(int graphic)
1205 {
1206   SetBackgroundImage(getBackgroundImage(graphic), REDRAW_FIELD);
1207 }
1208
1209 void SetDoorBackgroundImage(int graphic)
1210 {
1211   SetBackgroundImage(getBackgroundImage(graphic), REDRAW_DOOR_1);
1212 }
1213
1214 void SetPanelBackground(void)
1215 {
1216   SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
1217 }
1218
1219 void DrawBackground(int x, int y, int width, int height)
1220 {
1221   // "drawto" might still point to playfield buffer here (hall of fame)
1222   ClearRectangleOnBackground(backbuffer, x, y, width, height);
1223
1224   if (IN_GFX_FIELD_FULL(x, y))
1225     redraw_mask |= REDRAW_FIELD;
1226   else if (IN_GFX_DOOR_1(x, y))
1227     redraw_mask |= REDRAW_DOOR_1;
1228   else if (IN_GFX_DOOR_2(x, y))
1229     redraw_mask |= REDRAW_DOOR_2;
1230   else if (IN_GFX_DOOR_3(x, y))
1231     redraw_mask |= REDRAW_DOOR_3;
1232 }
1233
1234 void DrawBackgroundForFont(int x, int y, int width, int height, int font_nr)
1235 {
1236   struct FontBitmapInfo *font = getFontBitmapInfo(font_nr);
1237
1238   if (font->bitmap == NULL)
1239     return;
1240
1241   DrawBackground(x, y, width, height);
1242 }
1243
1244 void DrawBackgroundForGraphic(int x, int y, int width, int height, int graphic)
1245 {
1246   struct GraphicInfo *g = &graphic_info[graphic];
1247
1248   if (g->bitmap == NULL)
1249     return;
1250
1251   DrawBackground(x, y, width, height);
1252 }
1253
1254 static int game_status_last = -1;
1255 static Bitmap *global_border_bitmap_last = NULL;
1256 static Bitmap *global_border_bitmap = NULL;
1257 static int real_sx_last = -1, real_sy_last = -1;
1258 static int full_sxsize_last = -1, full_sysize_last = -1;
1259 static int dx_last = -1, dy_last = -1;
1260 static int dxsize_last = -1, dysize_last = -1;
1261 static int vx_last = -1, vy_last = -1;
1262 static int vxsize_last = -1, vysize_last = -1;
1263 static int ex_last = -1, ey_last = -1;
1264 static int exsize_last = -1, eysize_last = -1;
1265
1266 boolean CheckIfGlobalBorderHasChanged(void)
1267 {
1268   // if game status has not changed, global border has not changed either
1269   if (game_status == game_status_last)
1270     return FALSE;
1271
1272   // determine and store new global border bitmap for current game status
1273   global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
1274
1275   return (global_border_bitmap_last != global_border_bitmap);
1276 }
1277
1278 #define ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED             0
1279
1280 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1281 static boolean CheckIfGlobalBorderRedrawIsNeeded(void)
1282 {
1283   // if game status has not changed, nothing has to be redrawn
1284   if (game_status == game_status_last)
1285     return FALSE;
1286
1287   // redraw if last screen was title screen
1288   if (game_status_last == GAME_MODE_TITLE)
1289     return TRUE;
1290
1291   // redraw if global screen border has changed
1292   if (CheckIfGlobalBorderHasChanged())
1293     return TRUE;
1294
1295   // redraw if position or size of playfield area has changed
1296   if (real_sx_last != REAL_SX || real_sy_last != REAL_SY ||
1297       full_sxsize_last != FULL_SXSIZE || full_sysize_last != FULL_SYSIZE)
1298     return TRUE;
1299
1300   // redraw if position or size of door area has changed
1301   if (dx_last != DX || dy_last != DY ||
1302       dxsize_last != DXSIZE || dysize_last != DYSIZE)
1303     return TRUE;
1304
1305   // redraw if position or size of tape area has changed
1306   if (vx_last != VX || vy_last != VY ||
1307       vxsize_last != VXSIZE || vysize_last != VYSIZE)
1308     return TRUE;
1309
1310   // redraw if position or size of editor area has changed
1311   if (ex_last != EX || ey_last != EY ||
1312       exsize_last != EXSIZE || eysize_last != EYSIZE)
1313     return TRUE;
1314
1315   return FALSE;
1316 }
1317 #endif
1318
1319 static void RedrawGlobalBorderFromBitmap(Bitmap *bitmap)
1320 {
1321   if (bitmap)
1322     BlitBitmap(bitmap, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1323   else
1324     ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
1325 }
1326
1327 void RedrawGlobalBorder(void)
1328 {
1329   Bitmap *bitmap = getGlobalBorderBitmapFromStatus(game_status);
1330
1331   RedrawGlobalBorderFromBitmap(bitmap);
1332
1333   redraw_mask = REDRAW_ALL;
1334 }
1335
1336 static void RedrawGlobalBorderIfNeeded(void)
1337 {
1338 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1339   if (game_status == game_status_last)
1340     return;
1341 #endif
1342
1343   // copy current draw buffer to later copy back areas that have not changed
1344   if (game_status_last != GAME_MODE_TITLE)
1345     BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1346
1347 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1348   if (CheckIfGlobalBorderRedrawIsNeeded())
1349 #else
1350   // determine and store new global border bitmap for current game status
1351   global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
1352 #endif
1353   {
1354     // redraw global screen border (or clear, if defined to be empty)
1355     RedrawGlobalBorderFromBitmap(global_border_bitmap);
1356
1357     if (game_status == GAME_MODE_EDITOR)
1358       DrawSpecialEditorDoor();
1359
1360     // copy previous playfield and door areas, if they are defined on both
1361     // previous and current screen and if they still have the same size
1362
1363     if (real_sx_last != -1 && real_sy_last != -1 &&
1364         REAL_SX != -1 && REAL_SY != -1 &&
1365         full_sxsize_last == FULL_SXSIZE && full_sysize_last == FULL_SYSIZE)
1366       BlitBitmap(bitmap_db_store_1, backbuffer,
1367                  real_sx_last, real_sy_last, FULL_SXSIZE, FULL_SYSIZE,
1368                  REAL_SX, REAL_SY);
1369
1370     if (dx_last != -1 && dy_last != -1 &&
1371         DX != -1 && DY != -1 &&
1372         dxsize_last == DXSIZE && dysize_last == DYSIZE)
1373       BlitBitmap(bitmap_db_store_1, backbuffer,
1374                  dx_last, dy_last, DXSIZE, DYSIZE, DX, DY);
1375
1376     if (game_status != GAME_MODE_EDITOR)
1377     {
1378       if (vx_last != -1 && vy_last != -1 &&
1379           VX != -1 && VY != -1 &&
1380           vxsize_last == VXSIZE && vysize_last == VYSIZE)
1381         BlitBitmap(bitmap_db_store_1, backbuffer,
1382                    vx_last, vy_last, VXSIZE, VYSIZE, VX, VY);
1383     }
1384     else
1385     {
1386       if (ex_last != -1 && ey_last != -1 &&
1387           EX != -1 && EY != -1 &&
1388           exsize_last == EXSIZE && eysize_last == EYSIZE)
1389         BlitBitmap(bitmap_db_store_1, backbuffer,
1390                    ex_last, ey_last, EXSIZE, EYSIZE, EX, EY);
1391     }
1392
1393     redraw_mask = REDRAW_ALL;
1394   }
1395
1396   game_status_last = game_status;
1397
1398   global_border_bitmap_last = global_border_bitmap;
1399
1400   real_sx_last = REAL_SX;
1401   real_sy_last = REAL_SY;
1402   full_sxsize_last = FULL_SXSIZE;
1403   full_sysize_last = FULL_SYSIZE;
1404   dx_last = DX;
1405   dy_last = DY;
1406   dxsize_last = DXSIZE;
1407   dysize_last = DYSIZE;
1408   vx_last = VX;
1409   vy_last = VY;
1410   vxsize_last = VXSIZE;
1411   vysize_last = VYSIZE;
1412   ex_last = EX;
1413   ey_last = EY;
1414   exsize_last = EXSIZE;
1415   eysize_last = EYSIZE;
1416 }
1417
1418 void ClearField(void)
1419 {
1420   RedrawGlobalBorderIfNeeded();
1421
1422   // !!! "drawto" might still point to playfield buffer here (see above) !!!
1423   // (when entering hall of fame after playing)
1424   DrawBackground(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
1425
1426   // !!! maybe this should be done before clearing the background !!!
1427   if (game_status == GAME_MODE_PLAYING)
1428   {
1429     ClearRectangle(fieldbuffer, 0, 0, FXSIZE, FYSIZE);
1430     SetDrawtoField(DRAW_TO_FIELDBUFFER);
1431   }
1432   else
1433   {
1434     SetDrawtoField(DRAW_TO_BACKBUFFER);
1435   }
1436 }
1437
1438 void MarkTileDirty(int x, int y)
1439 {
1440   redraw_mask |= REDRAW_FIELD;
1441 }
1442
1443 void SetBorderElement(void)
1444 {
1445   int x, y;
1446
1447   BorderElement = EL_EMPTY;
1448
1449   // only the R'n'D game engine may use an additional steelwall border
1450   if (level.game_engine_type != GAME_ENGINE_TYPE_RND)
1451     return;
1452
1453   for (y = 0; y < lev_fieldy && BorderElement == EL_EMPTY; y++)
1454   {
1455     for (x = 0; x < lev_fieldx; x++)
1456     {
1457       if (!IS_INDESTRUCTIBLE(Tile[x][y]))
1458         BorderElement = EL_STEELWALL;
1459
1460       if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
1461         x = lev_fieldx - 2;
1462     }
1463   }
1464 }
1465
1466 void FloodFillLevelExt(int start_x, int start_y, int fill_element,
1467                        int max_array_fieldx, int max_array_fieldy,
1468                        short field[max_array_fieldx][max_array_fieldy],
1469                        int max_fieldx, int max_fieldy)
1470 {
1471   static struct XY stack_buffer[MAX_LEV_FIELDX * MAX_LEV_FIELDY];
1472   struct XY *check = xy_topdown;
1473   int old_element = field[start_x][start_y];
1474   int stack_pos = 0;
1475
1476   // do nothing if start field already has the desired content
1477   if (old_element == fill_element)
1478     return;
1479
1480   stack_buffer[stack_pos++] = (struct XY){ start_x, start_y };
1481
1482   while (stack_pos > 0)
1483   {
1484     struct XY current = stack_buffer[--stack_pos];
1485     int i;
1486
1487     field[current.x][current.y] = fill_element;
1488
1489     for (i = 0; i < 4; i++)
1490     {
1491       int x = current.x + check[i].x;
1492       int y = current.y + check[i].y;
1493
1494       // check for stack buffer overflow (should not happen)
1495       if (stack_pos >= MAX_LEV_FIELDX * MAX_LEV_FIELDY)
1496         Fail("Stack buffer overflow in 'FloodFillLevelExt()'. Please debug.");
1497
1498       if (IN_FIELD(x, y, max_fieldx, max_fieldy) && field[x][y] == old_element)
1499         stack_buffer[stack_pos++] = (struct XY){ x, y };
1500     }
1501   }
1502 }
1503
1504 void FloodFillLevel(int from_x, int from_y, int fill_element,
1505                     short field[MAX_LEV_FIELDX][MAX_LEV_FIELDY],
1506                     int max_fieldx, int max_fieldy)
1507 {
1508   FloodFillLevelExt(from_x, from_y, fill_element,
1509                     MAX_LEV_FIELDX, MAX_LEV_FIELDY, field,
1510                     max_fieldx, max_fieldy);
1511 }
1512
1513 void SetRandomAnimationValue(int x, int y)
1514 {
1515   gfx.anim_random_frame = GfxRandom[x][y];
1516 }
1517
1518 int getGraphicAnimationFrame(int graphic, int sync_frame)
1519 {
1520   // animation synchronized with global frame counter, not move position
1521   if (graphic_info[graphic].anim_global_sync || sync_frame < 0)
1522     sync_frame = FrameCounter;
1523   else if (graphic_info[graphic].anim_global_anim_sync)
1524     sync_frame = getGlobalAnimSyncFrame();
1525
1526   return getAnimationFrame(graphic_info[graphic].anim_frames,
1527                            graphic_info[graphic].anim_delay,
1528                            graphic_info[graphic].anim_mode,
1529                            graphic_info[graphic].anim_start_frame,
1530                            sync_frame);
1531 }
1532
1533 int getGraphicAnimationFrameXY(int graphic, int lx, int ly)
1534 {
1535   if (graphic_info[graphic].anim_mode & ANIM_TILED)
1536   {
1537     struct GraphicInfo *g = &graphic_info[graphic];
1538     int xsize = MAX(1, g->anim_frames_per_line);
1539     int ysize = MAX(1, g->anim_frames / xsize);
1540     int xoffset = g->anim_start_frame % xsize;
1541     int yoffset = g->anim_start_frame % ysize;
1542     // may be needed if screen field is significantly larger than playfield
1543     int x = (lx + xoffset + SCR_FIELDX * xsize) % xsize;
1544     int y = (ly + yoffset + SCR_FIELDY * ysize) % ysize;
1545     int sync_frame = y * xsize + x;
1546
1547     return sync_frame % g->anim_frames;
1548   }
1549   else if (graphic_info[graphic].anim_mode & ANIM_RANDOM_STATIC)
1550   {
1551     struct GraphicInfo *g = &graphic_info[graphic];
1552     // may be needed if screen field is significantly larger than playfield
1553     int x = (lx + SCR_FIELDX * lev_fieldx) % lev_fieldx;
1554     int y = (ly + SCR_FIELDY * lev_fieldy) % lev_fieldy;
1555     int sync_frame = GfxRandomStatic[x][y];
1556
1557     return sync_frame % g->anim_frames;
1558   }
1559   else
1560   {
1561     int sync_frame = (IN_LEV_FIELD(lx, ly) ? GfxFrame[lx][ly] : -1);
1562
1563     return getGraphicAnimationFrame(graphic, sync_frame);
1564   }
1565 }
1566
1567 void getGraphicSourceBitmap(int graphic, int tilesize, Bitmap **bitmap)
1568 {
1569   struct GraphicInfo *g = &graphic_info[graphic];
1570   int tilesize_capped = MIN(MAX(1, tilesize), TILESIZE);
1571
1572   if (tilesize == gfx.standard_tile_size)
1573     *bitmap = g->bitmaps[IMG_BITMAP_STANDARD];
1574   else if (tilesize == game.tile_size)
1575     *bitmap = g->bitmaps[IMG_BITMAP_PTR_GAME];
1576   else
1577     *bitmap = g->bitmaps[IMG_BITMAP_1x1 - log_2(tilesize_capped)];
1578 }
1579
1580 void getGraphicSourceXY(int graphic, int frame, int *x, int *y,
1581                         boolean get_backside)
1582 {
1583   struct GraphicInfo *g = &graphic_info[graphic];
1584   int src_x = g->src_x + (get_backside ? g->offset2_x : 0);
1585   int src_y = g->src_y + (get_backside ? g->offset2_y : 0);
1586
1587   if (g->offset_y == 0)         // frames are ordered horizontally
1588   {
1589     int max_width = g->anim_frames_per_line * g->width;
1590     int pos = (src_y / g->height) * max_width + src_x + frame * g->offset_x;
1591
1592     *x = pos % max_width;
1593     *y = src_y % g->height + pos / max_width * g->height;
1594   }
1595   else if (g->offset_x == 0)    // frames are ordered vertically
1596   {
1597     int max_height = g->anim_frames_per_line * g->height;
1598     int pos = (src_x / g->width) * max_height + src_y + frame * g->offset_y;
1599
1600     *x = src_x % g->width + pos / max_height * g->width;
1601     *y = pos % max_height;
1602   }
1603   else                          // frames are ordered diagonally
1604   {
1605     *x = src_x + frame * g->offset_x;
1606     *y = src_y + frame * g->offset_y;
1607   }
1608 }
1609
1610 void getSizedGraphicSourceExt(int graphic, int frame, int tilesize,
1611                               Bitmap **bitmap, int *x, int *y,
1612                               boolean get_backside)
1613 {
1614   struct GraphicInfo *g = &graphic_info[graphic];
1615
1616   // if no graphics defined at all, use fallback graphics
1617   if (g->bitmaps == NULL)
1618     *g = graphic_info[IMG_CHAR_EXCLAM];
1619
1620   // if no in-game graphics defined, always use standard graphic size
1621   if (g->bitmaps[IMG_BITMAP_PTR_GAME] == NULL)
1622     tilesize = TILESIZE;
1623
1624   getGraphicSourceBitmap(graphic, tilesize, bitmap);
1625   getGraphicSourceXY(graphic, frame, x, y, get_backside);
1626
1627   *x = *x * tilesize / g->tile_size;
1628   *y = *y * tilesize / g->tile_size;
1629 }
1630
1631 void getSizedGraphicSource(int graphic, int frame, int tilesize,
1632                            Bitmap **bitmap, int *x, int *y)
1633 {
1634   getSizedGraphicSourceExt(graphic, frame, tilesize, bitmap, x, y, FALSE);
1635 }
1636
1637 void getFixedGraphicSource(int graphic, int frame,
1638                            Bitmap **bitmap, int *x, int *y)
1639 {
1640   getSizedGraphicSourceExt(graphic, frame, TILESIZE, bitmap, x, y, FALSE);
1641 }
1642
1643 void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
1644 {
1645   getSizedGraphicSource(graphic, 0, MINI_TILESIZE, bitmap, x, y);
1646 }
1647
1648 void getGlobalAnimGraphicSource(int graphic, int frame,
1649                                 Bitmap **bitmap, int *x, int *y)
1650 {
1651   struct GraphicInfo *g = &graphic_info[graphic];
1652
1653   // if no graphics defined at all, use fallback graphics
1654   if (g->bitmaps == NULL)
1655     *g = graphic_info[IMG_CHAR_EXCLAM];
1656
1657   // use original size graphics, if existing, else use standard size graphics
1658   if (g->bitmaps[IMG_BITMAP_PTR_ORIGINAL])
1659     *bitmap = g->bitmaps[IMG_BITMAP_PTR_ORIGINAL];
1660   else
1661     *bitmap = g->bitmaps[IMG_BITMAP_STANDARD];
1662
1663   getGraphicSourceXY(graphic, frame, x, y, FALSE);
1664 }
1665
1666 static void getGraphicSourceExt(int graphic, int frame, Bitmap **bitmap,
1667                                 int *x, int *y, boolean get_backside)
1668 {
1669   getSizedGraphicSourceExt(graphic, frame, TILESIZE_VAR, bitmap, x, y,
1670                            get_backside);
1671 }
1672
1673 void getGraphicSource(int graphic, int frame, Bitmap **bitmap, int *x, int *y)
1674 {
1675   getGraphicSourceExt(graphic, frame, bitmap, x, y, FALSE);
1676 }
1677
1678 void DrawGraphic(int x, int y, int graphic, int frame)
1679 {
1680 #if DEBUG
1681   if (!IN_SCR_FIELD(x, y))
1682   {
1683     Debug("draw:DrawGraphic", "x = %d, y = %d, graphic = %d", x, y, graphic);
1684     Debug("draw:DrawGraphic", "This should never happen!");
1685
1686     return;
1687   }
1688 #endif
1689
1690   DrawGraphicExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR, graphic,
1691                  frame);
1692
1693   MarkTileDirty(x, y);
1694 }
1695
1696 void DrawFixedGraphic(int x, int y, int graphic, int frame)
1697 {
1698 #if DEBUG
1699   if (!IN_SCR_FIELD(x, y))
1700   {
1701     Debug("draw:DrawFixedGraphic", "x = %d, y = %d, graphic = %d",
1702           x, y, graphic);
1703     Debug("draw:DrawFixedGraphic", "This should never happen!");
1704
1705     return;
1706   }
1707 #endif
1708
1709   DrawFixedGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic,
1710                       frame);
1711   MarkTileDirty(x, y);
1712 }
1713
1714 void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1715                     int frame)
1716 {
1717   Bitmap *src_bitmap;
1718   int src_x, src_y;
1719
1720   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1721
1722   BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX_VAR, TILEY_VAR, x, y);
1723 }
1724
1725 void DrawFixedGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1726                          int frame)
1727 {
1728   Bitmap *src_bitmap;
1729   int src_x, src_y;
1730
1731   getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1732   BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
1733 }
1734
1735 void DrawGraphicThruMask(int x, int y, int graphic, int frame)
1736 {
1737 #if DEBUG
1738   if (!IN_SCR_FIELD(x, y))
1739   {
1740     Debug("draw:DrawGraphicThruMask", "x = %d, y = %d, graphic = %d",
1741           x, y, graphic);
1742     Debug("draw:DrawGraphicThruMask", "This should never happen!");
1743
1744     return;
1745   }
1746 #endif
1747
1748   DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
1749                          graphic, frame);
1750
1751   MarkTileDirty(x, y);
1752 }
1753
1754 void DrawFixedGraphicThruMask(int x, int y, int graphic, int frame)
1755 {
1756 #if DEBUG
1757   if (!IN_SCR_FIELD(x, y))
1758   {
1759     Debug("draw:DrawFixedGraphicThruMask", "x = %d, y = %d, graphic = %d",
1760           x, y, graphic);
1761     Debug("draw:DrawFixedGraphicThruMask", "This should never happen!");
1762
1763     return;
1764   }
1765 #endif
1766
1767   DrawFixedGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
1768                               graphic, frame);
1769   MarkTileDirty(x, y);
1770 }
1771
1772 void DrawGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y, int graphic,
1773                             int frame)
1774 {
1775   Bitmap *src_bitmap;
1776   int src_x, src_y;
1777
1778   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1779
1780   BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX_VAR, TILEY_VAR,
1781                    dst_x, dst_y);
1782 }
1783
1784 void DrawFixedGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y,
1785                                  int graphic, int frame)
1786 {
1787   Bitmap *src_bitmap;
1788   int src_x, src_y;
1789
1790   getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1791
1792   BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY,
1793                    dst_x, dst_y);
1794 }
1795
1796 void DrawSizedGraphic(int x, int y, int graphic, int frame, int tilesize)
1797 {
1798   DrawSizedGraphicExt(drawto, SX + x * tilesize, SY + y * tilesize, graphic,
1799                       frame, tilesize);
1800   MarkTileDirty(x / tilesize, y / tilesize);
1801 }
1802
1803 void DrawSizedGraphicThruMask(int x, int y, int graphic, int frame,
1804                               int tilesize)
1805 {
1806   DrawSizedGraphicThruMaskExt(drawto, SX + x * tilesize, SY + y * tilesize,
1807                               graphic, frame, tilesize);
1808   MarkTileDirty(x / tilesize, y / tilesize);
1809 }
1810
1811 void DrawSizedGraphicExt(DrawBuffer *d, int x, int y, int graphic, int frame,
1812                          int tilesize)
1813 {
1814   Bitmap *src_bitmap;
1815   int src_x, src_y;
1816
1817   getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1818   BlitBitmap(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1819 }
1820
1821 void DrawSizedGraphicThruMaskExt(DrawBuffer *d, int x, int y, int graphic,
1822                                  int frame, int tilesize)
1823 {
1824   Bitmap *src_bitmap;
1825   int src_x, src_y;
1826
1827   getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1828   BlitBitmapMasked(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1829 }
1830
1831 void DrawMiniGraphic(int x, int y, int graphic)
1832 {
1833   DrawMiniGraphicExt(drawto, SX + x * MINI_TILEX, SY + y * MINI_TILEY, graphic);
1834   MarkTileDirty(x / 2, y / 2);
1835 }
1836
1837 void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
1838 {
1839   Bitmap *src_bitmap;
1840   int src_x, src_y;
1841
1842   getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
1843   BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
1844 }
1845
1846 static void DrawGraphicShiftedNormal(int x, int y, int dx, int dy,
1847                                      int graphic, int frame,
1848                                      int cut_mode, int mask_mode)
1849 {
1850   Bitmap *src_bitmap;
1851   int src_x, src_y;
1852   int dst_x, dst_y;
1853   int width = TILEX, height = TILEY;
1854   int cx = 0, cy = 0;
1855
1856   if (dx || dy)                 // shifted graphic
1857   {
1858     if (x < BX1)                // object enters playfield from the left
1859     {
1860       x = BX1;
1861       width = dx;
1862       cx = TILEX - dx;
1863       dx = 0;
1864     }
1865     else if (x > BX2)           // object enters playfield from the right
1866     {
1867       x = BX2;
1868       width = -dx;
1869       dx = TILEX + dx;
1870     }
1871     else if (x == BX1 && dx < 0) // object leaves playfield to the left
1872     {
1873       width += dx;
1874       cx = -dx;
1875       dx = 0;
1876     }
1877     else if (x == BX2 && dx > 0) // object leaves playfield to the right
1878       width -= dx;
1879     else if (dx)                // general horizontal movement
1880       MarkTileDirty(x + SIGN(dx), y);
1881
1882     if (y < BY1)                // object enters playfield from the top
1883     {
1884       if (cut_mode == CUT_BELOW) // object completely above top border
1885         return;
1886
1887       y = BY1;
1888       height = dy;
1889       cy = TILEY - dy;
1890       dy = 0;
1891     }
1892     else if (y > BY2)           // object enters playfield from the bottom
1893     {
1894       y = BY2;
1895       height = -dy;
1896       dy = TILEY + dy;
1897     }
1898     else if (y == BY1 && dy < 0) // object leaves playfield to the top
1899     {
1900       height += dy;
1901       cy = -dy;
1902       dy = 0;
1903     }
1904     else if (dy > 0 && cut_mode == CUT_ABOVE)
1905     {
1906       if (y == BY2)             // object completely above bottom border
1907         return;
1908
1909       height = dy;
1910       cy = TILEY - dy;
1911       dy = TILEY;
1912       MarkTileDirty(x, y + 1);
1913     }                           // object leaves playfield to the bottom
1914     else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
1915       height -= dy;
1916     else if (dy)                // general vertical movement
1917       MarkTileDirty(x, y + SIGN(dy));
1918   }
1919
1920 #if DEBUG
1921   if (!IN_SCR_FIELD(x, y))
1922   {
1923     Debug("draw:DrawGraphicShiftedNormal", "x = %d, y = %d, graphic = %d",
1924           x, y, graphic);
1925     Debug("draw:DrawGraphicShiftedNormal", "This should never happen!");
1926
1927     return;
1928   }
1929 #endif
1930
1931   width = width * TILESIZE_VAR / TILESIZE;
1932   height = height * TILESIZE_VAR / TILESIZE;
1933   cx = cx * TILESIZE_VAR / TILESIZE;
1934   cy = cy * TILESIZE_VAR / TILESIZE;
1935   dx = dx * TILESIZE_VAR / TILESIZE;
1936   dy = dy * TILESIZE_VAR / TILESIZE;
1937
1938   if (width > 0 && height > 0)
1939   {
1940     getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1941
1942     src_x += cx;
1943     src_y += cy;
1944
1945     dst_x = FX + x * TILEX_VAR + dx;
1946     dst_y = FY + y * TILEY_VAR + dy;
1947
1948     if (mask_mode == USE_MASKING)
1949       BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1950                        dst_x, dst_y);
1951     else
1952       BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1953                  dst_x, dst_y);
1954
1955     MarkTileDirty(x, y);
1956   }
1957 }
1958
1959 static void DrawGraphicShiftedDouble(int x, int y, int dx, int dy,
1960                                      int graphic, int frame,
1961                                      int cut_mode, int mask_mode)
1962 {
1963   Bitmap *src_bitmap;
1964   int src_x, src_y;
1965   int dst_x, dst_y;
1966   int width = TILEX_VAR, height = TILEY_VAR;
1967   int x1 = x;
1968   int y1 = y;
1969   int x2 = x + SIGN(dx);
1970   int y2 = y + SIGN(dy);
1971
1972   // movement with two-tile animations must be sync'ed with movement position,
1973   // not with current GfxFrame (which can be higher when using slow movement)
1974   int anim_pos = (dx ? ABS(dx) : ABS(dy));
1975   int anim_frames = graphic_info[graphic].anim_frames;
1976
1977   // (we also need anim_delay here for movement animations with less frames)
1978   int anim_delay = graphic_info[graphic].anim_delay;
1979   int sync_frame = anim_pos * anim_frames * anim_delay / TILESIZE;
1980
1981   boolean draw_start_tile = (cut_mode != CUT_ABOVE);    // only for falling!
1982   boolean draw_end_tile   = (cut_mode != CUT_BELOW);    // only for falling!
1983
1984   // re-calculate animation frame for two-tile movement animation
1985   frame = getGraphicAnimationFrame(graphic, sync_frame);
1986
1987   // check if movement start graphic inside screen area and should be drawn
1988   if (draw_start_tile && IN_SCR_FIELD(x1, y1))
1989   {
1990     getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, TRUE);
1991
1992     dst_x = FX + x1 * TILEX_VAR;
1993     dst_y = FY + y1 * TILEY_VAR;
1994
1995     if (mask_mode == USE_MASKING)
1996       BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1997                        dst_x, dst_y);
1998     else
1999       BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
2000                  dst_x, dst_y);
2001
2002     MarkTileDirty(x1, y1);
2003   }
2004
2005   // check if movement end graphic inside screen area and should be drawn
2006   if (draw_end_tile && IN_SCR_FIELD(x2, y2))
2007   {
2008     getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
2009
2010     dst_x = FX + x2 * TILEX_VAR;
2011     dst_y = FY + y2 * TILEY_VAR;
2012
2013     if (mask_mode == USE_MASKING)
2014       BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
2015                        dst_x, dst_y);
2016     else
2017       BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
2018                  dst_x, dst_y);
2019
2020     MarkTileDirty(x2, y2);
2021   }
2022 }
2023
2024 static void DrawGraphicShifted(int x, int y, int dx, int dy,
2025                                int graphic, int frame,
2026                                int cut_mode, int mask_mode)
2027 {
2028   if (graphic < 0)
2029   {
2030     DrawGraphic(x, y, graphic, frame);
2031
2032     return;
2033   }
2034
2035   if (graphic_info[graphic].double_movement)    // EM style movement images
2036     DrawGraphicShiftedDouble(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
2037   else
2038     DrawGraphicShiftedNormal(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
2039 }
2040
2041 static void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy,
2042                                        int graphic, int frame, int cut_mode)
2043 {
2044   DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, USE_MASKING);
2045 }
2046
2047 void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
2048                           int cut_mode, int mask_mode)
2049 {
2050   int lx = LEVELX(x), ly = LEVELY(y);
2051   int graphic;
2052   int frame;
2053
2054   if (IN_LEV_FIELD(lx, ly))
2055   {
2056     if (element == EL_EMPTY)
2057       element = GfxElementEmpty[lx][ly];
2058
2059     SetRandomAnimationValue(lx, ly);
2060
2061     graphic = el_act_dir2img(element, GfxAction[lx][ly], GfxDir[lx][ly]);
2062     frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2063
2064     // do not use double (EM style) movement graphic when not moving
2065     if (graphic_info[graphic].double_movement && !dx && !dy)
2066     {
2067       graphic = el_act_dir2img(element, ACTION_DEFAULT, GfxDir[lx][ly]);
2068       frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2069     }
2070
2071     if (game.use_masked_elements && (dx || dy))
2072       mask_mode = USE_MASKING;
2073   }
2074   else  // border element
2075   {
2076     graphic = el2img(element);
2077     frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2078   }
2079
2080   if (element == EL_EXPANDABLE_WALL)
2081   {
2082     boolean left_stopped = FALSE, right_stopped = FALSE;
2083
2084     if (!IN_LEV_FIELD(lx - 1, ly) || IS_WALL(Tile[lx - 1][ly]))
2085       left_stopped = TRUE;
2086     if (!IN_LEV_FIELD(lx + 1, ly) || IS_WALL(Tile[lx + 1][ly]))
2087       right_stopped = TRUE;
2088
2089     if (left_stopped && right_stopped)
2090       graphic = IMG_WALL;
2091     else if (left_stopped)
2092     {
2093       graphic = IMG_EXPANDABLE_WALL_GROWING_RIGHT;
2094       frame = graphic_info[graphic].anim_frames - 1;
2095     }
2096     else if (right_stopped)
2097     {
2098       graphic = IMG_EXPANDABLE_WALL_GROWING_LEFT;
2099       frame = graphic_info[graphic].anim_frames - 1;
2100     }
2101   }
2102
2103   if (dx || dy)
2104     DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
2105   else if (mask_mode == USE_MASKING)
2106     DrawGraphicThruMask(x, y, graphic, frame);
2107   else
2108     DrawGraphic(x, y, graphic, frame);
2109 }
2110
2111 void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
2112                          int cut_mode, int mask_mode)
2113 {
2114   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2115     DrawScreenElementExt(SCREENX(x), SCREENY(y), dx, dy, element,
2116                          cut_mode, mask_mode);
2117 }
2118
2119 void DrawScreenElementShifted(int x, int y, int dx, int dy, int element,
2120                               int cut_mode)
2121 {
2122   DrawScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
2123 }
2124
2125 void DrawLevelElementShifted(int x, int y, int dx, int dy, int element,
2126                              int cut_mode)
2127 {
2128   DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
2129 }
2130
2131 void DrawLevelElementThruMask(int x, int y, int element)
2132 {
2133   DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
2134 }
2135
2136 void DrawLevelFieldThruMask(int x, int y)
2137 {
2138   DrawLevelElementExt(x, y, 0, 0, Tile[x][y], NO_CUTTING, USE_MASKING);
2139 }
2140
2141 // !!! implementation of quicksand is totally broken !!!
2142 #define IS_CRUMBLED_TILE(x, y, e)                                       \
2143         (GFX_CRUMBLED(e) && (!IN_LEV_FIELD(x, y) ||                     \
2144                              !IS_MOVING(x, y) ||                        \
2145                              (e) == EL_QUICKSAND_EMPTYING ||            \
2146                              (e) == EL_QUICKSAND_FAST_EMPTYING))
2147
2148 static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy,
2149                                                int graphic)
2150 {
2151   Bitmap *src_bitmap;
2152   int src_x, src_y;
2153   int width, height, cx, cy;
2154   int sx = SCREENX(x), sy = SCREENY(y);
2155   int crumbled_border_size = graphic_info[graphic].border_size;
2156   int crumbled_tile_size = graphic_info[graphic].tile_size;
2157   int crumbled_border_size_var =
2158     crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
2159   int i;
2160
2161   getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2162
2163   for (i = 1; i < 4; i++)
2164   {
2165     int dxx = (i & 1 ? dx : 0);
2166     int dyy = (i & 2 ? dy : 0);
2167     int xx = x + dxx;
2168     int yy = y + dyy;
2169     int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2170                    BorderElement);
2171
2172     // check if neighbour field is of same crumble type
2173     boolean same = (IS_CRUMBLED_TILE(xx, yy, element) &&
2174                     graphic_info[graphic].class ==
2175                     graphic_info[el_act2crm(element, ACTION_DEFAULT)].class);
2176
2177     // return if check prevents inner corner
2178     if (same == (dxx == dx && dyy == dy))
2179       return;
2180   }
2181
2182   // if we reach this point, we have an inner corner
2183
2184   getGraphicSource(graphic, 1, &src_bitmap, &src_x, &src_y);
2185
2186   width  = crumbled_border_size_var;
2187   height = crumbled_border_size_var;
2188   cx = (dx > 0 ? TILESIZE_VAR - width  : 0);
2189   cy = (dy > 0 ? TILESIZE_VAR - height : 0);
2190
2191   if (game.use_masked_elements)
2192   {
2193     int graphic0 = el2img(EL_EMPTY);
2194     int frame0 = getGraphicAnimationFrameXY(graphic0, x, y);
2195     Bitmap *src_bitmap0;
2196     int src_x0, src_y0;
2197
2198     getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
2199
2200     BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
2201                width, height,
2202                FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2203
2204     BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2205                      width, height,
2206                      FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2207   }
2208   else
2209     BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2210                width, height,
2211                FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2212 }
2213
2214 static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
2215                                           int dir)
2216 {
2217   Bitmap *src_bitmap;
2218   int src_x, src_y;
2219   int width, height, bx, by, cx, cy;
2220   int sx = SCREENX(x), sy = SCREENY(y);
2221   int crumbled_border_size = graphic_info[graphic].border_size;
2222   int crumbled_tile_size = graphic_info[graphic].tile_size;
2223   int crumbled_border_size_var =
2224     crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
2225   int crumbled_border_pos_var = TILESIZE_VAR - crumbled_border_size_var;
2226   int i;
2227
2228   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2229
2230   // only needed when using masked elements
2231   int graphic0 = el2img(EL_EMPTY);
2232   int frame0 = getGraphicAnimationFrameXY(graphic0, x, y);
2233   Bitmap *src_bitmap0;
2234   int src_x0, src_y0;
2235
2236   if (game.use_masked_elements)
2237     getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
2238
2239   // draw simple, sloppy, non-corner-accurate crumbled border
2240
2241   width  = (dir == 1 || dir == 2 ? crumbled_border_size_var : TILESIZE_VAR);
2242   height = (dir == 0 || dir == 3 ? crumbled_border_size_var : TILESIZE_VAR);
2243   cx = (dir == 2 ? crumbled_border_pos_var : 0);
2244   cy = (dir == 3 ? crumbled_border_pos_var : 0);
2245
2246   if (game.use_masked_elements)
2247   {
2248     BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
2249                width, height,
2250                FX + sx * TILEX_VAR + cx,
2251                FY + sy * TILEY_VAR + cy);
2252
2253     BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2254                      width, height,
2255                      FX + sx * TILEX_VAR + cx,
2256                      FY + sy * TILEY_VAR + cy);
2257   }
2258   else
2259     BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2260                width, height,
2261                FX + sx * TILEX_VAR + cx,
2262                FY + sy * TILEY_VAR + cy);
2263
2264   // (remaining middle border part must be at least as big as corner part)
2265   if (!(graphic_info[graphic].style & STYLE_ACCURATE_BORDERS) ||
2266       crumbled_border_size_var >= TILESIZE_VAR / 3)
2267     return;
2268
2269   // correct corners of crumbled border, if needed
2270
2271   for (i = -1; i <= 1; i += 2)
2272   {
2273     int xx = x + (dir == 0 || dir == 3 ? i : 0);
2274     int yy = y + (dir == 1 || dir == 2 ? i : 0);
2275     int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2276                    BorderElement);
2277
2278     // check if neighbour field is of same crumble type
2279     if (IS_CRUMBLED_TILE(xx, yy, element) &&
2280         graphic_info[graphic].class ==
2281         graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2282     {
2283       // no crumbled corner, but continued crumbled border
2284
2285       int c1 = (dir == 2 || dir == 3 ? crumbled_border_pos_var : 0);
2286       int c2 = (i == 1 ? crumbled_border_pos_var : 0);
2287       int b1 = (i == 1 ? crumbled_border_size_var :
2288                 TILESIZE_VAR - 2 * crumbled_border_size_var);
2289
2290       width  = crumbled_border_size_var;
2291       height = crumbled_border_size_var;
2292
2293       if (dir == 1 || dir == 2)
2294       {
2295         cx = c1;
2296         cy = c2;
2297         bx = cx;
2298         by = b1;
2299       }
2300       else
2301       {
2302         cx = c2;
2303         cy = c1;
2304         bx = b1;
2305         by = cy;
2306       }
2307
2308       if (game.use_masked_elements)
2309       {
2310         BlitBitmap(src_bitmap0, drawto_field, src_x0 + bx, src_y0 + by,
2311                    width, height,
2312                    FX + sx * TILEX_VAR + cx,
2313                    FY + sy * TILEY_VAR + cy);
2314
2315         BlitBitmapMasked(src_bitmap, drawto_field, src_x + bx, src_y + by,
2316                          width, height,
2317                          FX + sx * TILEX_VAR + cx,
2318                          FY + sy * TILEY_VAR + cy);
2319       }
2320       else
2321         BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
2322                    width, height,
2323                    FX + sx * TILEX_VAR + cx,
2324                    FY + sy * TILEY_VAR + cy);
2325     }
2326   }
2327 }
2328
2329 static void DrawLevelFieldCrumbledExt(int x, int y, int graphic, int frame)
2330 {
2331   int sx = SCREENX(x), sy = SCREENY(y);
2332   int element;
2333   int i;
2334   struct XY *xy = xy_topdown;
2335
2336   if (!IN_LEV_FIELD(x, y))
2337     return;
2338
2339   element = TILE_GFX_ELEMENT(x, y);
2340
2341   if (IS_CRUMBLED_TILE(x, y, element))          // crumble field itself
2342   {
2343     if (!IN_SCR_FIELD(sx, sy))
2344       return;
2345
2346     // crumble field borders towards direct neighbour fields
2347     for (i = 0; i < 4; i++)
2348     {
2349       int xx = x + xy[i].x;
2350       int yy = y + xy[i].y;
2351
2352       element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2353                  BorderElement);
2354
2355       // check if neighbour field is of same crumble type
2356       if (IS_CRUMBLED_TILE(xx, yy, element) &&
2357           graphic_info[graphic].class ==
2358           graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2359         continue;
2360
2361       DrawLevelFieldCrumbledBorders(x, y, graphic, frame, i);
2362     }
2363
2364     // crumble inner field corners towards corner neighbour fields
2365     if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2366         graphic_info[graphic].anim_frames == 2)
2367     {
2368       for (i = 0; i < 4; i++)
2369       {
2370         int dx = (i & 1 ? +1 : -1);
2371         int dy = (i & 2 ? +1 : -1);
2372
2373         DrawLevelFieldCrumbledInnerCorners(x, y, dx, dy, graphic);
2374       }
2375     }
2376
2377     MarkTileDirty(sx, sy);
2378   }
2379   else          // center field is not crumbled -- crumble neighbour fields
2380   {
2381     // crumble field borders of direct neighbour fields
2382     for (i = 0; i < 4; i++)
2383     {
2384       int xx = x + xy[i].x;
2385       int yy = y + xy[i].y;
2386       int sxx = sx + xy[i].x;
2387       int syy = sy + xy[i].y;
2388
2389       if (!IN_LEV_FIELD(xx, yy) ||
2390           !IN_SCR_FIELD(sxx, syy))
2391         continue;
2392
2393       // do not crumble fields that are being digged or snapped
2394       if (Tile[xx][yy] == EL_EMPTY ||
2395           Tile[xx][yy] == EL_ELEMENT_SNAPPING)
2396         continue;
2397
2398       element = TILE_GFX_ELEMENT(xx, yy);
2399
2400       if (!IS_CRUMBLED_TILE(xx, yy, element))
2401         continue;
2402
2403       graphic = el_act2crm(element, ACTION_DEFAULT);
2404
2405       DrawLevelFieldCrumbledBorders(xx, yy, graphic, 0, 3 - i);
2406
2407       MarkTileDirty(sxx, syy);
2408     }
2409
2410     // crumble inner field corners of corner neighbour fields
2411     for (i = 0; i < 4; i++)
2412     {
2413       int dx = (i & 1 ? +1 : -1);
2414       int dy = (i & 2 ? +1 : -1);
2415       int xx = x + dx;
2416       int yy = y + dy;
2417       int sxx = sx + dx;
2418       int syy = sy + dy;
2419
2420       if (!IN_LEV_FIELD(xx, yy) ||
2421           !IN_SCR_FIELD(sxx, syy))
2422         continue;
2423
2424       if (Tile[xx][yy] == EL_ELEMENT_SNAPPING)
2425         continue;
2426
2427       element = TILE_GFX_ELEMENT(xx, yy);
2428
2429       if (!IS_CRUMBLED_TILE(xx, yy, element))
2430         continue;
2431
2432       graphic = el_act2crm(element, ACTION_DEFAULT);
2433
2434       if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2435           graphic_info[graphic].anim_frames == 2)
2436         DrawLevelFieldCrumbledInnerCorners(xx, yy, -dx, -dy, graphic);
2437
2438       MarkTileDirty(sxx, syy);
2439     }
2440   }
2441 }
2442
2443 void DrawLevelFieldCrumbled(int x, int y)
2444 {
2445   int graphic;
2446
2447   if (!IN_LEV_FIELD(x, y))
2448     return;
2449
2450   if (Tile[x][y] == EL_ELEMENT_SNAPPING &&
2451       GfxElement[x][y] != EL_UNDEFINED &&
2452       GFX_CRUMBLED(GfxElement[x][y]))
2453   {
2454     DrawLevelFieldCrumbledDigging(x, y, GfxDir[x][y], GfxFrame[x][y]);
2455
2456     return;
2457   }
2458
2459   graphic = el_act2crm(TILE_GFX_ELEMENT(x, y), ACTION_DEFAULT);
2460
2461   DrawLevelFieldCrumbledExt(x, y, graphic, 0);
2462 }
2463
2464 void DrawLevelFieldCrumbledDigging(int x, int y, int direction,
2465                                    int step_frame)
2466 {
2467   int graphic1 = el_act_dir2img(GfxElement[x][y], ACTION_DIGGING, direction);
2468   int graphic2 = el_act_dir2crm(GfxElement[x][y], ACTION_DIGGING, direction);
2469   int frame1 = getGraphicAnimationFrame(graphic1, step_frame);
2470   int frame2 = getGraphicAnimationFrame(graphic2, step_frame);
2471   int sx = SCREENX(x), sy = SCREENY(y);
2472
2473   DrawScreenGraphic(sx, sy, graphic1, frame1);
2474   DrawLevelFieldCrumbledExt(x, y, graphic2, frame2);
2475 }
2476
2477 void DrawLevelFieldCrumbledNeighbours(int x, int y)
2478 {
2479   int sx = SCREENX(x), sy = SCREENY(y);
2480   struct XY *xy = xy_topdown;
2481   int i;
2482
2483   // crumble direct neighbour fields (required for field borders)
2484   for (i = 0; i < 4; i++)
2485   {
2486     int xx = x + xy[i].x;
2487     int yy = y + xy[i].y;
2488     int sxx = sx + xy[i].x;
2489     int syy = sy + xy[i].y;
2490
2491     if (!IN_LEV_FIELD(xx, yy) ||
2492         !IN_SCR_FIELD(sxx, syy) ||
2493         !GFX_CRUMBLED(Tile[xx][yy]) ||
2494         IS_MOVING(xx, yy))
2495       continue;
2496
2497     DrawLevelField(xx, yy);
2498   }
2499
2500   // crumble corner neighbour fields (required for inner field corners)
2501   for (i = 0; i < 4; i++)
2502   {
2503     int dx = (i & 1 ? +1 : -1);
2504     int dy = (i & 2 ? +1 : -1);
2505     int xx = x + dx;
2506     int yy = y + dy;
2507     int sxx = sx + dx;
2508     int syy = sy + dy;
2509
2510     if (!IN_LEV_FIELD(xx, yy) ||
2511         !IN_SCR_FIELD(sxx, syy) ||
2512         !GFX_CRUMBLED(Tile[xx][yy]) ||
2513         IS_MOVING(xx, yy))
2514       continue;
2515
2516     int element = TILE_GFX_ELEMENT(xx, yy);
2517     int graphic = el_act2crm(element, ACTION_DEFAULT);
2518
2519     if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2520         graphic_info[graphic].anim_frames == 2)
2521       DrawLevelField(xx, yy);
2522   }
2523 }
2524
2525 static int getBorderElement(int x, int y)
2526 {
2527   int border[7][2] =
2528   {
2529     { EL_STEELWALL_TOPLEFT,             EL_INVISIBLE_STEELWALL_TOPLEFT     },
2530     { EL_STEELWALL_TOPRIGHT,            EL_INVISIBLE_STEELWALL_TOPRIGHT    },
2531     { EL_STEELWALL_BOTTOMLEFT,          EL_INVISIBLE_STEELWALL_BOTTOMLEFT  },
2532     { EL_STEELWALL_BOTTOMRIGHT,         EL_INVISIBLE_STEELWALL_BOTTOMRIGHT },
2533     { EL_STEELWALL_VERTICAL,            EL_INVISIBLE_STEELWALL_VERTICAL    },
2534     { EL_STEELWALL_HORIZONTAL,          EL_INVISIBLE_STEELWALL_HORIZONTAL  },
2535     { EL_STEELWALL,                     EL_INVISIBLE_STEELWALL             }
2536   };
2537   int steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
2538   int steel_position = (x == -1         && y == -1              ? 0 :
2539                         x == lev_fieldx && y == -1              ? 1 :
2540                         x == -1         && y == lev_fieldy      ? 2 :
2541                         x == lev_fieldx && y == lev_fieldy      ? 3 :
2542                         x == -1         || x == lev_fieldx      ? 4 :
2543                         y == -1         || y == lev_fieldy      ? 5 : 6);
2544
2545   return border[steel_position][steel_type];
2546 }
2547
2548 void DrawScreenGraphic(int x, int y, int graphic, int frame)
2549 {
2550   if (game.use_masked_elements)
2551   {
2552     if (graphic != el2img(EL_EMPTY))
2553       DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
2554
2555     DrawGraphicThruMask(x, y, graphic, frame);
2556   }
2557   else
2558   {
2559     DrawGraphic(x, y, graphic, frame);
2560   }
2561 }
2562
2563 void DrawLevelGraphic(int x, int y, int graphic, int frame)
2564 {
2565   DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
2566 }
2567
2568 void DrawScreenElement(int x, int y, int element)
2569 {
2570   int mask_mode = NO_MASKING;
2571
2572   if (game.use_masked_elements)
2573   {
2574     int lx = LEVELX(x), ly = LEVELY(y);
2575
2576     if (IN_LEV_FIELD(lx, ly) && element != EL_EMPTY)
2577     {
2578       DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
2579
2580       mask_mode = USE_MASKING;
2581     }
2582   }
2583
2584   DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, mask_mode);
2585   DrawLevelFieldCrumbled(LEVELX(x), LEVELY(y));
2586 }
2587
2588 void DrawLevelElement(int x, int y, int element)
2589 {
2590   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2591     DrawScreenElement(SCREENX(x), SCREENY(y), element);
2592 }
2593
2594 void DrawScreenField(int x, int y)
2595 {
2596   int lx = LEVELX(x), ly = LEVELY(y);
2597   int element, content;
2598
2599   if (!IN_LEV_FIELD(lx, ly))
2600   {
2601     if (lx < -1 || lx > lev_fieldx || ly < -1 || ly > lev_fieldy)
2602       element = EL_EMPTY;
2603     else
2604       element = getBorderElement(lx, ly);
2605
2606     DrawScreenElement(x, y, element);
2607
2608     return;
2609   }
2610
2611   element = Tile[lx][ly];
2612   content = Store[lx][ly];
2613
2614   if (IS_MOVING(lx, ly))
2615   {
2616     int horiz_move = (MovDir[lx][ly] == MV_LEFT || MovDir[lx][ly] == MV_RIGHT);
2617     boolean cut_mode = NO_CUTTING;
2618
2619     if (element == EL_QUICKSAND_EMPTYING ||
2620         element == EL_QUICKSAND_FAST_EMPTYING ||
2621         element == EL_MAGIC_WALL_EMPTYING ||
2622         element == EL_BD_MAGIC_WALL_EMPTYING ||
2623         element == EL_DC_MAGIC_WALL_EMPTYING ||
2624         element == EL_AMOEBA_DROPPING)
2625       cut_mode = CUT_ABOVE;
2626     else if (element == EL_QUICKSAND_FILLING ||
2627              element == EL_QUICKSAND_FAST_FILLING ||
2628              element == EL_MAGIC_WALL_FILLING ||
2629              element == EL_BD_MAGIC_WALL_FILLING ||
2630              element == EL_DC_MAGIC_WALL_FILLING)
2631       cut_mode = CUT_BELOW;
2632
2633     if (cut_mode == CUT_ABOVE)
2634       DrawScreenElement(x, y, element);
2635     else
2636       DrawScreenElement(x, y, EL_EMPTY);
2637
2638     if (cut_mode != CUT_BELOW && game.use_masked_elements)
2639     {
2640       int dir = MovDir[lx][ly];
2641       int newx = x + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2642       int newy = y + (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
2643
2644       if (IN_SCR_FIELD(newx, newy))
2645         DrawScreenElement(newx, newy, EL_EMPTY);
2646     }
2647
2648     if (horiz_move)
2649       DrawScreenElementShifted(x, y, MovPos[lx][ly], 0, element, NO_CUTTING);
2650     else if (cut_mode == NO_CUTTING)
2651       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
2652     else
2653     {
2654       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
2655
2656       if (cut_mode == CUT_BELOW &&
2657           IN_LEV_FIELD(lx, ly + 1) && IN_SCR_FIELD(x, y + 1))
2658         DrawLevelElement(lx, ly + 1, element);
2659     }
2660
2661     if (content == EL_ACID)
2662     {
2663       int dir = MovDir[lx][ly];
2664       int newlx = lx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2665       int newly = ly + (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
2666
2667       DrawLevelElementThruMask(newlx, newly, EL_ACID);
2668
2669       // prevent target field from being drawn again (but without masking)
2670       // (this would happen if target field is scanned after moving element)
2671       Stop[newlx][newly] = TRUE;
2672     }
2673   }
2674   else if (IS_BLOCKED(lx, ly))
2675   {
2676     int oldx, oldy;
2677     int sx, sy;
2678     int horiz_move;
2679     boolean cut_mode = NO_CUTTING;
2680     int element_old, content_old;
2681
2682     Blocked2Moving(lx, ly, &oldx, &oldy);
2683     sx = SCREENX(oldx);
2684     sy = SCREENY(oldy);
2685     horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
2686                   MovDir[oldx][oldy] == MV_RIGHT);
2687
2688     element_old = Tile[oldx][oldy];
2689     content_old = Store[oldx][oldy];
2690
2691     if (element_old == EL_QUICKSAND_EMPTYING ||
2692         element_old == EL_QUICKSAND_FAST_EMPTYING ||
2693         element_old == EL_MAGIC_WALL_EMPTYING ||
2694         element_old == EL_BD_MAGIC_WALL_EMPTYING ||
2695         element_old == EL_DC_MAGIC_WALL_EMPTYING ||
2696         element_old == EL_AMOEBA_DROPPING)
2697       cut_mode = CUT_ABOVE;
2698
2699     DrawScreenElement(x, y, EL_EMPTY);
2700
2701     if (horiz_move)
2702       DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
2703                                NO_CUTTING);
2704     else if (cut_mode == NO_CUTTING)
2705       DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old,
2706                                cut_mode);
2707     else
2708       DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old,
2709                                cut_mode);
2710   }
2711   else if (IS_DRAWABLE(element))
2712     DrawScreenElement(x, y, element);
2713   else
2714     DrawScreenElement(x, y, EL_EMPTY);
2715 }
2716
2717 void DrawLevelField(int x, int y)
2718 {
2719   if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2720     DrawScreenField(SCREENX(x), SCREENY(y));
2721   else if (IS_MOVING(x, y))
2722   {
2723     int newx, newy;
2724
2725     Moving2Blocked(x, y, &newx, &newy);
2726     if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
2727       DrawScreenField(SCREENX(newx), SCREENY(newy));
2728   }
2729   else if (IS_BLOCKED(x, y))
2730   {
2731     int oldx, oldy;
2732
2733     Blocked2Moving(x, y, &oldx, &oldy);
2734     if (IN_SCR_FIELD(SCREENX(oldx), SCREENY(oldy)))
2735       DrawScreenField(SCREENX(oldx), SCREENY(oldy));
2736   }
2737 }
2738
2739 static void DrawSizedWallExt_MM(int dst_x, int dst_y, int element, int tilesize,
2740                                 int (*el2img_function)(int), boolean masked,
2741                                 int element_bits_draw)
2742 {
2743   int element_base = map_mm_wall_element(element);
2744   int element_bits = (IS_DF_WALL(element) ?
2745                       element - EL_DF_WALL_START :
2746                       IS_MM_WALL(element) ?
2747                       element - EL_MM_WALL_START : EL_EMPTY) & 0x000f;
2748   int graphic = el2img_function(element_base);
2749   int tilesize_draw = tilesize / 2;
2750   Bitmap *src_bitmap;
2751   int src_x, src_y;
2752   int i;
2753
2754   getSizedGraphicSource(graphic, 0, tilesize_draw, &src_bitmap, &src_x, &src_y);
2755
2756   for (i = 0; i < 4; i++)
2757   {
2758     int dst_draw_x = dst_x + (i % 2) * tilesize_draw;
2759     int dst_draw_y = dst_y + (i / 2) * tilesize_draw;
2760
2761     if (!(element_bits_draw & (1 << i)))
2762       continue;
2763
2764     if (element_bits & (1 << i))
2765     {
2766       if (masked)
2767         BlitBitmapMasked(src_bitmap, drawto, src_x, src_y,
2768                          tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2769       else
2770         BlitBitmap(src_bitmap, drawto, src_x, src_y,
2771                    tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2772     }
2773     else
2774     {
2775       if (!masked)
2776         ClearRectangle(drawto, dst_draw_x, dst_draw_y,
2777                        tilesize_draw, tilesize_draw);
2778     }
2779   }
2780 }
2781
2782 void DrawSizedWallParts_MM(int x, int y, int element, int tilesize,
2783                            boolean masked, int element_bits_draw)
2784 {
2785   DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2786                       element, tilesize, el2edimg, masked, element_bits_draw);
2787 }
2788
2789 static void DrawSizedWall_MM(int dst_x, int dst_y, int element, int tilesize,
2790                              int (*el2img_function)(int))
2791 {
2792   DrawSizedWallExt_MM(dst_x, dst_y, element, tilesize, el2img_function, FALSE,
2793                       0x000f);
2794 }
2795
2796 static void DrawSizedElementExt(int x, int y, int element, int tilesize,
2797                                 boolean masked)
2798 {
2799   if (IS_MM_WALL(element))
2800   {
2801     DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2802                         element, tilesize, el2edimg, masked, 0x000f);
2803   }
2804   else
2805   {
2806     int graphic = el2edimg(element);
2807
2808     if (masked)
2809       DrawSizedGraphicThruMask(x, y, graphic, 0, tilesize);
2810     else
2811       DrawSizedGraphic(x, y, graphic, 0, tilesize);
2812   }
2813 }
2814
2815 void DrawSizedElement(int x, int y, int element, int tilesize)
2816 {
2817   DrawSizedElementExt(x, y, element, tilesize, FALSE);
2818 }
2819
2820 void DrawSizedElementThruMask(int x, int y, int element, int tilesize)
2821 {
2822   DrawSizedElementExt(x, y, element, tilesize, TRUE);
2823 }
2824
2825 void DrawMiniElement(int x, int y, int element)
2826 {
2827   int graphic;
2828
2829   graphic = el2edimg(element);
2830   DrawMiniGraphic(x, y, graphic);
2831 }
2832
2833 void DrawSizedElementOrWall(int sx, int sy, int scroll_x, int scroll_y,
2834                             int tilesize)
2835 {
2836   int x = sx + scroll_x, y = sy + scroll_y;
2837
2838   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2839     DrawSizedElement(sx, sy, EL_EMPTY, tilesize);
2840   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2841     DrawSizedElement(sx, sy, Tile[x][y], tilesize);
2842   else
2843     DrawSizedGraphic(sx, sy, el2edimg(getBorderElement(x, y)), 0, tilesize);
2844 }
2845
2846 void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
2847 {
2848   int x = sx + scroll_x, y = sy + scroll_y;
2849
2850   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2851     DrawMiniElement(sx, sy, EL_EMPTY);
2852   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2853     DrawMiniElement(sx, sy, Tile[x][y]);
2854   else
2855     DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
2856 }
2857
2858 static void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
2859                                         int x, int y, int xsize, int ysize,
2860                                         int tile_width, int tile_height)
2861 {
2862   Bitmap *src_bitmap;
2863   int src_x, src_y;
2864   int dst_x = startx + x * tile_width;
2865   int dst_y = starty + y * tile_height;
2866   int width  = graphic_info[graphic].width;
2867   int height = graphic_info[graphic].height;
2868   int inner_width_raw  = MAX(width  - 2 * tile_width,  tile_width);
2869   int inner_height_raw = MAX(height - 2 * tile_height, tile_height);
2870   int inner_width  = inner_width_raw  - (inner_width_raw  % tile_width);
2871   int inner_height = inner_height_raw - (inner_height_raw % tile_height);
2872   int inner_sx = (width  >= 3 * tile_width  ? tile_width  : 0);
2873   int inner_sy = (height >= 3 * tile_height ? tile_height : 0);
2874   boolean draw_masked = graphic_info[graphic].draw_masked;
2875
2876   getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2877
2878   if (src_bitmap == NULL || width < tile_width || height < tile_height)
2879   {
2880     ClearRectangle(drawto, dst_x, dst_y, tile_width, tile_height);
2881     return;
2882   }
2883
2884   src_x += (x == 0 ? 0 : x == xsize - 1 ? width  - tile_width  :
2885             inner_sx + (x - 1) * tile_width  % inner_width);
2886   src_y += (y == 0 ? 0 : y == ysize - 1 ? height - tile_height :
2887             inner_sy + (y - 1) * tile_height % inner_height);
2888
2889   if (draw_masked)
2890     BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2891                      dst_x, dst_y);
2892   else
2893     BlitBitmap(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2894                dst_x, dst_y);
2895 }
2896
2897 static void DrawEnvelopeBackground(int graphic, int startx, int starty,
2898                                    int x, int y, int xsize, int ysize,
2899                                    int font_nr)
2900 {
2901   int font_width  = getFontWidth(font_nr);
2902   int font_height = getFontHeight(font_nr);
2903
2904   DrawEnvelopeBackgroundTiles(graphic, startx, starty, x, y, xsize, ysize,
2905                               font_width, font_height);
2906 }
2907
2908 static void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
2909 {
2910   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2911   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
2912   int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
2913   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2914   boolean no_delay = (tape.warp_forward);
2915   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2916   int anim_delay_value = MAX(1, (no_delay ? 0 : frame_delay_value) / 2);
2917   DelayCounter anim_delay = { anim_delay_value };
2918   int font_nr = FONT_ENVELOPE_1 + envelope_nr;
2919   int font_width = getFontWidth(font_nr);
2920   int font_height = getFontHeight(font_nr);
2921   int max_xsize = level.envelope[envelope_nr].xsize;
2922   int max_ysize = level.envelope[envelope_nr].ysize;
2923   int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize : 0);
2924   int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize : 0);
2925   int xend = max_xsize;
2926   int yend = (anim_mode != ANIM_DEFAULT ? max_ysize : 0);
2927   int xstep = (xstart < xend ? 1 : 0);
2928   int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
2929   int start = 0;
2930   int end = MAX(xend - xstart, yend - ystart);
2931   int i;
2932
2933   for (i = start; i <= end; i++)
2934   {
2935     int last_frame = end;       // last frame of this "for" loop
2936     int x = xstart + i * xstep;
2937     int y = ystart + i * ystep;
2938     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
2939     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
2940     int sx = SX + (SXSIZE - xsize * font_width)  / 2;
2941     int sy = SY + (SYSIZE - ysize * font_height) / 2;
2942     int xx, yy;
2943
2944     SetDrawtoField(DRAW_TO_FIELDBUFFER);
2945
2946     BlitScreenToBitmap(backbuffer);
2947
2948     SetDrawtoField(DRAW_TO_BACKBUFFER);
2949
2950     for (yy = 0; yy < ysize; yy++)
2951       for (xx = 0; xx < xsize; xx++)
2952         DrawEnvelopeBackground(graphic, sx, sy, xx, yy, xsize, ysize, font_nr);
2953
2954     DrawTextArea(sx + font_width, sy + font_height,
2955                  level.envelope[envelope_nr].text, font_nr, max_xsize,
2956                  xsize - 2, ysize - 2, 0, mask_mode,
2957                  level.envelope[envelope_nr].autowrap,
2958                  level.envelope[envelope_nr].centered, FALSE);
2959
2960     redraw_mask |= REDRAW_FIELD;
2961     BackToFront();
2962
2963     SkipUntilDelayReached(&anim_delay, &i, last_frame);
2964   }
2965
2966   ClearAutoRepeatKeyEvents();
2967 }
2968
2969 void ShowEnvelope(int envelope_nr)
2970 {
2971   int element = EL_ENVELOPE_1 + envelope_nr;
2972   int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2973   int sound_opening = element_info[element].sound[ACTION_OPENING];
2974   int sound_closing = element_info[element].sound[ACTION_CLOSING];
2975   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2976   boolean no_delay = (tape.warp_forward);
2977   int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
2978   int wait_delay_value = (no_delay ? 0 : normal_delay_value);
2979   int anim_mode = graphic_info[graphic].anim_mode;
2980   int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
2981                         anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
2982   boolean overlay_enabled = GetOverlayEnabled();
2983
2984   game.envelope_active = TRUE;  // needed for RedrawPlayfield() events
2985
2986   SetOverlayEnabled(FALSE);
2987   UnmapAllGadgets();
2988
2989   PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
2990
2991   if (anim_mode == ANIM_DEFAULT)
2992     AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
2993
2994   AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
2995
2996   if (tape.playing)
2997     Delay_WithScreenUpdates(wait_delay_value);
2998   else
2999     WaitForEventToContinue();
3000
3001   RemapAllGadgets();
3002   SetOverlayEnabled(overlay_enabled);
3003
3004   PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
3005
3006   if (anim_mode != ANIM_NONE)
3007     AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
3008
3009   if (anim_mode == ANIM_DEFAULT)
3010     AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
3011
3012   game.envelope_active = FALSE;
3013
3014   SetDrawtoField(DRAW_TO_FIELDBUFFER);
3015
3016   redraw_mask |= REDRAW_FIELD;
3017   BackToFront();
3018 }
3019
3020 static void PrepareEnvelopeRequestToScreen(Bitmap *bitmap, int sx, int sy,
3021                                            int xsize, int ysize)
3022 {
3023   if (!global.use_envelope_request)
3024     return;
3025
3026   if (request.bitmap == NULL ||
3027       xsize > request.xsize ||
3028       ysize > request.ysize)
3029   {
3030     if (request.bitmap != NULL)
3031       FreeBitmap(request.bitmap);
3032
3033     request.bitmap = CreateBitmap(xsize, ysize, DEFAULT_DEPTH);
3034
3035     SDL_Surface *surface = request.bitmap->surface;
3036
3037     if ((request.bitmap->surface_masked = SDLGetNativeSurface(surface)) == NULL)
3038       Fail("SDLGetNativeSurface() failed");
3039   }
3040
3041   BlitBitmap(bitmap, request.bitmap, sx, sy, xsize, ysize, 0, 0);
3042
3043   // create masked surface for request bitmap, if needed
3044   if (graphic_info[IMG_BACKGROUND_REQUEST].draw_masked)
3045   {
3046     SDL_Surface *surface        = request.bitmap->surface;
3047     SDL_Surface *surface_masked = request.bitmap->surface_masked;
3048
3049     SDLBlitSurface(surface, surface_masked, 0, 0, xsize, ysize, 0, 0);
3050     SDL_SetColorKey(surface_masked, SET_TRANSPARENT_PIXEL,
3051                     SDL_MapRGB(surface_masked->format, 0x00, 0x00, 0x00));
3052   }
3053
3054   SDLFreeBitmapTextures(request.bitmap);
3055   SDLCreateBitmapTextures(request.bitmap);
3056
3057   // set envelope request run-time values
3058   request.sx = sx;
3059   request.sy = sy;
3060   request.xsize = xsize;
3061   request.ysize = ysize;
3062 }
3063
3064 void DrawEnvelopeRequestToScreen(int drawing_target)
3065 {
3066   if (global.use_envelope_request &&
3067       game.request_active &&
3068       drawing_target == DRAW_TO_SCREEN)
3069   {
3070     if (graphic_info[IMG_BACKGROUND_REQUEST].draw_masked)
3071       BlitToScreenMasked(request.bitmap, 0, 0, request.xsize, request.ysize,
3072                          request.sx, request.sy);
3073     else
3074       BlitToScreen(request.bitmap, 0, 0, request.xsize, request.ysize,
3075                    request.sx, request.sy);
3076   }
3077 }
3078
3079 static void setRequestBasePosition(int *x, int *y)
3080 {
3081   int sx_base, sy_base;
3082
3083   if (request.x != -1)
3084     sx_base = request.x;
3085   else if (request.align == ALIGN_LEFT)
3086     sx_base = SX;
3087   else if (request.align == ALIGN_RIGHT)
3088     sx_base = SX + SXSIZE;
3089   else
3090     sx_base = SX + SXSIZE / 2;
3091
3092   if (request.y != -1)
3093     sy_base = request.y;
3094   else if (request.valign == VALIGN_TOP)
3095     sy_base = SY;
3096   else if (request.valign == VALIGN_BOTTOM)
3097     sy_base = SY + SYSIZE;
3098   else
3099     sy_base = SY + SYSIZE / 2;
3100
3101   *x = sx_base;
3102   *y = sy_base;
3103 }
3104
3105 static void setRequestPositionExt(int *x, int *y, int width, int height,
3106                                   boolean add_border_size)
3107 {
3108   int border_size = request.border_size;
3109   int sx_base, sy_base;
3110   int sx, sy;
3111
3112   setRequestBasePosition(&sx_base, &sy_base);
3113
3114   if (request.align == ALIGN_LEFT)
3115     sx = sx_base;
3116   else if (request.align == ALIGN_RIGHT)
3117     sx = sx_base - width;
3118   else
3119     sx = sx_base - width  / 2;
3120
3121   if (request.valign == VALIGN_TOP)
3122     sy = sy_base;
3123   else if (request.valign == VALIGN_BOTTOM)
3124     sy = sy_base - height;
3125   else
3126     sy = sy_base - height / 2;
3127
3128   sx = MAX(0, MIN(sx, WIN_XSIZE - width));
3129   sy = MAX(0, MIN(sy, WIN_YSIZE - height));
3130
3131   if (add_border_size)
3132   {
3133     sx += border_size;
3134     sy += border_size;
3135   }
3136
3137   *x = sx;
3138   *y = sy;
3139 }
3140
3141 static void setRequestPosition(int *x, int *y, boolean add_border_size)
3142 {
3143   setRequestPositionExt(x, y, request.width, request.height, add_border_size);
3144 }
3145
3146 static void DrawEnvelopeRequest(char *text, unsigned int req_state)
3147 {
3148   DrawBuffer *drawto_last = drawto;
3149   char *text_final = text;
3150   char *text_door_style = NULL;
3151   int graphic = IMG_BACKGROUND_REQUEST;
3152   Bitmap *src_bitmap = graphic_info[graphic].bitmap;
3153   int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
3154   int font_nr = FONT_REQUEST;
3155   int font_width = getFontWidth(font_nr);
3156   int font_height = getFontHeight(font_nr);
3157   int border_size = request.border_size;
3158   int line_spacing = request.line_spacing;
3159   int line_height = font_height + line_spacing;
3160   int max_text_width  = request.width  - 2 * border_size;
3161   int max_text_height = request.height - 2 * border_size;
3162   int line_length = max_text_width  / font_width;
3163   int max_lines   = max_text_height / line_height;
3164   int text_width = line_length * font_width;
3165   int width = request.width;
3166   int height = request.height;
3167   int tile_size = MAX(request.step_offset, 1);
3168   int x_steps = width  / tile_size;
3169   int y_steps = height / tile_size;
3170   int sx_offset = border_size;
3171   int sy_offset = border_size;
3172   int sx, sy;
3173   int x, y;
3174
3175   if (request.centered)
3176     sx_offset = (request.width - text_width) / 2;
3177
3178   if (request.wrap_single_words && !request.autowrap)
3179   {
3180     char *src_text_ptr, *dst_text_ptr;
3181
3182     text_door_style = checked_malloc(2 * strlen(text) + 1);
3183
3184     src_text_ptr = text;
3185     dst_text_ptr = text_door_style;
3186
3187     while (*src_text_ptr)
3188     {
3189       if (*src_text_ptr == ' ' ||
3190           *src_text_ptr == '?' ||
3191           *src_text_ptr == '!')
3192         *dst_text_ptr++ = '\n';
3193
3194       if (*src_text_ptr != ' ')
3195         *dst_text_ptr++ = *src_text_ptr;
3196
3197       src_text_ptr++;
3198     }
3199
3200     *dst_text_ptr = '\0';
3201
3202     text_final = text_door_style;
3203   }
3204
3205   setRequestPosition(&sx, &sy, FALSE);
3206
3207   // draw complete envelope request to temporary bitmap
3208   drawto = bitmap_db_store_1;
3209
3210   ClearRectangle(drawto, sx, sy, width, height);
3211
3212   for (y = 0; y < y_steps; y++)
3213     for (x = 0; x < x_steps; x++)
3214       DrawEnvelopeBackgroundTiles(graphic, sx, sy,
3215                                   x, y, x_steps, y_steps,
3216                                   tile_size, tile_size);
3217
3218   // force DOOR font inside door area
3219   SetFontStatus(GAME_MODE_PSEUDO_DOOR);
3220
3221   DrawTextBuffer(sx + sx_offset, sy + sy_offset, text_final, font_nr,
3222                  line_length, -1, max_lines, line_spacing, mask_mode,
3223                  request.autowrap, request.centered, FALSE);
3224
3225   ResetFontStatus();
3226
3227   MapToolButtons(req_state);
3228
3229   // restore pointer to drawing buffer
3230   drawto = drawto_last;
3231
3232   // prepare complete envelope request from temporary bitmap
3233   PrepareEnvelopeRequestToScreen(bitmap_db_store_1, sx, sy, width, height);
3234
3235   if (text_door_style)
3236     free(text_door_style);
3237 }
3238
3239 static void AnimateEnvelopeRequest(int anim_mode, int action)
3240 {
3241   boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
3242   int delay_value_normal = request.step_delay;
3243   int delay_value_fast = delay_value_normal / 2;
3244   boolean ffwd_delay = (tape.playing && tape.fast_forward);
3245   boolean no_delay = (tape.warp_forward);
3246   int delay_value = (ffwd_delay ? delay_value_fast : delay_value_normal);
3247   int anim_delay_value = MAX(1, (no_delay ? 0 : delay_value + 500 * 0) / 2);
3248   DelayCounter anim_delay = { anim_delay_value };
3249
3250   int tile_size = MAX(request.step_offset, 1);
3251   int max_xsize = request.width  / tile_size;
3252   int max_ysize = request.height / tile_size;
3253   int max_xsize_inner = max_xsize - 2;
3254   int max_ysize_inner = max_ysize - 2;
3255
3256   int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize_inner : 0);
3257   int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize_inner : 0);
3258   int xend = max_xsize_inner;
3259   int yend = (anim_mode != ANIM_DEFAULT ? max_ysize_inner : 0);
3260   int xstep = (xstart < xend ? 1 : 0);
3261   int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
3262   int start = 0;
3263   int end = MAX(xend - xstart, yend - ystart);
3264   int i;
3265
3266   if (setup.quick_doors)
3267   {
3268     xstart = xend;
3269     ystart = yend;
3270     end = 0;
3271   }
3272
3273   for (i = start; i <= end; i++)
3274   {
3275     int last_frame = end;       // last frame of this "for" loop
3276     int x = xstart + i * xstep;
3277     int y = ystart + i * ystep;
3278     int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
3279     int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
3280     int xsize_size_left = (xsize - 1) * tile_size;
3281     int ysize_size_top  = (ysize - 1) * tile_size;
3282     int max_xsize_pos = (max_xsize - 1) * tile_size;
3283     int max_ysize_pos = (max_ysize - 1) * tile_size;
3284     int width  = xsize * tile_size;
3285     int height = ysize * tile_size;
3286     int src_x, src_y;
3287     int dst_x, dst_y;
3288     int xx, yy;
3289
3290     if (game_ended)
3291       HandleGameActions();
3292
3293     setRequestPosition(&src_x, &src_y, FALSE);
3294     setRequestPositionExt(&dst_x, &dst_y, width, height, FALSE);
3295
3296     for (yy = 0; yy < 2; yy++)
3297     {
3298       for (xx = 0; xx < 2; xx++)
3299       {
3300         int src_xx = src_x + xx * max_xsize_pos;
3301         int src_yy = src_y + yy * max_ysize_pos;
3302         int dst_xx = dst_x + xx * xsize_size_left;
3303         int dst_yy = dst_y + yy * ysize_size_top;
3304         int xx_size = (xx ? tile_size : xsize_size_left);
3305         int yy_size = (yy ? tile_size : ysize_size_top);
3306
3307         // draw partial (animated) envelope request to temporary bitmap
3308         BlitBitmap(bitmap_db_store_1, bitmap_db_store_2,
3309                    src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
3310       }
3311     }
3312
3313     // prepare partial (animated) envelope request from temporary bitmap
3314     PrepareEnvelopeRequestToScreen(bitmap_db_store_2, dst_x, dst_y,
3315                                    width, height);
3316
3317     redraw_mask |= REDRAW_FIELD;
3318
3319     BackToFront();
3320
3321     SkipUntilDelayReached(&anim_delay, &i, last_frame);
3322   }
3323
3324   ClearAutoRepeatKeyEvents();
3325 }
3326
3327 static void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
3328 {
3329   int graphic = IMG_BACKGROUND_REQUEST;
3330   int sound_opening = SND_REQUEST_OPENING;
3331   int sound_closing = SND_REQUEST_CLOSING;
3332   int anim_mode_1 = request.anim_mode;                  // (higher priority)
3333   int anim_mode_2 = graphic_info[graphic].anim_mode;    // (lower priority)
3334   int anim_mode = (anim_mode_1 != ANIM_DEFAULT ? anim_mode_1 : anim_mode_2);
3335   int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
3336                         anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
3337
3338   game.envelope_active = TRUE;  // needed for RedrawPlayfield() events
3339
3340   if (action == ACTION_OPENING)
3341   {
3342     DrawEnvelopeRequest(text, req_state);
3343
3344     PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
3345
3346     if (anim_mode == ANIM_DEFAULT)
3347       AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
3348
3349     AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
3350   }
3351   else
3352   {
3353     PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
3354
3355     if (anim_mode != ANIM_NONE)
3356       AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
3357
3358     if (anim_mode == ANIM_DEFAULT)
3359       AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
3360   }
3361
3362   game.envelope_active = FALSE;
3363 }
3364
3365 static void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
3366 {
3367   if (IS_MM_WALL(element))
3368   {
3369     DrawSizedWall_MM(dst_x, dst_y, element, tilesize, el2preimg);
3370   }
3371   else
3372   {
3373     Bitmap *src_bitmap;
3374     int src_x, src_y;
3375     int graphic = el2preimg(element);
3376
3377     getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
3378     BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize,
3379                dst_x, dst_y);
3380   }
3381 }
3382
3383 void DrawLevel(int draw_background_mask)
3384 {
3385   int x, y;
3386
3387   SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
3388   SetDrawBackgroundMask(draw_background_mask);
3389
3390   ClearField();
3391
3392   for (x = BX1; x <= BX2; x++)
3393     for (y = BY1; y <= BY2; y++)
3394       DrawScreenField(x, y);
3395
3396   redraw_mask |= REDRAW_FIELD;
3397 }
3398
3399 void DrawSizedLevel(int size_x, int size_y, int scroll_x, int scroll_y,
3400                     int tilesize)
3401 {
3402   int x, y;
3403
3404   for (x = 0; x < size_x; x++)
3405     for (y = 0; y < size_y; y++)
3406       DrawSizedElementOrWall(x, y, scroll_x, scroll_y, tilesize);
3407
3408   redraw_mask |= REDRAW_FIELD;
3409 }
3410
3411 void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
3412 {
3413   int x, y;
3414
3415   for (x = 0; x < size_x; x++)
3416     for (y = 0; y < size_y; y++)
3417       DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
3418
3419   redraw_mask |= REDRAW_FIELD;
3420 }
3421
3422 static void DrawPreviewLevelPlayfield(int from_x, int from_y)
3423 {
3424   boolean show_level_border = (BorderElement != EL_EMPTY);
3425   int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3426   int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3427   int tile_size = preview.tile_size;
3428   int preview_width  = preview.xsize * tile_size;
3429   int preview_height = preview.ysize * tile_size;
3430   int real_preview_xsize = MIN(level_xsize, preview.xsize);
3431   int real_preview_ysize = MIN(level_ysize, preview.ysize);
3432   int real_preview_width  = real_preview_xsize * tile_size;
3433   int real_preview_height = real_preview_ysize * tile_size;
3434   int dst_x = SX + ALIGNED_XPOS(preview.x, preview_width, preview.align);
3435   int dst_y = SY + ALIGNED_YPOS(preview.y, preview_height, preview.valign);
3436   int x, y;
3437
3438   if (!IN_GFX_FIELD_FULL(dst_x, dst_y + preview_height - 1))
3439     return;
3440
3441   DrawBackground(dst_x, dst_y, preview_width, preview_height);
3442
3443   dst_x += (preview_width  - real_preview_width)  / 2;
3444   dst_y += (preview_height - real_preview_height) / 2;
3445
3446   for (x = 0; x < real_preview_xsize; x++)
3447   {
3448     for (y = 0; y < real_preview_ysize; y++)
3449     {
3450       int lx = from_x + x + (show_level_border ? -1 : 0);
3451       int ly = from_y + y + (show_level_border ? -1 : 0);
3452       int element = (IN_LEV_FIELD(lx, ly) ? level.field[lx][ly] :
3453                      getBorderElement(lx, ly));
3454
3455       DrawPreviewElement(dst_x + x * tile_size, dst_y + y * tile_size,
3456                          element, tile_size);
3457     }
3458   }
3459
3460   redraw_mask |= REDRAW_FIELD;
3461 }
3462
3463 #define MICROLABEL_EMPTY                0
3464 #define MICROLABEL_LEVEL_NAME           1
3465 #define MICROLABEL_LEVEL_AUTHOR_HEAD    2
3466 #define MICROLABEL_LEVEL_AUTHOR         3
3467 #define MICROLABEL_IMPORTED_FROM_HEAD   4
3468 #define MICROLABEL_IMPORTED_FROM        5
3469 #define MICROLABEL_IMPORTED_BY_HEAD     6
3470 #define MICROLABEL_IMPORTED_BY          7
3471
3472 static int getMaxTextLength(struct TextPosInfo *pos, int font_nr)
3473 {
3474   int max_text_width = SXSIZE;
3475   int font_width = getFontWidth(font_nr);
3476
3477   if (pos->align == ALIGN_CENTER)
3478     max_text_width = (pos->x < SXSIZE / 2 ? pos->x * 2 : (SXSIZE - pos->x) * 2);
3479   else if (pos->align == ALIGN_RIGHT)
3480     max_text_width = pos->x;
3481   else
3482     max_text_width = SXSIZE - pos->x;
3483
3484   return max_text_width / font_width;
3485 }
3486
3487 static void DrawPreviewLevelLabelExt(int mode, struct TextPosInfo *pos)
3488 {
3489   char label_text[MAX_OUTPUT_LINESIZE + 1];
3490   int max_len_label_text;
3491   int font_nr = pos->font;
3492   int i;
3493
3494   if (!IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3495     return;
3496
3497   if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
3498       mode == MICROLABEL_IMPORTED_FROM_HEAD ||
3499       mode == MICROLABEL_IMPORTED_BY_HEAD)
3500     font_nr = pos->font_alt;
3501
3502   max_len_label_text = getMaxTextLength(pos, font_nr);
3503
3504   if (pos->size != -1)
3505     max_len_label_text = pos->size;
3506
3507   for (i = 0; i < max_len_label_text; i++)
3508     label_text[i] = ' ';
3509   label_text[max_len_label_text] = '\0';
3510
3511   if (strlen(label_text) > 0)
3512     DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3513
3514   strncpy(label_text,
3515           (mode == MICROLABEL_LEVEL_NAME ? level.name :
3516            mode == MICROLABEL_LEVEL_AUTHOR_HEAD ? "created by" :
3517            mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
3518            mode == MICROLABEL_IMPORTED_FROM_HEAD ? "imported from" :
3519            mode == MICROLABEL_IMPORTED_FROM ? leveldir_current->imported_from :
3520            mode == MICROLABEL_IMPORTED_BY_HEAD ? "imported by" :
3521            mode == MICROLABEL_IMPORTED_BY ? leveldir_current->imported_by :""),
3522           max_len_label_text);
3523   label_text[max_len_label_text] = '\0';
3524
3525   if (strlen(label_text) > 0)
3526     DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3527
3528   redraw_mask |= REDRAW_FIELD;
3529 }
3530
3531 static void DrawPreviewLevelLabel(int mode)
3532 {
3533   DrawPreviewLevelLabelExt(mode, &menu.main.text.level_info_2);
3534 }
3535
3536 static void DrawPreviewLevelInfo(int mode)
3537 {
3538   if (mode == MICROLABEL_LEVEL_NAME)
3539     DrawPreviewLevelLabelExt(mode, &menu.main.text.level_name);
3540   else if (mode == MICROLABEL_LEVEL_AUTHOR)
3541     DrawPreviewLevelLabelExt(mode, &menu.main.text.level_author);
3542 }
3543
3544 static void DrawPreviewLevelExt(boolean restart)
3545 {
3546   static DelayCounter scroll_delay = { 0 };
3547   static DelayCounter label_delay = { 0 };
3548   static int from_x, from_y, scroll_direction;
3549   static int label_state, label_counter;
3550   boolean show_level_border = (BorderElement != EL_EMPTY);
3551   int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3552   int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3553
3554   scroll_delay.value = preview.step_delay;
3555   label_delay.value = MICROLEVEL_LABEL_DELAY;
3556
3557   if (restart)
3558   {
3559     from_x = 0;
3560     from_y = 0;
3561
3562     if (preview.anim_mode == ANIM_CENTERED)
3563     {
3564       if (level_xsize > preview.xsize)
3565         from_x = (level_xsize - preview.xsize) / 2;
3566       if (level_ysize > preview.ysize)
3567         from_y = (level_ysize - preview.ysize) / 2;
3568     }
3569
3570     from_x += preview.xoffset;
3571     from_y += preview.yoffset;
3572
3573     scroll_direction = MV_RIGHT;
3574     label_state = 1;
3575     label_counter = 0;
3576
3577     DrawPreviewLevelPlayfield(from_x, from_y);
3578     DrawPreviewLevelLabel(label_state);
3579
3580     DrawPreviewLevelInfo(MICROLABEL_LEVEL_NAME);
3581     DrawPreviewLevelInfo(MICROLABEL_LEVEL_AUTHOR);
3582
3583     // initialize delay counters
3584     ResetDelayCounter(&scroll_delay);
3585     ResetDelayCounter(&label_delay);
3586
3587     if (leveldir_current->name)
3588     {
3589       struct TextPosInfo *pos = &menu.main.text.level_info_1;
3590       char label_text[MAX_OUTPUT_LINESIZE + 1];
3591       int font_nr = pos->font;
3592       int max_len_label_text = getMaxTextLength(pos, font_nr);
3593
3594       if (pos->size != -1)
3595         max_len_label_text = pos->size;
3596
3597       strncpy(label_text, leveldir_current->name, max_len_label_text);
3598       label_text[max_len_label_text] = '\0';
3599
3600       if (IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3601         DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3602     }
3603
3604     return;
3605   }
3606
3607   // scroll preview level, if needed
3608   if (preview.anim_mode != ANIM_NONE &&
3609       (level_xsize > preview.xsize || level_ysize > preview.ysize) &&
3610       DelayReached(&scroll_delay))
3611   {
3612     switch (scroll_direction)
3613     {
3614       case MV_LEFT:
3615         if (from_x > 0)
3616         {
3617           from_x -= preview.step_offset;
3618           from_x = (from_x < 0 ? 0 : from_x);
3619         }
3620         else
3621           scroll_direction = MV_UP;
3622         break;
3623
3624       case MV_RIGHT:
3625         if (from_x < level_xsize - preview.xsize)
3626         {
3627           from_x += preview.step_offset;
3628           from_x = (from_x > level_xsize - preview.xsize ?
3629                     level_xsize - preview.xsize : from_x);
3630         }
3631         else
3632           scroll_direction = MV_DOWN;
3633         break;
3634
3635       case MV_UP:
3636         if (from_y > 0)
3637         {
3638           from_y -= preview.step_offset;
3639           from_y = (from_y < 0 ? 0 : from_y);
3640         }
3641         else
3642           scroll_direction = MV_RIGHT;
3643         break;
3644
3645       case MV_DOWN:
3646         if (from_y < level_ysize - preview.ysize)
3647         {
3648           from_y += preview.step_offset;
3649           from_y = (from_y > level_ysize - preview.ysize ?
3650                     level_ysize - preview.ysize : from_y);
3651         }
3652         else
3653           scroll_direction = MV_LEFT;
3654         break;
3655
3656       default:
3657         break;
3658     }
3659
3660     DrawPreviewLevelPlayfield(from_x, from_y);
3661   }
3662
3663   // !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!!
3664   // redraw micro level label, if needed
3665   if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
3666       !strEqual(level.author, ANONYMOUS_NAME) &&
3667       !strEqual(level.author, leveldir_current->name) &&
3668       DelayReached(&label_delay))
3669   {
3670     int max_label_counter = 23;
3671
3672     if (leveldir_current->imported_from != NULL &&
3673         strlen(leveldir_current->imported_from) > 0)
3674       max_label_counter += 14;
3675     if (leveldir_current->imported_by != NULL &&
3676         strlen(leveldir_current->imported_by) > 0)
3677       max_label_counter += 14;
3678
3679     label_counter = (label_counter + 1) % max_label_counter;
3680     label_state = (label_counter >= 0 && label_counter <= 7 ?
3681                    MICROLABEL_LEVEL_NAME :
3682                    label_counter >= 9 && label_counter <= 12 ?
3683                    MICROLABEL_LEVEL_AUTHOR_HEAD :
3684                    label_counter >= 14 && label_counter <= 21 ?
3685                    MICROLABEL_LEVEL_AUTHOR :
3686                    label_counter >= 23 && label_counter <= 26 ?
3687                    MICROLABEL_IMPORTED_FROM_HEAD :
3688                    label_counter >= 28 && label_counter <= 35 ?
3689                    MICROLABEL_IMPORTED_FROM :
3690                    label_counter >= 37 && label_counter <= 40 ?
3691                    MICROLABEL_IMPORTED_BY_HEAD :
3692                    label_counter >= 42 && label_counter <= 49 ?
3693                    MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
3694
3695     if (leveldir_current->imported_from == NULL &&
3696         (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
3697          label_state == MICROLABEL_IMPORTED_FROM))
3698       label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
3699                      MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
3700
3701     DrawPreviewLevelLabel(label_state);
3702   }
3703 }
3704
3705 void DrawPreviewPlayers(void)
3706 {
3707   if (game_status != GAME_MODE_MAIN)
3708     return;
3709
3710   // do not draw preview players if level preview redefined, but players aren't
3711   if (preview.redefined && !menu.main.preview_players.redefined)
3712     return;
3713
3714   boolean player_found[MAX_PLAYERS];
3715   int num_players = 0;
3716   int i, x, y;
3717
3718   for (i = 0; i < MAX_PLAYERS; i++)
3719     player_found[i] = FALSE;
3720
3721   // check which players can be found in the level (simple approach)
3722   for (x = 0; x < lev_fieldx; x++)
3723   {
3724     for (y = 0; y < lev_fieldy; y++)
3725     {
3726       int element = level.field[x][y];
3727
3728       if (IS_PLAYER_ELEMENT(element))
3729       {
3730         int player_nr = GET_PLAYER_NR(element);
3731
3732         player_nr = MIN(MAX(0, player_nr), MAX_PLAYERS - 1);
3733
3734         if (!player_found[player_nr])
3735           num_players++;
3736
3737         player_found[player_nr] = TRUE;
3738       }
3739     }
3740   }
3741
3742   struct TextPosInfo *pos = &menu.main.preview_players;
3743   int tile_size = pos->tile_size;
3744   int border_size = pos->border_size;
3745   int player_xoffset_raw = (pos->vertical ? 0 : tile_size + border_size);
3746   int player_yoffset_raw = (pos->vertical ? tile_size + border_size : 0);
3747   int player_xoffset = (pos->xoffset != -1 ? pos->xoffset : player_xoffset_raw);
3748   int player_yoffset = (pos->yoffset != -1 ? pos->yoffset : player_yoffset_raw);
3749   int max_players_width  = (MAX_PLAYERS - 1) * player_xoffset + tile_size;
3750   int max_players_height = (MAX_PLAYERS - 1) * player_yoffset + tile_size;
3751   int all_players_width  = (num_players - 1) * player_xoffset + tile_size;
3752   int all_players_height = (num_players - 1) * player_yoffset + tile_size;
3753   int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width,  pos->align);
3754   int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
3755   int xpos = SX + ALIGNED_XPOS(pos->x, all_players_width,  pos->align);
3756   int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
3757
3758   // clear area in which the players will be drawn
3759   ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
3760                              max_players_width, max_players_height);
3761
3762   if (!network.enabled && !setup.team_mode)
3763     return;
3764
3765   // only draw players if level is suited for team mode
3766   if (num_players < 2)
3767     return;
3768
3769   // draw all players that were found in the level
3770   for (i = 0; i < MAX_PLAYERS; i++)
3771   {
3772     if (player_found[i])
3773     {
3774       int graphic = el2img(EL_PLAYER_1 + i);
3775
3776       DrawSizedGraphicThruMaskExt(drawto, xpos, ypos, graphic, 0, tile_size);
3777
3778       xpos += player_xoffset;
3779       ypos += player_yoffset;
3780     }
3781   }
3782 }
3783
3784 void DrawPreviewLevelInitial(void)
3785 {
3786   DrawPreviewLevelExt(TRUE);
3787   DrawPreviewPlayers();
3788 }
3789
3790 void DrawPreviewLevelAnimation(void)
3791 {
3792   DrawPreviewLevelExt(FALSE);
3793 }
3794
3795 static void DrawNetworkPlayer(int x, int y, int player_nr, int tile_size,
3796                               int border_size, int font_nr)
3797 {
3798   int graphic = el2img(EL_PLAYER_1 + player_nr);
3799   int font_height = getFontHeight(font_nr);
3800   int player_height = MAX(tile_size, font_height);
3801   int xoffset_text = tile_size + border_size;
3802   int yoffset_text    = (player_height - font_height) / 2;
3803   int yoffset_graphic = (player_height - tile_size) / 2;
3804   char *player_name = getNetworkPlayerName(player_nr + 1);
3805
3806   DrawSizedGraphicThruMaskExt(drawto, x, y + yoffset_graphic, graphic, 0,
3807                               tile_size);
3808   DrawText(x + xoffset_text, y + yoffset_text, player_name, font_nr);
3809 }
3810
3811 static void DrawNetworkPlayersExt(boolean force)
3812 {
3813   if (game_status != GAME_MODE_MAIN)
3814     return;
3815
3816   if (!network.connected && !force)
3817     return;
3818
3819   // do not draw network players if level preview redefined, but players aren't
3820   if (preview.redefined && !menu.main.network_players.redefined)
3821     return;
3822
3823   int num_players = 0;
3824   int i;
3825
3826   for (i = 0; i < MAX_PLAYERS; i++)
3827     if (stored_player[i].connected_network)
3828       num_players++;
3829
3830   struct TextPosInfo *pos = &menu.main.network_players;
3831   int tile_size = pos->tile_size;
3832   int border_size = pos->border_size;
3833   int xoffset_text = tile_size + border_size;
3834   int font_nr = pos->font;
3835   int font_width = getFontWidth(font_nr);
3836   int font_height = getFontHeight(font_nr);
3837   int player_height = MAX(tile_size, font_height);
3838   int player_yoffset = player_height + border_size;
3839   int max_players_width = xoffset_text + MAX_PLAYER_NAME_LEN * font_width;
3840   int max_players_height = MAX_PLAYERS * player_yoffset - border_size;
3841   int all_players_height = num_players * player_yoffset - border_size;
3842   int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width,  pos->align);
3843   int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
3844   int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
3845
3846   ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
3847                              max_players_width, max_players_height);
3848
3849   // first draw local network player ...
3850   for (i = 0; i < MAX_PLAYERS; i++)
3851   {
3852     if (stored_player[i].connected_network &&
3853         stored_player[i].connected_locally)
3854     {
3855       char *player_name = getNetworkPlayerName(i + 1);
3856       int player_width = xoffset_text + getTextWidth(player_name, font_nr);
3857       int xpos = SX + ALIGNED_XPOS(pos->x, player_width,  pos->align);
3858
3859       DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
3860
3861       ypos += player_yoffset;
3862     }
3863   }
3864
3865   // ... then draw all other network players
3866   for (i = 0; i < MAX_PLAYERS; i++)
3867   {
3868     if (stored_player[i].connected_network &&
3869         !stored_player[i].connected_locally)
3870     {
3871       char *player_name = getNetworkPlayerName(i + 1);
3872       int player_width = xoffset_text + getTextWidth(player_name, font_nr);
3873       int xpos = SX + ALIGNED_XPOS(pos->x, player_width,  pos->align);
3874
3875       DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
3876
3877       ypos += player_yoffset;
3878     }
3879   }
3880 }
3881
3882 void DrawNetworkPlayers(void)
3883 {
3884   DrawNetworkPlayersExt(FALSE);
3885 }
3886
3887 void ClearNetworkPlayers(void)
3888 {
3889   DrawNetworkPlayersExt(TRUE);
3890 }
3891
3892 static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3893                                     int graphic, int lx, int ly,
3894                                     int mask_mode)
3895 {
3896   int frame = getGraphicAnimationFrameXY(graphic, lx, ly);
3897
3898   if (mask_mode == USE_MASKING)
3899     DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3900   else
3901     DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
3902 }
3903
3904 void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3905                                   int graphic, int sync_frame, int mask_mode)
3906 {
3907   int frame = getGraphicAnimationFrame(graphic, sync_frame);
3908
3909   if (mask_mode == USE_MASKING)
3910     DrawFixedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3911   else
3912     DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame);
3913 }
3914
3915 void DrawSizedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3916                                   int graphic, int sync_frame, int tilesize,
3917                                   int mask_mode)
3918 {
3919   int frame = getGraphicAnimationFrame(graphic, sync_frame);
3920
3921   if (mask_mode == USE_MASKING)
3922     DrawSizedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame, tilesize);
3923   else
3924     DrawSizedGraphicExt(dst_bitmap, x, y, graphic, frame, tilesize);
3925 }
3926
3927 static void DrawGraphicAnimation(int x, int y, int graphic)
3928 {
3929   int lx = LEVELX(x), ly = LEVELY(y);
3930   int mask_mode = NO_MASKING;
3931
3932   if (!IN_SCR_FIELD(x, y))
3933     return;
3934
3935   if (game.use_masked_elements)
3936   {
3937     if (Tile[lx][ly] != EL_EMPTY)
3938     {
3939       DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
3940
3941       mask_mode = USE_MASKING;
3942     }
3943   }
3944
3945   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
3946                           graphic, lx, ly, mask_mode);
3947
3948   MarkTileDirty(x, y);
3949 }
3950
3951 void DrawFixedGraphicAnimation(int x, int y, int graphic)
3952 {
3953   int lx = LEVELX(x), ly = LEVELY(y);
3954   int mask_mode = NO_MASKING;
3955
3956   if (!IN_SCR_FIELD(x, y))
3957     return;
3958
3959   if (game.use_masked_elements)
3960   {
3961     if (Tile[lx][ly] != EL_EMPTY)
3962     {
3963       DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
3964
3965       mask_mode = USE_MASKING;
3966     }
3967   }
3968
3969   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
3970                           graphic, lx, ly, mask_mode);
3971
3972   MarkTileDirty(x, y);
3973 }
3974
3975 void DrawLevelGraphicAnimation(int x, int y, int graphic)
3976 {
3977   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3978 }
3979
3980 void DrawLevelElementAnimation(int x, int y, int element)
3981 {
3982   int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
3983
3984   DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3985 }
3986
3987 void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
3988 {
3989   int sx = SCREENX(x), sy = SCREENY(y);
3990
3991   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
3992     return;
3993
3994   if (Tile[x][y] == EL_EMPTY)
3995     graphic = el2img(GfxElementEmpty[x][y]);
3996
3997   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
3998     return;
3999
4000   if (ANIM_MODE(graphic) & (ANIM_TILED | ANIM_RANDOM_STATIC))
4001     return;
4002
4003   DrawGraphicAnimation(sx, sy, graphic);
4004
4005 #if 1
4006   if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
4007     DrawLevelFieldCrumbled(x, y);
4008 #else
4009   if (GFX_CRUMBLED(Tile[x][y]))
4010     DrawLevelFieldCrumbled(x, y);
4011 #endif
4012 }
4013
4014 void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
4015 {
4016   int sx = SCREENX(x), sy = SCREENY(y);
4017   int graphic;
4018
4019   if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
4020     return;
4021
4022   graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
4023
4024   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
4025     return;
4026
4027   DrawGraphicAnimation(sx, sy, graphic);
4028
4029   if (GFX_CRUMBLED(element))
4030     DrawLevelFieldCrumbled(x, y);
4031 }
4032
4033 static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
4034 {
4035   if (player->use_murphy)
4036   {
4037     // this works only because currently only one player can be "murphy" ...
4038     static int last_horizontal_dir = MV_LEFT;
4039     int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
4040
4041     if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
4042       last_horizontal_dir = move_dir;
4043
4044     if (graphic == IMG_SP_MURPHY)       // undefined => use special graphic
4045     {
4046       int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
4047
4048       graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
4049     }
4050
4051     return graphic;
4052   }
4053   else
4054     return el_act_dir2img(player->artwork_element, player->GfxAction, move_dir);
4055 }
4056
4057 static boolean equalGraphics(int graphic1, int graphic2)
4058 {
4059   struct GraphicInfo *g1 = &graphic_info[graphic1];
4060   struct GraphicInfo *g2 = &graphic_info[graphic2];
4061
4062   return (g1->bitmap      == g2->bitmap &&
4063           g1->src_x       == g2->src_x &&
4064           g1->src_y       == g2->src_y &&
4065           g1->anim_frames == g2->anim_frames &&
4066           g1->anim_delay  == g2->anim_delay &&
4067           g1->anim_mode   == g2->anim_mode);
4068 }
4069
4070 #define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
4071
4072 enum
4073 {
4074   DRAW_PLAYER_STAGE_INIT = 0,
4075   DRAW_PLAYER_STAGE_LAST_FIELD,
4076   DRAW_PLAYER_STAGE_FIELD_UNDER_PLAYER,
4077 #if DRAW_PLAYER_OVER_PUSHED_ELEMENT
4078   DRAW_PLAYER_STAGE_ELEMENT_PUSHED,
4079   DRAW_PLAYER_STAGE_PLAYER,
4080 #else
4081   DRAW_PLAYER_STAGE_PLAYER,
4082   DRAW_PLAYER_STAGE_ELEMENT_PUSHED,
4083 #endif
4084   DRAW_PLAYER_STAGE_ELEMENT_OVER_PLAYER,
4085   DRAW_PLAYER_STAGE_FIELD_OVER_PLAYER,
4086
4087   NUM_DRAW_PLAYER_STAGES
4088 };
4089
4090 static void DrawPlayerExt(struct PlayerInfo *player, int drawing_stage)
4091 {
4092   static int static_last_player_graphic[MAX_PLAYERS];
4093   static int static_last_player_frame[MAX_PLAYERS];
4094   static boolean static_player_is_opaque[MAX_PLAYERS];
4095   static boolean draw_player[MAX_PLAYERS];
4096   int pnr = player->index_nr;
4097
4098   if (drawing_stage == DRAW_PLAYER_STAGE_INIT)
4099   {
4100     static_last_player_graphic[pnr] = getPlayerGraphic(player, player->MovDir);
4101     static_last_player_frame[pnr] = player->Frame;
4102     static_player_is_opaque[pnr] = FALSE;
4103
4104     draw_player[pnr] = TRUE;
4105   }
4106
4107   if (!draw_player[pnr])
4108     return;
4109
4110 #if DEBUG
4111   if (!IN_LEV_FIELD(player->jx, player->jy))
4112   {
4113     Debug("draw:DrawPlayerExt", "x = %d, y = %d", player->jx, player->jy);
4114     Debug("draw:DrawPlayerExt", "This should never happen!");
4115
4116     draw_player[pnr] = FALSE;
4117
4118     return;
4119   }
4120 #endif
4121
4122   int last_player_graphic  = static_last_player_graphic[pnr];
4123   int last_player_frame    = static_last_player_frame[pnr];
4124   boolean player_is_opaque = static_player_is_opaque[pnr];
4125
4126   int jx = player->jx;
4127   int jy = player->jy;
4128   int move_dir = (player->is_waiting ? player->dir_waiting : player->MovDir);
4129   int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
4130   int dy = (move_dir == MV_UP   ? -1 : move_dir == MV_DOWN  ? +1 : 0);
4131   int last_jx = (player->is_moving ? jx - dx : jx);
4132   int last_jy = (player->is_moving ? jy - dy : jy);
4133   int next_jx = jx + dx;
4134   int next_jy = jy + dy;
4135   boolean player_is_moving = (player->MovPos != 0 ? TRUE : FALSE);
4136   int sx = SCREENX(jx);
4137   int sy = SCREENY(jy);
4138   int sxx = (move_dir == MV_LEFT || move_dir == MV_RIGHT ? player->GfxPos : 0);
4139   int syy = (move_dir == MV_UP   || move_dir == MV_DOWN  ? player->GfxPos : 0);
4140   int element = Tile[jx][jy];
4141   int last_element = Tile[last_jx][last_jy];
4142   int action = (player->is_pushing    ? ACTION_PUSHING         :
4143                 player->is_digging    ? ACTION_DIGGING         :
4144                 player->is_collecting ? ACTION_COLLECTING      :
4145                 player->is_moving     ? ACTION_MOVING          :
4146                 player->is_snapping   ? ACTION_SNAPPING        :
4147                 player->is_dropping   ? ACTION_DROPPING        :
4148                 player->is_waiting    ? player->action_waiting :
4149                 ACTION_DEFAULT);
4150
4151   if (drawing_stage == DRAW_PLAYER_STAGE_INIT)
4152   {
4153     // ------------------------------------------------------------------------
4154     // initialize drawing the player
4155     // ------------------------------------------------------------------------
4156
4157     draw_player[pnr] = FALSE;
4158
4159     // GfxElement[][] is set to the element the player is digging or collecting;
4160     // remove also for off-screen player if the player is not moving anymore
4161     if (IN_LEV_FIELD(jx, jy) && !player_is_moving)
4162       GfxElement[jx][jy] = EL_UNDEFINED;
4163
4164     if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
4165       return;
4166
4167     if (element == EL_EXPLOSION)
4168       return;
4169
4170     InitPlayerGfxAnimation(player, action, move_dir);
4171
4172     draw_player[pnr] = TRUE;
4173   }
4174   else if (drawing_stage == DRAW_PLAYER_STAGE_LAST_FIELD)
4175   {
4176     // ------------------------------------------------------------------------
4177     // draw things in the field the player is leaving, if needed
4178     // ------------------------------------------------------------------------
4179
4180     if (!IN_SCR_FIELD(sx, sy))
4181       draw_player[pnr] = FALSE;
4182
4183     if (!player->is_moving)
4184       return;
4185
4186     if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
4187     {
4188       DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
4189
4190       if (last_element == EL_DYNAMITE_ACTIVE ||
4191           last_element == EL_EM_DYNAMITE_ACTIVE ||
4192           last_element == EL_SP_DISK_RED_ACTIVE)
4193         DrawDynamite(last_jx, last_jy);
4194       else
4195         DrawLevelFieldThruMask(last_jx, last_jy);
4196     }
4197     else if (last_element == EL_DYNAMITE_ACTIVE ||
4198              last_element == EL_EM_DYNAMITE_ACTIVE ||
4199              last_element == EL_SP_DISK_RED_ACTIVE)
4200       DrawDynamite(last_jx, last_jy);
4201     else
4202       DrawLevelField(last_jx, last_jy);
4203   }
4204   else if (drawing_stage == DRAW_PLAYER_STAGE_FIELD_UNDER_PLAYER)
4205   {
4206     // ------------------------------------------------------------------------
4207     // draw things behind the player, if needed
4208     // ------------------------------------------------------------------------
4209
4210     if (Back[jx][jy])
4211     {
4212       DrawLevelElement(jx, jy, Back[jx][jy]);
4213
4214       return;
4215     }
4216
4217     if (IS_ACTIVE_BOMB(element))
4218     {
4219       DrawLevelElement(jx, jy, EL_EMPTY);
4220
4221       return;
4222     }
4223
4224     if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
4225     {
4226       int old_element = GfxElement[jx][jy];
4227       int old_graphic = el_act_dir2img(old_element, action, move_dir);
4228       int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
4229
4230       if (GFX_CRUMBLED(old_element))
4231         DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
4232       else
4233         DrawScreenGraphic(sx, sy, old_graphic, frame);
4234
4235       if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
4236         static_player_is_opaque[pnr] = TRUE;
4237     }
4238     else
4239     {
4240       GfxElement[jx][jy] = EL_UNDEFINED;
4241
4242       // make sure that pushed elements are drawn with correct frame rate
4243       int graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
4244
4245       if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
4246         GfxFrame[jx][jy] = player->StepFrame;
4247
4248       DrawLevelField(jx, jy);
4249     }
4250   }
4251   else if (drawing_stage == DRAW_PLAYER_STAGE_ELEMENT_PUSHED)
4252   {
4253     // ------------------------------------------------------------------------
4254     // draw things the player is pushing, if needed
4255     // ------------------------------------------------------------------------
4256
4257     if (!player->is_pushing || !player->is_moving)
4258       return;
4259
4260     if (Tile[next_jx][next_jy] == EL_EXPLOSION)
4261       return;
4262
4263     int gfx_frame = GfxFrame[jx][jy];
4264
4265     if (!IS_MOVING(jx, jy))             // push movement already finished
4266     {
4267       element = Tile[next_jx][next_jy];
4268       gfx_frame = GfxFrame[next_jx][next_jy];
4269     }
4270
4271     int graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
4272     int sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
4273     int frame = getGraphicAnimationFrame(graphic, sync_frame);
4274
4275     // draw background element under pushed element (like the Sokoban field)
4276     if (game.use_masked_pushing && IS_MOVING(jx, jy))
4277     {
4278       // this allows transparent pushing animation over non-black background
4279
4280       if (Back[jx][jy])
4281         DrawLevelElement(jx, jy, Back[jx][jy]);
4282       else
4283         DrawLevelElement(jx, jy, EL_EMPTY);
4284     }
4285
4286     if (Back[next_jx][next_jy])
4287       DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
4288     else
4289       DrawLevelElement(next_jx, next_jy, EL_EMPTY);
4290
4291     int px = SCREENX(jx), py = SCREENY(jy);
4292     int pxx = (TILEX - ABS(sxx)) * dx;
4293     int pyy = (TILEY - ABS(syy)) * dy;
4294
4295 #if 1
4296     // do not draw (EM style) pushing animation when pushing is finished
4297     // (two-tile animations usually do not contain start and end frame)
4298     if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
4299       DrawLevelElement(next_jx, next_jy, Tile[next_jx][next_jy]);
4300     else
4301       DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4302 #else
4303     // masked drawing is needed for EMC style (double) movement graphics
4304     // !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!!
4305     DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4306 #endif
4307   }
4308   else if (drawing_stage == DRAW_PLAYER_STAGE_PLAYER)
4309   {
4310     // ------------------------------------------------------------------------
4311     // draw player himself
4312     // ------------------------------------------------------------------------
4313
4314     int graphic = getPlayerGraphic(player, move_dir);
4315
4316     // in the case of changed player action or direction, prevent the current
4317     // animation frame from being restarted for identical animations
4318     if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
4319       player->Frame = last_player_frame;
4320
4321     int frame = getGraphicAnimationFrame(graphic, player->Frame);
4322
4323     if (player_is_opaque)
4324       DrawGraphicShifted(sx,sy, sxx,syy, graphic, frame, NO_CUTTING,NO_MASKING);
4325     else
4326       DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4327
4328     if (SHIELD_ON(player))
4329     {
4330       graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
4331                  IMG_SHIELD_NORMAL_ACTIVE);
4332       frame = getGraphicAnimationFrame(graphic, -1);
4333
4334       DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4335     }
4336   }
4337   else if (drawing_stage == DRAW_PLAYER_STAGE_ELEMENT_OVER_PLAYER)
4338   {
4339     // ------------------------------------------------------------------------
4340     // draw things in front of player (active dynamite or dynabombs)
4341     // ------------------------------------------------------------------------
4342
4343     if (IS_ACTIVE_BOMB(element))
4344     {
4345       int graphic = el2img(element);
4346       int frame = getGraphicAnimationFrameXY(graphic, jx, jy);
4347
4348       if (game.emulation == EMU_SUPAPLEX)
4349         DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
4350       else
4351         DrawGraphicThruMask(sx, sy, graphic, frame);
4352     }
4353
4354     if (player_is_moving && last_element == EL_EXPLOSION)
4355     {
4356       int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
4357                      GfxElement[last_jx][last_jy] :  EL_EMPTY);
4358       int graphic = el_act2img(element, ACTION_EXPLODING);
4359       int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
4360       int phase = ExplodePhase[last_jx][last_jy] - 1;
4361       int frame = getGraphicAnimationFrame(graphic, phase - delay);
4362
4363       if (phase >= delay)
4364         DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
4365     }
4366   }
4367   else if (drawing_stage == DRAW_PLAYER_STAGE_FIELD_OVER_PLAYER)
4368   {
4369     // ------------------------------------------------------------------------
4370     // draw elements the player is just walking/passing through/under
4371     // ------------------------------------------------------------------------
4372
4373     if (player_is_moving)
4374     {
4375       // handle the field the player is leaving ...
4376       if (IS_ACCESSIBLE_INSIDE(last_element))
4377         DrawLevelField(last_jx, last_jy);
4378       else if (IS_ACCESSIBLE_UNDER(last_element))
4379         DrawLevelFieldThruMask(last_jx, last_jy);
4380     }
4381
4382     // do not redraw accessible elements if the player is just pushing them
4383     if (!player_is_moving || !player->is_pushing)
4384     {
4385       // ... and the field the player is entering
4386       if (IS_ACCESSIBLE_INSIDE(element))
4387         DrawLevelField(jx, jy);
4388       else if (IS_ACCESSIBLE_UNDER(element))
4389         DrawLevelFieldThruMask(jx, jy);
4390     }
4391
4392     MarkTileDirty(sx, sy);
4393   }
4394 }
4395
4396 void DrawPlayer(struct PlayerInfo *player)
4397 {
4398   int i;
4399
4400   for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4401     DrawPlayerExt(player, i);
4402 }
4403
4404 void DrawAllPlayers(void)
4405 {
4406   int i, j;
4407
4408   for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4409     for (j = 0; j < MAX_PLAYERS; j++)
4410       if (stored_player[j].active)
4411         DrawPlayerExt(&stored_player[j], i);
4412 }
4413
4414 void DrawPlayerField(int x, int y)
4415 {
4416   if (!IS_PLAYER(x, y))
4417     return;
4418
4419   DrawPlayer(PLAYERINFO(x, y));
4420 }
4421
4422 // ----------------------------------------------------------------------------
4423
4424 void WaitForEventToContinue(void)
4425 {
4426   boolean first_wait = TRUE;
4427   boolean still_wait = TRUE;
4428
4429   if (program.headless)
4430     return;
4431
4432   // simulate releasing mouse button over last gadget, if still pressed
4433   if (button_status)
4434     HandleGadgets(-1, -1, 0);
4435
4436   button_status = MB_RELEASED;
4437
4438   ClearEventQueue();
4439   ClearPlayerAction();
4440
4441   while (still_wait)
4442   {
4443     Event event;
4444
4445     if (NextValidEvent(&event))
4446     {
4447       switch (event.type)
4448       {
4449         case EVENT_BUTTONPRESS:
4450         case EVENT_FINGERPRESS:
4451           first_wait = FALSE;
4452           break;
4453
4454         case EVENT_BUTTONRELEASE:
4455         case EVENT_FINGERRELEASE:
4456           still_wait = first_wait;
4457           break;
4458
4459         case EVENT_KEYPRESS:
4460         case SDL_CONTROLLERBUTTONDOWN:
4461         case SDL_JOYBUTTONDOWN:
4462           still_wait = FALSE;
4463           break;
4464
4465         default:
4466           HandleOtherEvents(&event);
4467           break;
4468       }
4469     }
4470     else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4471     {
4472       still_wait = FALSE;
4473     }
4474
4475     if (!PendingEvent())
4476       BackToFront();
4477   }
4478 }
4479
4480 #define MAX_REQUEST_LINES               13
4481 #define MAX_REQUEST_LINE_FONT1_LEN      7
4482 #define MAX_REQUEST_LINE_FONT2_LEN      10
4483
4484 static int RequestHandleEvents(unsigned int req_state, int draw_buffer_game)
4485 {
4486   boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
4487   int draw_buffer_last = GetDrawtoField();
4488   int width  = request.width;
4489   int height = request.height;
4490   int sx, sy;
4491   int result;
4492
4493   setRequestPosition(&sx, &sy, FALSE);
4494
4495   button_status = MB_RELEASED;
4496
4497   request_gadget_id = -1;
4498   result = -1;
4499
4500   while (result < 0)
4501   {
4502     if (game_ended)
4503     {
4504       SetDrawtoField(draw_buffer_game);
4505
4506       HandleGameActions();
4507
4508       SetDrawtoField(DRAW_TO_BACKBUFFER);
4509     }
4510
4511     if (PendingEvent())
4512     {
4513       Event event;
4514
4515       while (NextValidEvent(&event))
4516       {
4517         switch (event.type)
4518         {
4519           case EVENT_BUTTONPRESS:
4520           case EVENT_BUTTONRELEASE:
4521           case EVENT_MOTIONNOTIFY:
4522           {
4523             DrawBuffer *drawto_last = drawto;
4524             int mx, my;
4525
4526             if (event.type == EVENT_MOTIONNOTIFY)
4527             {
4528               if (!button_status)
4529                 continue;
4530
4531               motion_status = TRUE;
4532               mx = ((MotionEvent *) &event)->x;
4533               my = ((MotionEvent *) &event)->y;
4534             }
4535             else
4536             {
4537               motion_status = FALSE;
4538               mx = ((ButtonEvent *) &event)->x;
4539               my = ((ButtonEvent *) &event)->y;
4540               if (event.type == EVENT_BUTTONPRESS)
4541                 button_status = ((ButtonEvent *) &event)->button;
4542               else
4543                 button_status = MB_RELEASED;
4544             }
4545
4546             if (global.use_envelope_request)
4547             {
4548               // draw changed button states to temporary bitmap
4549               drawto = bitmap_db_store_1;
4550             }
4551
4552             // this sets 'request_gadget_id'
4553             HandleGadgets(mx, my, button_status);
4554
4555             if (global.use_envelope_request)
4556             {
4557               // restore pointer to drawing buffer
4558               drawto = drawto_last;
4559
4560               // prepare complete envelope request from temporary bitmap
4561               PrepareEnvelopeRequestToScreen(bitmap_db_store_1, sx, sy,
4562                                              width, height);
4563             }
4564
4565             switch (request_gadget_id)
4566             {
4567               case TOOL_CTRL_ID_YES:
4568               case TOOL_CTRL_ID_TOUCH_YES:
4569                 result = TRUE;
4570                 break;
4571               case TOOL_CTRL_ID_NO:
4572               case TOOL_CTRL_ID_TOUCH_NO:
4573                 result = FALSE;
4574                 break;
4575               case TOOL_CTRL_ID_CONFIRM:
4576               case TOOL_CTRL_ID_TOUCH_CONFIRM:
4577                 result = TRUE | FALSE;
4578                 break;
4579
4580               case TOOL_CTRL_ID_PLAYER_1:
4581                 result = 1;
4582                 break;
4583               case TOOL_CTRL_ID_PLAYER_2:
4584                 result = 2;
4585                 break;
4586               case TOOL_CTRL_ID_PLAYER_3:
4587                 result = 3;
4588                 break;
4589               case TOOL_CTRL_ID_PLAYER_4:
4590                 result = 4;
4591                 break;
4592
4593               default:
4594                 // only check clickable animations if no request gadget clicked
4595                 HandleGlobalAnimClicks(mx, my, button_status, FALSE);
4596                 break;
4597             }
4598
4599             break;
4600           }
4601
4602           case SDL_WINDOWEVENT:
4603             HandleWindowEvent((WindowEvent *) &event);
4604             break;
4605
4606           case SDL_APP_WILLENTERBACKGROUND:
4607           case SDL_APP_DIDENTERBACKGROUND:
4608           case SDL_APP_WILLENTERFOREGROUND:
4609           case SDL_APP_DIDENTERFOREGROUND:
4610             HandlePauseResumeEvent((PauseResumeEvent *) &event);
4611             break;
4612
4613           case EVENT_KEYPRESS:
4614           {
4615             Key key = GetEventKey((KeyEvent *)&event);
4616
4617             switch (key)
4618             {
4619               case KSYM_space:
4620                 if (req_state & REQ_CONFIRM)
4621                   result = 1;
4622                 break;
4623
4624               case KSYM_Return:
4625               case KSYM_y:
4626               case KSYM_Y:
4627               case KSYM_Select:
4628               case KSYM_Menu:
4629 #if defined(KSYM_Rewind)
4630               case KSYM_Rewind:         // for Amazon Fire TV remote
4631 #endif
4632                 result = 1;
4633                 break;
4634
4635               case KSYM_Escape:
4636               case KSYM_n:
4637               case KSYM_N:
4638               case KSYM_Back:
4639 #if defined(KSYM_FastForward)
4640               case KSYM_FastForward:    // for Amazon Fire TV remote
4641 #endif
4642                 result = 0;
4643                 break;
4644
4645               default:
4646                 HandleKeysDebug(key, KEY_PRESSED);
4647                 break;
4648             }
4649
4650             if (req_state & REQ_PLAYER)
4651             {
4652               int old_player_nr = setup.network_player_nr;
4653
4654               if (result != -1)
4655                 result = old_player_nr + 1;
4656
4657               switch (key)
4658               {
4659                 case KSYM_space:
4660                   result = old_player_nr + 1;
4661                   break;
4662
4663                 case KSYM_Up:
4664                 case KSYM_1:
4665                   result = 1;
4666                   break;
4667
4668                 case KSYM_Right:
4669                 case KSYM_2:
4670                   result = 2;
4671                   break;
4672
4673                 case KSYM_Down:
4674                 case KSYM_3:
4675                   result = 3;
4676                   break;
4677
4678                 case KSYM_Left:
4679                 case KSYM_4:
4680                   result = 4;
4681                   break;
4682
4683                 default:
4684                   break;
4685               }
4686             }
4687
4688             break;
4689           }
4690
4691           case EVENT_FINGERRELEASE:
4692           case EVENT_KEYRELEASE:
4693             ClearPlayerAction();
4694             break;
4695
4696           case SDL_CONTROLLERBUTTONDOWN:
4697             switch (event.cbutton.button)
4698             {
4699               case SDL_CONTROLLER_BUTTON_A:
4700               case SDL_CONTROLLER_BUTTON_X:
4701               case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
4702               case SDL_CONTROLLER_BUTTON_LEFTSTICK:
4703                 result = 1;
4704                 break;
4705
4706               case SDL_CONTROLLER_BUTTON_B:
4707               case SDL_CONTROLLER_BUTTON_Y:
4708               case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
4709               case SDL_CONTROLLER_BUTTON_RIGHTSTICK:
4710               case SDL_CONTROLLER_BUTTON_BACK:
4711                 result = 0;
4712                 break;
4713             }
4714
4715             if (req_state & REQ_PLAYER)
4716             {
4717               int old_player_nr = setup.network_player_nr;
4718
4719               if (result != -1)
4720                 result = old_player_nr + 1;
4721
4722               switch (event.cbutton.button)
4723               {
4724                 case SDL_CONTROLLER_BUTTON_DPAD_UP:
4725                 case SDL_CONTROLLER_BUTTON_Y:
4726                   result = 1;
4727                   break;
4728
4729                 case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
4730                 case SDL_CONTROLLER_BUTTON_B:
4731                   result = 2;
4732                   break;
4733
4734                 case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
4735                 case SDL_CONTROLLER_BUTTON_A:
4736                   result = 3;
4737                   break;
4738
4739                 case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
4740                 case SDL_CONTROLLER_BUTTON_X:
4741                   result = 4;
4742                   break;
4743
4744                 default:
4745                   break;
4746               }
4747             }
4748
4749             break;
4750
4751           case SDL_CONTROLLERBUTTONUP:
4752             HandleJoystickEvent(&event);
4753             ClearPlayerAction();
4754             break;
4755
4756           default:
4757             HandleOtherEvents(&event);
4758             break;
4759         }
4760       }
4761     }
4762     else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4763     {
4764       int joy = AnyJoystick();
4765
4766       if (joy & JOY_BUTTON_1)
4767         result = 1;
4768       else if (joy & JOY_BUTTON_2)
4769         result = 0;
4770     }
4771     else if (AnyJoystick())
4772     {
4773       int joy = AnyJoystick();
4774
4775       if (req_state & REQ_PLAYER)
4776       {
4777         if (joy & JOY_UP)
4778           result = 1;
4779         else if (joy & JOY_RIGHT)
4780           result = 2;
4781         else if (joy & JOY_DOWN)
4782           result = 3;
4783         else if (joy & JOY_LEFT)
4784           result = 4;
4785       }
4786     }
4787
4788     BackToFront();
4789   }
4790
4791   SetDrawtoField(draw_buffer_last);
4792
4793   return result;
4794 }
4795
4796 static void DoRequestBefore(unsigned int req_state)
4797 {
4798   if (game_status == GAME_MODE_PLAYING)
4799     BlitScreenToBitmap(backbuffer);
4800
4801   // disable deactivated drawing when quick-loading level tape recording
4802   if (tape.playing && tape.deactivate_display)
4803     TapeDeactivateDisplayOff(TRUE);
4804
4805   SetMouseCursor(CURSOR_DEFAULT);
4806
4807   // pause network game while waiting for request to answer
4808   if (network.enabled &&
4809       game_status == GAME_MODE_PLAYING &&
4810       !game.all_players_gone &&
4811       req_state & REQUEST_WAIT_FOR_INPUT)
4812     SendToServer_PausePlaying();
4813
4814   // simulate releasing mouse button over last gadget, if still pressed
4815   if (button_status)
4816     HandleGadgets(-1, -1, 0);
4817
4818   UnmapAllGadgets();
4819 }
4820
4821 static void DoRequestAfter(unsigned int req_state)
4822 {
4823   RemapAllGadgets();
4824
4825   if (game_status == GAME_MODE_PLAYING)
4826   {
4827     SetPanelBackground();
4828     SetDrawBackgroundMask(REDRAW_DOOR_1);
4829   }
4830   else
4831   {
4832     SetDrawBackgroundMask(REDRAW_FIELD);
4833   }
4834
4835   // continue network game after request
4836   if (network.enabled &&
4837       game_status == GAME_MODE_PLAYING &&
4838       !game.all_players_gone &&
4839       req_state & REQUEST_WAIT_FOR_INPUT)
4840     SendToServer_ContinuePlaying();
4841
4842   // restore deactivated drawing when quick-loading level tape recording
4843   if (tape.playing && tape.deactivate_display)
4844     TapeDeactivateDisplayOn();
4845 }
4846
4847 static boolean RequestDoor(char *text, unsigned int req_state)
4848 {
4849   int draw_buffer_last = GetDrawtoField();
4850   unsigned int old_door_state = GetDoorState();
4851   int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN;
4852   int font_nr = FONT_TEXT_2;
4853   char *text_ptr;
4854   int result;
4855   int ty;
4856
4857   if (maxWordLengthInRequestString(text) > MAX_REQUEST_LINE_FONT1_LEN)
4858   {
4859     max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
4860     font_nr = FONT_TEXT_1;
4861   }
4862
4863   DoRequestBefore(req_state);
4864
4865   // draw released gadget before proceeding
4866   // BackToFront();
4867
4868   if (old_door_state & DOOR_OPEN_1)
4869   {
4870     CloseDoor(DOOR_CLOSE_1);
4871
4872     // save old door content
4873     BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
4874                0 * DXSIZE, 0, DXSIZE, DYSIZE, 1 * DXSIZE, 0);
4875   }
4876
4877   SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
4878   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4879
4880   // clear door drawing field
4881   DrawBackground(DX, DY, DXSIZE, DYSIZE);
4882
4883   // force DOOR font inside door area
4884   SetFontStatus(GAME_MODE_PSEUDO_DOOR);
4885
4886   // write text for request
4887   for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
4888   {
4889     char text_line[max_request_line_len + 1];
4890     int tx, tl, tc = 0;
4891
4892     if (!*text_ptr)
4893       break;
4894
4895     for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
4896     {
4897       tc = *(text_ptr + tx);
4898       // if (!tc || tc == ' ')
4899       if (!tc || tc == ' ' || tc == '?' || tc == '!')
4900         break;
4901     }
4902
4903     if ((tc == '?' || tc == '!') && tl == 0)
4904       tl = 1;
4905
4906     if (!tl)
4907     {
4908       text_ptr++;
4909       ty--;
4910       continue;
4911     }
4912
4913     strncpy(text_line, text_ptr, tl);
4914     text_line[tl] = 0;
4915
4916     DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
4917              DY + 8 + ty * (getFontHeight(font_nr) + 2),
4918              text_line, font_nr);
4919
4920     text_ptr += tl + (tc == ' ' ? 1 : 0);
4921     // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
4922   }
4923
4924   ResetFontStatus();
4925
4926   MapToolButtons(req_state);
4927
4928   // copy request gadgets to door backbuffer
4929   BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4930
4931   OpenDoor(DOOR_OPEN_1);
4932
4933   if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4934   {
4935     if (game_status == GAME_MODE_PLAYING)
4936     {
4937       SetPanelBackground();
4938       SetDrawBackgroundMask(REDRAW_DOOR_1);
4939     }
4940     else
4941     {
4942       SetDrawBackgroundMask(REDRAW_FIELD);
4943     }
4944
4945     return FALSE;
4946   }
4947
4948   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4949
4950   // ---------- handle request buttons ----------
4951   result = RequestHandleEvents(req_state, draw_buffer_last);
4952
4953   UnmapToolButtons();
4954
4955   if (!(req_state & REQ_STAY_OPEN))
4956   {
4957     CloseDoor(DOOR_CLOSE_1);
4958
4959     if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
4960         (req_state & REQ_REOPEN))
4961       OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
4962   }
4963
4964   DoRequestAfter(req_state);
4965
4966   return result;
4967 }
4968
4969 static boolean RequestEnvelope(char *text, unsigned int req_state)
4970 {
4971   int draw_buffer_last = GetDrawtoField();
4972   int result;
4973
4974   DoRequestBefore(req_state);
4975
4976   ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
4977
4978   if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4979   {
4980     if (game_status == GAME_MODE_PLAYING)
4981     {
4982       SetPanelBackground();
4983       SetDrawBackgroundMask(REDRAW_DOOR_1);
4984     }
4985     else
4986     {
4987       SetDrawBackgroundMask(REDRAW_FIELD);
4988     }
4989
4990     return FALSE;
4991   }
4992
4993   SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4994
4995   // ---------- handle request buttons ----------
4996   result = RequestHandleEvents(req_state, draw_buffer_last);
4997
4998   UnmapToolButtons();
4999
5000   ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
5001
5002   DoRequestAfter(req_state);
5003
5004   return result;
5005 }
5006
5007 boolean Request(char *text, unsigned int req_state)
5008 {
5009   boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
5010   boolean overlay_enabled = GetOverlayEnabled();
5011   boolean result;
5012
5013   // when showing request dialog after game ended, deactivate game panel
5014   if (game_ended)
5015     game.panel.active = FALSE;
5016
5017   game.request_active = TRUE;
5018
5019   SetOverlayEnabled(FALSE);
5020
5021   if (global.use_envelope_request)
5022     result = RequestEnvelope(text, req_state);
5023   else
5024     result = RequestDoor(text, req_state);
5025
5026   SetOverlayEnabled(overlay_enabled);
5027
5028   game.request_active = FALSE;
5029
5030   return result;
5031 }
5032
5033 static int compareDoorPartOrderInfo(const void *object1, const void *object2)
5034 {
5035   const struct DoorPartOrderInfo *dpo1 = (struct DoorPartOrderInfo *)object1;
5036   const struct DoorPartOrderInfo *dpo2 = (struct DoorPartOrderInfo *)object2;
5037   int compare_result;
5038
5039   if (dpo1->sort_priority != dpo2->sort_priority)
5040     compare_result = dpo1->sort_priority - dpo2->sort_priority;
5041   else
5042     compare_result = dpo1->nr - dpo2->nr;
5043
5044   return compare_result;
5045 }
5046
5047 void InitGraphicCompatibilityInfo_Doors(void)
5048 {
5049   struct
5050   {
5051     int door_token;
5052     int part_1, part_8;
5053     struct DoorInfo *door;
5054   }
5055   doors[] =
5056   {
5057     { DOOR_1,   IMG_GFX_DOOR_1_PART_1,  IMG_GFX_DOOR_1_PART_8,  &door_1 },
5058     { DOOR_2,   IMG_GFX_DOOR_2_PART_1,  IMG_GFX_DOOR_2_PART_8,  &door_2 },
5059
5060     { -1,       -1,                     -1,                     NULL    }
5061   };
5062   struct Rect door_rect_list[] =
5063   {
5064     { DX, DY, DXSIZE, DYSIZE },
5065     { VX, VY, VXSIZE, VYSIZE }
5066   };
5067   int i, j;
5068
5069   for (i = 0; doors[i].door_token != -1; i++)
5070   {
5071     int door_token = doors[i].door_token;
5072     int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5073     int part_1 = doors[i].part_1;
5074     int part_8 = doors[i].part_8;
5075     int part_2 = part_1 + 1;
5076     int part_3 = part_1 + 2;
5077     struct DoorInfo *door = doors[i].door;
5078     struct Rect *door_rect = &door_rect_list[door_index];
5079     boolean door_gfx_redefined = FALSE;
5080
5081     // check if any door part graphic definitions have been redefined
5082
5083     for (j = 0; door_part_controls[j].door_token != -1; j++)
5084     {
5085       struct DoorPartControlInfo *dpc = &door_part_controls[j];
5086       struct FileInfo *fi = getImageListEntryFromImageID(dpc->graphic);
5087
5088       if (dpc->door_token == door_token && fi->redefined)
5089         door_gfx_redefined = TRUE;
5090     }
5091
5092     // check for old-style door graphic/animation modifications
5093
5094     if (!door_gfx_redefined)
5095     {
5096       if (door->anim_mode & ANIM_STATIC_PANEL)
5097       {
5098         door->panel.step_xoffset = 0;
5099         door->panel.step_yoffset = 0;
5100       }
5101
5102       if (door->anim_mode & (ANIM_HORIZONTAL | ANIM_VERTICAL))
5103       {
5104         struct GraphicInfo *g_part_1 = &graphic_info[part_1];
5105         struct GraphicInfo *g_part_2 = &graphic_info[part_2];
5106         int num_door_steps, num_panel_steps;
5107
5108         // remove door part graphics other than the two default wings
5109
5110         for (j = 0; door_part_controls[j].door_token != -1; j++)
5111         {
5112           struct DoorPartControlInfo *dpc = &door_part_controls[j];
5113           struct GraphicInfo *g = &graphic_info[dpc->graphic];
5114
5115           if (dpc->graphic >= part_3 &&
5116               dpc->graphic <= part_8)
5117             g->bitmap = NULL;
5118         }
5119
5120         // set graphics and screen positions of the default wings
5121
5122         g_part_1->width  = door_rect->width;
5123         g_part_1->height = door_rect->height;
5124         g_part_2->width  = door_rect->width;
5125         g_part_2->height = door_rect->height;
5126         g_part_2->src_x = door_rect->width;
5127         g_part_2->src_y = g_part_1->src_y;
5128
5129         door->part_2.x = door->part_1.x;
5130         door->part_2.y = door->part_1.y;
5131
5132         if (door->width != -1)
5133         {
5134           g_part_1->width = door->width;
5135           g_part_2->width = door->width;
5136
5137           // special treatment for graphics and screen position of right wing
5138           g_part_2->src_x += door_rect->width - door->width;
5139           door->part_2.x  += door_rect->width - door->width;
5140         }
5141
5142         if (door->height != -1)
5143         {
5144           g_part_1->height = door->height;
5145           g_part_2->height = door->height;
5146
5147           // special treatment for graphics and screen position of bottom wing
5148           g_part_2->src_y += door_rect->height - door->height;
5149           door->part_2.y  += door_rect->height - door->height;
5150         }
5151
5152         // set animation delays for the default wings and panels
5153
5154         door->part_1.step_delay = door->step_delay;
5155         door->part_2.step_delay = door->step_delay;
5156         door->panel.step_delay  = door->step_delay;
5157
5158         // set animation draw order for the default wings
5159
5160         door->part_1.sort_priority = 2; // draw left wing over ...
5161         door->part_2.sort_priority = 1; //          ... right wing
5162
5163         // set animation draw offset for the default wings
5164
5165         if (door->anim_mode & ANIM_HORIZONTAL)
5166         {
5167           door->part_1.step_xoffset = door->step_offset;
5168           door->part_1.step_yoffset = 0;
5169           door->part_2.step_xoffset = door->step_offset * -1;
5170           door->part_2.step_yoffset = 0;
5171
5172           num_door_steps = g_part_1->width / door->step_offset;
5173         }
5174         else    // ANIM_VERTICAL
5175         {
5176           door->part_1.step_xoffset = 0;
5177           door->part_1.step_yoffset = door->step_offset;
5178           door->part_2.step_xoffset = 0;
5179           door->part_2.step_yoffset = door->step_offset * -1;
5180
5181           num_door_steps = g_part_1->height / door->step_offset;
5182         }
5183
5184         // set animation draw offset for the default panels
5185
5186         if (door->step_offset > 1)
5187         {
5188           num_panel_steps = 2 * door_rect->height / door->step_offset;
5189           door->panel.start_step = num_panel_steps - num_door_steps;
5190           door->panel.start_step_closing = door->panel.start_step;
5191         }
5192         else
5193         {
5194           num_panel_steps = door_rect->height / door->step_offset;
5195           door->panel.start_step = num_panel_steps - num_door_steps / 2;
5196           door->panel.start_step_closing = door->panel.start_step;
5197           door->panel.step_delay *= 2;
5198         }
5199       }
5200     }
5201   }
5202 }
5203
5204 void InitDoors(void)
5205 {
5206   int i;
5207
5208   for (i = 0; door_part_controls[i].door_token != -1; i++)
5209   {
5210     struct DoorPartControlInfo *dpc = &door_part_controls[i];
5211     struct DoorPartOrderInfo *dpo = &door_part_order[i];
5212
5213     // initialize "start_step_opening" and "start_step_closing", if needed
5214     if (dpc->pos->start_step_opening == 0 &&
5215         dpc->pos->start_step_closing == 0)
5216     {
5217       // dpc->pos->start_step_opening = dpc->pos->start_step;
5218       dpc->pos->start_step_closing = dpc->pos->start_step;
5219     }
5220
5221     // fill structure for door part draw order (sorted below)
5222     dpo->nr = i;
5223     dpo->sort_priority = dpc->pos->sort_priority;
5224   }
5225
5226   // sort door part controls according to sort_priority and graphic number
5227   qsort(door_part_order, MAX_DOOR_PARTS,
5228         sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
5229 }
5230
5231 unsigned int OpenDoor(unsigned int door_state)
5232 {
5233   if (door_state & DOOR_COPY_BACK)
5234   {
5235     if (door_state & DOOR_OPEN_1)
5236       BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
5237                  1 * DXSIZE, 0, DXSIZE, DYSIZE, 0 * DXSIZE, 0);
5238
5239     if (door_state & DOOR_OPEN_2)
5240       BlitBitmap(bitmap_db_door_2, bitmap_db_door_2,
5241                  1 * VXSIZE, 0, VXSIZE, VYSIZE, 0 * VXSIZE, 0);
5242
5243     door_state &= ~DOOR_COPY_BACK;
5244   }
5245
5246   return MoveDoor(door_state);
5247 }
5248
5249 unsigned int CloseDoor(unsigned int door_state)
5250 {
5251   unsigned int old_door_state = GetDoorState();
5252
5253   if (!(door_state & DOOR_NO_COPY_BACK))
5254   {
5255     if (old_door_state & DOOR_OPEN_1)
5256       BlitBitmap(backbuffer, bitmap_db_door_1,
5257                  DX, DY, DXSIZE, DYSIZE, 0, 0);
5258
5259     if (old_door_state & DOOR_OPEN_2)
5260       BlitBitmap(backbuffer, bitmap_db_door_2,
5261                  VX, VY, VXSIZE, VYSIZE, 0, 0);
5262
5263     door_state &= ~DOOR_NO_COPY_BACK;
5264   }
5265
5266   return MoveDoor(door_state);
5267 }
5268
5269 unsigned int GetDoorState(void)
5270 {
5271   return MoveDoor(DOOR_GET_STATE);
5272 }
5273
5274 unsigned int SetDoorState(unsigned int door_state)
5275 {
5276   return MoveDoor(door_state | DOOR_SET_STATE);
5277 }
5278
5279 static int euclid(int a, int b)
5280 {
5281   return (b ? euclid(b, a % b) : a);
5282 }
5283
5284 unsigned int MoveDoor(unsigned int door_state)
5285 {
5286   struct Rect door_rect_list[] =
5287   {
5288     { DX, DY, DXSIZE, DYSIZE },
5289     { VX, VY, VXSIZE, VYSIZE }
5290   };
5291   static int door1 = DOOR_CLOSE_1;
5292   static int door2 = DOOR_CLOSE_2;
5293   DelayCounter door_delay = { 0 };
5294   int i;
5295
5296   if (door_state == DOOR_GET_STATE)
5297     return (door1 | door2);
5298
5299   if (door_state & DOOR_SET_STATE)
5300   {
5301     if (door_state & DOOR_ACTION_1)
5302       door1 = door_state & DOOR_ACTION_1;
5303     if (door_state & DOOR_ACTION_2)
5304       door2 = door_state & DOOR_ACTION_2;
5305
5306     return (door1 | door2);
5307   }
5308
5309   if (!(door_state & DOOR_FORCE_REDRAW))
5310   {
5311     if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
5312       door_state &= ~DOOR_OPEN_1;
5313     else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
5314       door_state &= ~DOOR_CLOSE_1;
5315     if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
5316       door_state &= ~DOOR_OPEN_2;
5317     else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
5318       door_state &= ~DOOR_CLOSE_2;
5319   }
5320
5321   if (global.autoplay_leveldir)
5322   {
5323     door_state |= DOOR_NO_DELAY;
5324     door_state &= ~DOOR_CLOSE_ALL;
5325   }
5326
5327   if (game_status == GAME_MODE_EDITOR && !(door_state & DOOR_FORCE_ANIM))
5328     door_state |= DOOR_NO_DELAY;
5329
5330   if (door_state & DOOR_ACTION)
5331   {
5332     boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
5333     boolean door_panel_drawn[NUM_DOORS];
5334     boolean panel_has_doors[NUM_DOORS];
5335     boolean door_part_skip[MAX_DOOR_PARTS];
5336     boolean door_part_done[MAX_DOOR_PARTS];
5337     boolean door_part_done_all;
5338     int num_steps[MAX_DOOR_PARTS];
5339     int max_move_delay = 0;     // delay for complete animations of all doors
5340     int max_step_delay = 0;     // delay (ms) between two animation frames
5341     int num_move_steps = 0;     // number of animation steps for all doors
5342     int max_move_delay_doors_only = 0;  // delay for doors only (no panel)
5343     int num_move_steps_doors_only = 0;  // steps for doors only (no panel)
5344     int start = 0;
5345     int k;
5346
5347     for (i = 0; i < NUM_DOORS; i++)
5348       panel_has_doors[i] = FALSE;
5349
5350     for (i = 0; i < MAX_DOOR_PARTS; i++)
5351     {
5352       struct DoorPartControlInfo *dpc = &door_part_controls[i];
5353       struct GraphicInfo *g = &graphic_info[dpc->graphic];
5354       int door_token = dpc->door_token;
5355
5356       door_part_done[i] = FALSE;
5357       door_part_skip[i] = (!(door_state & door_token) ||
5358                            !g->bitmap);
5359     }
5360
5361     for (i = 0; i < MAX_DOOR_PARTS; i++)
5362     {
5363       int nr = door_part_order[i].nr;
5364       struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5365       struct DoorPartPosInfo *pos = dpc->pos;
5366       struct GraphicInfo *g = &graphic_info[dpc->graphic];
5367       int door_token = dpc->door_token;
5368       int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5369       boolean is_panel = DOOR_PART_IS_PANEL(nr);
5370       int step_xoffset = ABS(pos->step_xoffset);
5371       int step_yoffset = ABS(pos->step_yoffset);
5372       int step_delay = pos->step_delay;
5373       int current_door_state = door_state & door_token;
5374       boolean door_opening = ((current_door_state & DOOR_OPEN)  != 0);
5375       boolean door_closing = ((current_door_state & DOOR_CLOSE) != 0);
5376       boolean part_opening = (is_panel ? door_closing : door_opening);
5377       int start_step = (part_opening ? pos->start_step_opening :
5378                         pos->start_step_closing);
5379       float move_xsize = (step_xoffset ? g->width  : 0);
5380       float move_ysize = (step_yoffset ? g->height : 0);
5381       int move_xsteps = (step_xoffset ? ceil(move_xsize / step_xoffset) : 0);
5382       int move_ysteps = (step_yoffset ? ceil(move_ysize / step_yoffset) : 0);
5383       int move_steps = (move_xsteps && move_ysteps ?
5384                         MIN(move_xsteps, move_ysteps) :
5385                         move_xsteps ? move_xsteps : move_ysteps) - start_step;
5386       int move_delay = move_steps * step_delay;
5387
5388       if (door_part_skip[nr])
5389         continue;
5390
5391       max_move_delay = MAX(max_move_delay, move_delay);
5392       max_step_delay = (max_step_delay == 0 ? step_delay :
5393                         euclid(max_step_delay, step_delay));
5394       num_steps[nr] = move_steps;
5395
5396       if (!is_panel)
5397       {
5398         max_move_delay_doors_only = MAX(max_move_delay_doors_only, move_delay);
5399
5400         panel_has_doors[door_index] = TRUE;
5401       }
5402     }
5403
5404     max_step_delay = MAX(1, max_step_delay);    // prevent division by zero
5405
5406     num_move_steps = max_move_delay / max_step_delay;
5407     num_move_steps_doors_only = max_move_delay_doors_only / max_step_delay;
5408
5409     door_delay.value = max_step_delay;
5410
5411     if ((door_state & DOOR_NO_DELAY) || setup.quick_doors)
5412     {
5413       start = num_move_steps - 1;
5414     }
5415     else
5416     {
5417       // opening door sound has priority over simultaneously closing door
5418       if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
5419       {
5420         PlayMenuSoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
5421
5422         if (door_state & DOOR_OPEN_1)
5423           PlayMenuSoundStereo(SND_DOOR_1_OPENING, SOUND_MIDDLE);
5424         if (door_state & DOOR_OPEN_2)
5425           PlayMenuSoundStereo(SND_DOOR_2_OPENING, SOUND_MIDDLE);
5426       }
5427       else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
5428       {
5429         PlayMenuSoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
5430
5431         if (door_state & DOOR_CLOSE_1)
5432           PlayMenuSoundStereo(SND_DOOR_1_CLOSING, SOUND_MIDDLE);
5433         if (door_state & DOOR_CLOSE_2)
5434           PlayMenuSoundStereo(SND_DOOR_2_CLOSING, SOUND_MIDDLE);
5435       }
5436     }
5437
5438     for (k = start; k < num_move_steps; k++)
5439     {
5440       int last_frame = num_move_steps - 1;      // last frame of this "for" loop
5441
5442       door_part_done_all = TRUE;
5443
5444       for (i = 0; i < NUM_DOORS; i++)
5445         door_panel_drawn[i] = FALSE;
5446
5447       for (i = 0; i < MAX_DOOR_PARTS; i++)
5448       {
5449         int nr = door_part_order[i].nr;
5450         struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5451         struct DoorPartPosInfo *pos = dpc->pos;
5452         struct GraphicInfo *g = &graphic_info[dpc->graphic];
5453         int door_token = dpc->door_token;
5454         int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5455         boolean is_panel = DOOR_PART_IS_PANEL(nr);
5456         boolean is_panel_and_door_has_closed = FALSE;
5457         struct Rect *door_rect = &door_rect_list[door_index];
5458         Bitmap *bitmap_db_door = (door_token == DOOR_1 ? bitmap_db_door_1 :
5459                                   bitmap_db_door_2);
5460         Bitmap *bitmap = (is_panel ? bitmap_db_door : g->bitmap);
5461         int current_door_state = door_state & door_token;
5462         boolean door_opening = ((current_door_state & DOOR_OPEN)  != 0);
5463         boolean door_closing = !door_opening;
5464         boolean part_opening = (is_panel ? door_closing : door_opening);
5465         boolean part_closing = !part_opening;
5466         int start_step = (part_opening ? pos->start_step_opening :
5467                           pos->start_step_closing);
5468         int step_delay = pos->step_delay;
5469         int step_factor = step_delay / max_step_delay;
5470         int k1 = (step_factor ? k / step_factor + 1 : k);
5471         int k2 = (part_opening ? k1 + start_step : num_steps[nr] - k1);
5472         int kk = MAX(0, k2);
5473         int g_src_x = 0;
5474         int g_src_y = 0;
5475         int src_x, src_y, src_xx, src_yy;
5476         int dst_x, dst_y, dst_xx, dst_yy;
5477         int width, height;
5478
5479         if (door_part_skip[nr])
5480           continue;
5481
5482         if (!(door_state & door_token))
5483           continue;
5484
5485         if (!g->bitmap)
5486           continue;
5487
5488         if (!is_panel)
5489         {
5490           int k2_door = (door_opening ? k : num_move_steps_doors_only - k - 1);
5491           int kk_door = MAX(0, k2_door);
5492           int sync_frame = kk_door * door_delay.value;
5493           int frame = getGraphicAnimationFrame(dpc->graphic, sync_frame);
5494
5495           getFixedGraphicSource(dpc->graphic, frame, &bitmap,
5496                                 &g_src_x, &g_src_y);
5497         }
5498
5499         // draw door panel
5500
5501         if (!door_panel_drawn[door_index])
5502         {
5503           ClearRectangle(drawto, door_rect->x, door_rect->y,
5504                          door_rect->width, door_rect->height);
5505
5506           door_panel_drawn[door_index] = TRUE;
5507         }
5508
5509         // draw opening or closing door parts
5510
5511         if (pos->step_xoffset < 0)      // door part on right side
5512         {
5513           src_xx = 0;
5514           dst_xx = pos->x + ABS(kk * pos->step_xoffset);
5515           width = g->width;
5516
5517           if (dst_xx + width > door_rect->width)
5518             width = door_rect->width - dst_xx;
5519         }
5520         else                            // door part on left side
5521         {
5522           src_xx = 0;
5523           dst_xx = pos->x - kk * pos->step_xoffset;
5524
5525           if (dst_xx < 0)
5526           {
5527             src_xx = ABS(dst_xx);
5528             dst_xx = 0;
5529           }
5530
5531           width = g->width - src_xx;
5532
5533           if (width > door_rect->width)
5534             width = door_rect->width;
5535
5536           // Debug("tools:MoveDoor", "k == %d [%d]", k, start_step);
5537         }
5538
5539         if (pos->step_yoffset < 0)      // door part on bottom side
5540         {
5541           src_yy = 0;
5542           dst_yy = pos->y + ABS(kk * pos->step_yoffset);
5543           height = g->height;
5544
5545           if (dst_yy + height > door_rect->height)
5546             height = door_rect->height - dst_yy;
5547         }
5548         else                            // door part on top side
5549         {
5550           src_yy = 0;
5551           dst_yy = pos->y - kk * pos->step_yoffset;
5552
5553           if (dst_yy < 0)
5554           {
5555             src_yy = ABS(dst_yy);
5556             dst_yy = 0;
5557           }
5558
5559           height = g->height - src_yy;
5560         }
5561
5562         src_x = g_src_x + src_xx;
5563         src_y = g_src_y + src_yy;
5564
5565         dst_x = door_rect->x + dst_xx;
5566         dst_y = door_rect->y + dst_yy;
5567
5568         is_panel_and_door_has_closed =
5569           (is_panel &&
5570            door_closing &&
5571            panel_has_doors[door_index] &&
5572            k >= num_move_steps_doors_only - 1);
5573
5574         if (width  >= 0 && width  <= g->width &&
5575             height >= 0 && height <= g->height &&
5576             !is_panel_and_door_has_closed)
5577         {
5578           if (is_panel || !pos->draw_masked)
5579             BlitBitmap(bitmap, drawto, src_x, src_y, width, height,
5580                        dst_x, dst_y);
5581           else
5582             BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height,
5583                              dst_x, dst_y);
5584         }
5585
5586         redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
5587
5588         if ((part_opening && (width < 0         || height < 0)) ||
5589             (part_closing && (width >= g->width && height >= g->height)))
5590           door_part_done[nr] = TRUE;
5591
5592         // continue door part animations, but not panel after door has closed
5593         if (!door_part_done[nr] && !is_panel_and_door_has_closed)
5594           door_part_done_all = FALSE;
5595       }
5596
5597       if (!(door_state & DOOR_NO_DELAY))
5598       {
5599         if (game_ended)
5600           HandleGameActions();
5601
5602         BackToFront();
5603
5604         SkipUntilDelayReached(&door_delay, &k, last_frame);
5605
5606         // prevent OS (Windows) from complaining about program not responding
5607         CheckQuitEvent();
5608       }
5609
5610       if (door_part_done_all)
5611         break;
5612     }
5613
5614     if (!(door_state & DOOR_NO_DELAY))
5615     {
5616       // wait for specified door action post delay
5617       if (door_state & DOOR_ACTION_1 && door_state & DOOR_ACTION_2)
5618         door_delay.value = MAX(door_1.post_delay, door_2.post_delay);
5619       else if (door_state & DOOR_ACTION_1)
5620         door_delay.value = door_1.post_delay;
5621       else if (door_state & DOOR_ACTION_2)
5622         door_delay.value = door_2.post_delay;
5623
5624       while (!DelayReached(&door_delay))
5625       {
5626         if (game_ended)
5627           HandleGameActions();
5628
5629         BackToFront();
5630       }
5631     }
5632   }
5633
5634   if (door_state & DOOR_ACTION_1)
5635     door1 = door_state & DOOR_ACTION_1;
5636   if (door_state & DOOR_ACTION_2)
5637     door2 = door_state & DOOR_ACTION_2;
5638
5639   // draw masked border over door area
5640   DrawMaskedBorder(REDRAW_DOOR_1);
5641   DrawMaskedBorder(REDRAW_DOOR_2);
5642
5643   ClearAutoRepeatKeyEvents();
5644
5645   return (door1 | door2);
5646 }
5647
5648 static boolean useSpecialEditorDoor(void)
5649 {
5650   int graphic = IMG_GLOBAL_BORDER_EDITOR;
5651   boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
5652
5653   // do not draw special editor door if editor border defined or redefined
5654   if (graphic_info[graphic].bitmap != NULL || redefined)
5655     return FALSE;
5656
5657   // do not draw special editor door if global border defined to be empty
5658   if (graphic_info[IMG_GLOBAL_BORDER].bitmap == NULL)
5659     return FALSE;
5660
5661   // do not draw special editor door if viewport definitions do not match
5662   if (EX != VX ||
5663       EY >= VY ||
5664       EXSIZE != VXSIZE ||
5665       EY + EYSIZE != VY + VYSIZE)
5666     return FALSE;
5667
5668   return TRUE;
5669 }
5670
5671 void DrawSpecialEditorDoor(void)
5672 {
5673   struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5674   int top_border_width = gfx1->width;
5675   int top_border_height = gfx1->height;
5676   int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5677   int ex = EX - outer_border;
5678   int ey = EY - outer_border;
5679   int vy = VY - outer_border;
5680   int exsize = EXSIZE + 2 * outer_border;
5681
5682   if (!useSpecialEditorDoor())
5683     return;
5684
5685   // draw bigger level editor toolbox window
5686   BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
5687              top_border_width, top_border_height, ex, ey - top_border_height);
5688   BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
5689              exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
5690
5691   redraw_mask |= REDRAW_ALL;
5692 }
5693
5694 void UndrawSpecialEditorDoor(void)
5695 {
5696   struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5697   int top_border_width = gfx1->width;
5698   int top_border_height = gfx1->height;
5699   int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5700   int ex = EX - outer_border;
5701   int ey = EY - outer_border;
5702   int ey_top = ey - top_border_height;
5703   int exsize = EXSIZE + 2 * outer_border;
5704   int eysize = EYSIZE + 2 * outer_border;
5705
5706   if (!useSpecialEditorDoor())
5707     return;
5708
5709   // draw normal tape recorder window
5710   if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
5711   {
5712     BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5713                ex, ey_top, top_border_width, top_border_height,
5714                ex, ey_top);
5715     BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5716                ex, ey, exsize, eysize, ex, ey);
5717   }
5718   else
5719   {
5720     // if screen background is set to "[NONE]", clear editor toolbox window
5721     ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
5722     ClearRectangle(drawto, ex, ey, exsize, eysize);
5723   }
5724
5725   redraw_mask |= REDRAW_ALL;
5726 }
5727
5728
5729 // ---------- new tool button stuff -------------------------------------------
5730
5731 static struct
5732 {
5733   int graphic;
5734   struct TextPosInfo *pos;
5735   int gadget_id;
5736   boolean is_touch_button;
5737   char *infotext;
5738 } toolbutton_info[NUM_TOOL_BUTTONS] =
5739 {
5740   {
5741     IMG_GFX_REQUEST_BUTTON_YES,         &request.button.yes,
5742     TOOL_CTRL_ID_YES, FALSE,            "yes"
5743   },
5744   {
5745     IMG_GFX_REQUEST_BUTTON_NO,          &request.button.no,
5746     TOOL_CTRL_ID_NO, FALSE,             "no"
5747   },
5748   {
5749     IMG_GFX_REQUEST_BUTTON_CONFIRM,     &request.button.confirm,
5750     TOOL_CTRL_ID_CONFIRM, FALSE,        "confirm"
5751   },
5752   {
5753     IMG_GFX_REQUEST_BUTTON_PLAYER_1,    &request.button.player_1,
5754     TOOL_CTRL_ID_PLAYER_1, FALSE,       "player 1"
5755   },
5756   {
5757     IMG_GFX_REQUEST_BUTTON_PLAYER_2,    &request.button.player_2,
5758     TOOL_CTRL_ID_PLAYER_2, FALSE,       "player 2"
5759   },
5760   {
5761     IMG_GFX_REQUEST_BUTTON_PLAYER_3,    &request.button.player_3,
5762     TOOL_CTRL_ID_PLAYER_3, FALSE,       "player 3"
5763   },
5764   {
5765     IMG_GFX_REQUEST_BUTTON_PLAYER_4,    &request.button.player_4,
5766     TOOL_CTRL_ID_PLAYER_4, FALSE,       "player 4"
5767   },
5768   {
5769     IMG_GFX_REQUEST_BUTTON_TOUCH_YES,   &request.button.touch_yes,
5770     TOOL_CTRL_ID_TOUCH_YES, TRUE,       "yes"
5771   },
5772   {
5773     IMG_GFX_REQUEST_BUTTON_TOUCH_NO,    &request.button.touch_no,
5774     TOOL_CTRL_ID_TOUCH_NO, TRUE,        "no"
5775   },
5776   {
5777     IMG_GFX_REQUEST_BUTTON_TOUCH_CONFIRM, &request.button.touch_confirm,
5778     TOOL_CTRL_ID_TOUCH_CONFIRM, TRUE,   "confirm"
5779   }
5780 };
5781
5782 void CreateToolButtons(void)
5783 {
5784   int i;
5785
5786   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5787   {
5788     int graphic = toolbutton_info[i].graphic;
5789     struct GraphicInfo *gfx = &graphic_info[graphic];
5790     struct TextPosInfo *pos = toolbutton_info[i].pos;
5791     struct GadgetInfo *gi;
5792     Bitmap *deco_bitmap = None;
5793     int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
5794     unsigned int event_mask = GD_EVENT_RELEASED;
5795     boolean is_touch_button = toolbutton_info[i].is_touch_button;
5796     int base_x = (is_touch_button ? 0 : DX);
5797     int base_y = (is_touch_button ? 0 : DY);
5798     int gd_x = gfx->src_x;
5799     int gd_y = gfx->src_y;
5800     int gd_xp = gfx->src_x + gfx->pressed_xoffset;
5801     int gd_yp = gfx->src_y + gfx->pressed_yoffset;
5802     int x = pos->x;
5803     int y = pos->y;
5804     int id = i;
5805
5806     // do not use touch buttons if overlay touch buttons are disabled
5807     if (is_touch_button && !setup.touch.overlay_buttons)
5808       continue;
5809
5810     if (global.use_envelope_request && !is_touch_button)
5811     {
5812       setRequestPosition(&base_x, &base_y, TRUE);
5813
5814       // check if request buttons are outside of envelope and fix, if needed
5815       if (x < 0 || x + gfx->width  > request.width ||
5816           y < 0 || y + gfx->height > request.height)
5817       {
5818         if (id == TOOL_CTRL_ID_YES)
5819         {
5820           x = 0;
5821           y = request.height - 2 * request.border_size - gfx->height;
5822         }
5823         else if (id == TOOL_CTRL_ID_NO)
5824         {
5825           x = request.width  - 2 * request.border_size - gfx->width;
5826           y = request.height - 2 * request.border_size - gfx->height;
5827         }
5828         else if (id == TOOL_CTRL_ID_CONFIRM)
5829         {
5830           x = (request.width - 2 * request.border_size - gfx->width) / 2;
5831           y = request.height - 2 * request.border_size - gfx->height;
5832         }
5833         else if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
5834         {
5835           int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5836
5837           x = (request.width - 2 * request.border_size - gfx->width) / 2;
5838           y = request.height - 2 * request.border_size - gfx->height * 2;
5839
5840           x += (player_nr == 3 ? -1 : player_nr == 1 ? +1 : 0) * gfx->width;
5841           y += (player_nr == 0 ? -1 : player_nr == 2 ? +1 : 0) * gfx->height;
5842         }
5843       }
5844     }
5845
5846     if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4 &&
5847         pos->draw_player)
5848     {
5849       int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5850
5851       getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
5852                             pos->size, &deco_bitmap, &deco_x, &deco_y);
5853       deco_xpos = (gfx->width  - pos->size) / 2;
5854       deco_ypos = (gfx->height - pos->size) / 2;
5855     }
5856
5857     gi = CreateGadget(GDI_CUSTOM_ID, id,
5858                       GDI_IMAGE_ID, graphic,
5859                       GDI_INFO_TEXT, toolbutton_info[i].infotext,
5860                       GDI_X, base_x + x,
5861                       GDI_Y, base_y + y,
5862                       GDI_WIDTH, gfx->width,
5863                       GDI_HEIGHT, gfx->height,
5864                       GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
5865                       GDI_STATE, GD_BUTTON_UNPRESSED,
5866                       GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
5867                       GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
5868                       GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
5869                       GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
5870                       GDI_DECORATION_SIZE, pos->size, pos->size,
5871                       GDI_DECORATION_SHIFTING, 1, 1,
5872                       GDI_DIRECT_DRAW, FALSE,
5873                       GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
5874                       GDI_EVENT_MASK, event_mask,
5875                       GDI_CALLBACK_ACTION, HandleToolButtons,
5876                       GDI_END);
5877
5878     if (gi == NULL)
5879       Fail("cannot create gadget");
5880
5881     tool_gadget[id] = gi;
5882   }
5883 }
5884
5885 void FreeToolButtons(void)
5886 {
5887   int i;
5888
5889   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5890     FreeGadget(tool_gadget[i]);
5891 }
5892
5893 static void MapToolButtons(unsigned int req_state)
5894 {
5895   if (req_state & REQ_ASK)
5896   {
5897     MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
5898     MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
5899     MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_YES]);
5900     MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_NO]);
5901   }
5902   else if (req_state & REQ_CONFIRM)
5903   {
5904     MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
5905     MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_CONFIRM]);
5906   }
5907   else if (req_state & REQ_PLAYER)
5908   {
5909     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
5910     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
5911     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
5912     MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
5913   }
5914 }
5915
5916 static void UnmapToolButtons(void)
5917 {
5918   int i;
5919
5920   for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5921     UnmapGadget(tool_gadget[i]);
5922 }
5923
5924 static void HandleToolButtons(struct GadgetInfo *gi)
5925 {
5926   request_gadget_id = gi->custom_id;
5927 }
5928
5929 static struct Mapping_EM_to_RND_object
5930 {
5931   int element_em;
5932   boolean is_rnd_to_em_mapping;         // unique mapping EM <-> RND
5933   boolean is_backside;                  // backside of moving element
5934
5935   int element_rnd;
5936   int action;
5937   int direction;
5938 }
5939 em_object_mapping_list[GAME_TILE_MAX + 1] =
5940 {
5941   {
5942     Zborder,                            FALSE,  FALSE,
5943     EL_EMPTY,                           -1, -1
5944   },
5945   {
5946     Zplayer,                            FALSE,  FALSE,
5947     EL_EMPTY,                           -1, -1
5948   },
5949
5950   {
5951     Zbug,                               FALSE,  FALSE,
5952     EL_EMPTY,                           -1, -1
5953   },
5954   {
5955     Ztank,                              FALSE,  FALSE,
5956     EL_EMPTY,                           -1, -1
5957   },
5958   {
5959     Zeater,                             FALSE,  FALSE,
5960     EL_EMPTY,                           -1, -1
5961   },
5962   {
5963     Zdynamite,                          FALSE,  FALSE,
5964     EL_EMPTY,                           -1, -1
5965   },
5966   {
5967     Zboom,                              FALSE,  FALSE,
5968     EL_EMPTY,                           -1, -1
5969   },
5970
5971   {
5972     Xchain,                             FALSE,  FALSE,
5973     EL_DEFAULT,                         ACTION_EXPLODING, -1
5974   },
5975   {
5976     Xboom_bug,                          FALSE,  FALSE,
5977     EL_BUG,                             ACTION_EXPLODING, -1
5978   },
5979   {
5980     Xboom_tank,                         FALSE,  FALSE,
5981     EL_SPACESHIP,                       ACTION_EXPLODING, -1
5982   },
5983   {
5984     Xboom_android,                      FALSE,  FALSE,
5985     EL_EMC_ANDROID,                     ACTION_OTHER, -1
5986   },
5987   {
5988     Xboom_1,                            FALSE,  FALSE,
5989     EL_DEFAULT,                         ACTION_EXPLODING, -1
5990   },
5991   {
5992     Xboom_2,                            FALSE,  FALSE,
5993     EL_DEFAULT,                         ACTION_EXPLODING, -1
5994   },
5995
5996   {
5997     Xblank,                             TRUE,   FALSE,
5998     EL_EMPTY,                           -1, -1
5999   },
6000
6001   {
6002     Xsplash_e,                          FALSE,  FALSE,
6003     EL_ACID_SPLASH_RIGHT,               -1, -1
6004   },
6005   {
6006     Xsplash_w,                          FALSE,  FALSE,
6007     EL_ACID_SPLASH_LEFT,                -1, -1
6008   },
6009
6010   {
6011     Xplant,                             TRUE,   FALSE,
6012     EL_EMC_PLANT,                       -1, -1
6013   },
6014   {
6015     Yplant,                             FALSE,  FALSE,
6016     EL_EMC_PLANT,                       -1, -1
6017   },
6018
6019   {
6020     Xacid_1,                            TRUE,   FALSE,
6021     EL_ACID,                            -1, -1
6022   },
6023   {
6024     Xacid_2,                            FALSE,  FALSE,
6025     EL_ACID,                            -1, -1
6026   },
6027   {
6028     Xacid_3,                            FALSE,  FALSE,
6029     EL_ACID,                            -1, -1
6030   },
6031   {
6032     Xacid_4,                            FALSE,  FALSE,
6033     EL_ACID,                            -1, -1
6034   },
6035   {
6036     Xacid_5,                            FALSE,  FALSE,
6037     EL_ACID,                            -1, -1
6038   },
6039   {
6040     Xacid_6,                            FALSE,  FALSE,
6041     EL_ACID,                            -1, -1
6042   },
6043   {
6044     Xacid_7,                            FALSE,  FALSE,
6045     EL_ACID,                            -1, -1
6046   },
6047   {
6048     Xacid_8,                            FALSE,  FALSE,
6049     EL_ACID,                            -1, -1
6050   },
6051
6052   {
6053     Xfake_acid_1,                       TRUE,   FALSE,
6054     EL_EMC_FAKE_ACID,                   -1, -1
6055   },
6056   {
6057     Xfake_acid_2,                       FALSE,  FALSE,
6058     EL_EMC_FAKE_ACID,                   -1, -1
6059   },
6060   {
6061     Xfake_acid_3,                       FALSE,  FALSE,
6062     EL_EMC_FAKE_ACID,                   -1, -1
6063   },
6064   {
6065     Xfake_acid_4,                       FALSE,  FALSE,
6066     EL_EMC_FAKE_ACID,                   -1, -1
6067   },
6068   {
6069     Xfake_acid_5,                       FALSE,  FALSE,
6070     EL_EMC_FAKE_ACID,                   -1, -1
6071   },
6072   {
6073     Xfake_acid_6,                       FALSE,  FALSE,
6074     EL_EMC_FAKE_ACID,                   -1, -1
6075   },
6076   {
6077     Xfake_acid_7,                       FALSE,  FALSE,
6078     EL_EMC_FAKE_ACID,                   -1, -1
6079   },
6080   {
6081     Xfake_acid_8,                       FALSE,  FALSE,
6082     EL_EMC_FAKE_ACID,                   -1, -1
6083   },
6084
6085   {
6086     Xfake_acid_1_player,                FALSE,  FALSE,
6087     EL_EMC_FAKE_ACID,                   -1, -1
6088   },
6089   {
6090     Xfake_acid_2_player,                FALSE,  FALSE,
6091     EL_EMC_FAKE_ACID,                   -1, -1
6092   },
6093   {
6094     Xfake_acid_3_player,                FALSE,  FALSE,
6095     EL_EMC_FAKE_ACID,                   -1, -1
6096   },
6097   {
6098     Xfake_acid_4_player,                FALSE,  FALSE,
6099     EL_EMC_FAKE_ACID,                   -1, -1
6100   },
6101   {
6102     Xfake_acid_5_player,                FALSE,  FALSE,
6103     EL_EMC_FAKE_ACID,                   -1, -1
6104   },
6105   {
6106     Xfake_acid_6_player,                FALSE,  FALSE,
6107     EL_EMC_FAKE_ACID,                   -1, -1
6108   },
6109   {
6110     Xfake_acid_7_player,                FALSE,  FALSE,
6111     EL_EMC_FAKE_ACID,                   -1, -1
6112   },
6113   {
6114     Xfake_acid_8_player,                FALSE,  FALSE,
6115     EL_EMC_FAKE_ACID,                   -1, -1
6116   },
6117
6118   {
6119     Xgrass,                             TRUE,   FALSE,
6120     EL_EMC_GRASS,                       -1, -1
6121   },
6122   {
6123     Ygrass_nB,                          FALSE,  FALSE,
6124     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_UP
6125   },
6126   {
6127     Ygrass_eB,                          FALSE,  FALSE,
6128     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_RIGHT
6129   },
6130   {
6131     Ygrass_sB,                          FALSE,  FALSE,
6132     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_DOWN
6133   },
6134   {
6135     Ygrass_wB,                          FALSE,  FALSE,
6136     EL_EMC_GRASS,                       ACTION_DIGGING, MV_BIT_LEFT
6137   },
6138
6139   {
6140     Xdirt,                              TRUE,   FALSE,
6141     EL_SAND,                            -1, -1
6142   },
6143   {
6144     Ydirt_nB,                           FALSE,  FALSE,
6145     EL_SAND,                            ACTION_DIGGING, MV_BIT_UP
6146   },
6147   {
6148     Ydirt_eB,                           FALSE,  FALSE,
6149     EL_SAND,                            ACTION_DIGGING, MV_BIT_RIGHT
6150   },
6151   {
6152     Ydirt_sB,                           FALSE,  FALSE,
6153     EL_SAND,                            ACTION_DIGGING, MV_BIT_DOWN
6154   },
6155   {
6156     Ydirt_wB,                           FALSE,  FALSE,
6157     EL_SAND,                            ACTION_DIGGING, MV_BIT_LEFT
6158   },
6159
6160   {
6161     Xandroid,                           TRUE,   FALSE,
6162     EL_EMC_ANDROID,                     ACTION_ACTIVE, -1
6163   },
6164   {
6165     Xandroid_1_n,                       FALSE,  FALSE,
6166     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_UP
6167   },
6168   {
6169     Xandroid_2_n,                       FALSE,  FALSE,
6170     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_UP
6171   },
6172   {
6173     Xandroid_1_e,                       FALSE,  FALSE,
6174     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_RIGHT
6175   },
6176   {
6177     Xandroid_2_e,                       FALSE,  FALSE,
6178     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_RIGHT
6179   },
6180   {
6181     Xandroid_1_w,                       FALSE,  FALSE,
6182     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_LEFT
6183   },
6184   {
6185     Xandroid_2_w,                       FALSE,  FALSE,
6186     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_LEFT
6187   },
6188   {
6189     Xandroid_1_s,                       FALSE,  FALSE,
6190     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_DOWN
6191   },
6192   {
6193     Xandroid_2_s,                       FALSE,  FALSE,
6194     EL_EMC_ANDROID,                     ACTION_ACTIVE, MV_BIT_DOWN
6195   },
6196   {
6197     Yandroid_n,                         FALSE,  FALSE,
6198     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_UP
6199   },
6200   {
6201     Yandroid_nB,                        FALSE,  TRUE,
6202     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_UP
6203   },
6204   {
6205     Yandroid_ne,                        FALSE,  FALSE,
6206     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_UPRIGHT
6207   },
6208   {
6209     Yandroid_neB,                       FALSE,  TRUE,
6210     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_UPRIGHT
6211   },
6212   {
6213     Yandroid_e,                         FALSE,  FALSE,
6214     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_RIGHT
6215   },
6216   {
6217     Yandroid_eB,                        FALSE,  TRUE,
6218     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_RIGHT
6219   },
6220   {
6221     Yandroid_se,                        FALSE,  FALSE,
6222     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_DOWNRIGHT
6223   },
6224   {
6225     Yandroid_seB,                       FALSE,  TRUE,
6226     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_DOWNRIGHT
6227   },
6228   {
6229     Yandroid_s,                         FALSE,  FALSE,
6230     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_DOWN
6231   },
6232   {
6233     Yandroid_sB,                        FALSE,  TRUE,
6234     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_DOWN
6235   },
6236   {
6237     Yandroid_sw,                        FALSE,  FALSE,
6238     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_DOWNLEFT
6239   },
6240   {
6241     Yandroid_swB,                       FALSE,  TRUE,
6242     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_DOWNLEFT
6243   },
6244   {
6245     Yandroid_w,                         FALSE,  FALSE,
6246     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_LEFT
6247   },
6248   {
6249     Yandroid_wB,                        FALSE,  TRUE,
6250     EL_EMC_ANDROID,                     ACTION_MOVING, MV_BIT_LEFT
6251   },
6252   {
6253     Yandroid_nw,                        FALSE,  FALSE,
6254     EL_EMC_ANDROID,                     ACTION_GROWING, MV_BIT_UPLEFT
6255   },
6256   {
6257     Yandroid_nwB,                       FALSE,  TRUE,
6258     EL_EMC_ANDROID,                     ACTION_SHRINKING, MV_BIT_UPLEFT
6259   },
6260
6261   {
6262     Xeater_n,                           TRUE,   FALSE,
6263     EL_YAMYAM_UP,                       -1, -1
6264   },
6265   {
6266     Xeater_e,                           TRUE,   FALSE,
6267     EL_YAMYAM_RIGHT,                    -1, -1
6268   },
6269   {
6270     Xeater_w,                           TRUE,   FALSE,
6271     EL_YAMYAM_LEFT,                     -1, -1
6272   },
6273   {
6274     Xeater_s,                           TRUE,   FALSE,
6275     EL_YAMYAM_DOWN,                     -1, -1
6276   },
6277   {
6278     Yeater_n,                           FALSE,  FALSE,
6279     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_UP
6280   },
6281   {
6282     Yeater_nB,                          FALSE,  TRUE,
6283     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_UP
6284   },
6285   {
6286     Yeater_e,                           FALSE,  FALSE,
6287     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_RIGHT
6288   },
6289   {
6290     Yeater_eB,                          FALSE,  TRUE,
6291     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_RIGHT
6292   },
6293   {
6294     Yeater_s,                           FALSE,  FALSE,
6295     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_DOWN
6296   },
6297   {
6298     Yeater_sB,                          FALSE,  TRUE,
6299     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_DOWN
6300   },
6301   {
6302     Yeater_w,                           FALSE,  FALSE,
6303     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_LEFT
6304   },
6305   {
6306     Yeater_wB,                          FALSE,  TRUE,
6307     EL_YAMYAM,                          ACTION_MOVING, MV_BIT_LEFT
6308   },
6309   {
6310     Yeater_stone,                       FALSE,  FALSE,
6311     EL_YAMYAM,                          ACTION_SMASHED_BY_ROCK, -1
6312   },
6313   {
6314     Yeater_spring,                      FALSE,  FALSE,
6315     EL_YAMYAM,                          ACTION_SMASHED_BY_SPRING, -1
6316   },
6317
6318   {
6319     Xalien,                             TRUE,   FALSE,
6320     EL_ROBOT,                           -1, -1
6321   },
6322   {
6323     Xalien_pause,                       FALSE,  FALSE,
6324     EL_ROBOT,                           -1, -1
6325   },
6326   {
6327     Yalien_n,                           FALSE,  FALSE,
6328     EL_ROBOT,                           ACTION_MOVING, MV_BIT_UP
6329   },
6330   {
6331     Yalien_nB,                          FALSE,  TRUE,
6332     EL_ROBOT,                           ACTION_MOVING, MV_BIT_UP
6333   },
6334   {
6335     Yalien_e,                           FALSE,  FALSE,
6336     EL_ROBOT,                           ACTION_MOVING, MV_BIT_RIGHT
6337   },
6338   {
6339     Yalien_eB,                          FALSE,  TRUE,
6340     EL_ROBOT,                           ACTION_MOVING, MV_BIT_RIGHT
6341   },
6342   {
6343     Yalien_s,                           FALSE,  FALSE,
6344     EL_ROBOT,                           ACTION_MOVING, MV_BIT_DOWN
6345   },
6346   {
6347     Yalien_sB,                          FALSE,  TRUE,
6348     EL_ROBOT,                           ACTION_MOVING, MV_BIT_DOWN
6349   },
6350   {
6351     Yalien_w,                           FALSE,  FALSE,
6352     EL_ROBOT,                           ACTION_MOVING, MV_BIT_LEFT
6353   },
6354   {
6355     Yalien_wB,                          FALSE,  TRUE,
6356     EL_ROBOT,                           ACTION_MOVING, MV_BIT_LEFT
6357   },
6358   {
6359     Yalien_stone,                       FALSE,  FALSE,
6360     EL_ROBOT,                           ACTION_SMASHED_BY_ROCK, -1
6361   },
6362   {
6363     Yalien_spring,                      FALSE,  FALSE,
6364     EL_ROBOT,                           ACTION_SMASHED_BY_SPRING, -1
6365   },
6366
6367   {
6368     Xbug_1_n,                           TRUE,   FALSE,
6369     EL_BUG_UP,                          -1, -1
6370   },
6371   {
6372     Xbug_1_e,                           TRUE,   FALSE,
6373     EL_BUG_RIGHT,                       -1, -1
6374   },
6375   {
6376     Xbug_1_s,                           TRUE,   FALSE,
6377     EL_BUG_DOWN,                        -1, -1
6378   },
6379   {
6380     Xbug_1_w,                           TRUE,   FALSE,
6381     EL_BUG_LEFT,                        -1, -1
6382   },
6383   {
6384     Xbug_2_n,                           FALSE,  FALSE,
6385     EL_BUG_UP,                          -1, -1
6386   },
6387   {
6388     Xbug_2_e,                           FALSE,  FALSE,
6389     EL_BUG_RIGHT,                       -1, -1
6390   },
6391   {
6392     Xbug_2_s,                           FALSE,  FALSE,
6393     EL_BUG_DOWN,                        -1, -1
6394   },
6395   {
6396     Xbug_2_w,                           FALSE,  FALSE,
6397     EL_BUG_LEFT,                        -1, -1
6398   },
6399   {
6400     Ybug_n,                             FALSE,  FALSE,
6401     EL_BUG,                             ACTION_MOVING, MV_BIT_UP
6402   },
6403   {
6404     Ybug_nB,                            FALSE,  TRUE,
6405     EL_BUG,                             ACTION_MOVING, MV_BIT_UP
6406   },
6407   {
6408     Ybug_e,                             FALSE,  FALSE,
6409     EL_BUG,                             ACTION_MOVING, MV_BIT_RIGHT
6410   },
6411   {
6412     Ybug_eB,                            FALSE,  TRUE,
6413     EL_BUG,                             ACTION_MOVING, MV_BIT_RIGHT
6414   },
6415   {
6416     Ybug_s,                             FALSE,  FALSE,
6417     EL_BUG,                             ACTION_MOVING, MV_BIT_DOWN
6418   },
6419   {
6420     Ybug_sB,                            FALSE,  TRUE,
6421     EL_BUG,                             ACTION_MOVING, MV_BIT_DOWN
6422   },
6423   {
6424     Ybug_w,                             FALSE,  FALSE,
6425     EL_BUG,                             ACTION_MOVING, MV_BIT_LEFT
6426   },
6427   {
6428     Ybug_wB,                            FALSE,  TRUE,
6429     EL_BUG,                             ACTION_MOVING, MV_BIT_LEFT
6430   },
6431   {
6432     Ybug_w_n,                           FALSE,  FALSE,
6433     EL_BUG,                             ACTION_TURNING_FROM_LEFT, MV_BIT_UP
6434   },
6435   {
6436     Ybug_n_e,                           FALSE,  FALSE,
6437     EL_BUG,                             ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
6438   },
6439   {
6440     Ybug_e_s,                           FALSE,  FALSE,
6441     EL_BUG,                             ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
6442   },
6443   {
6444     Ybug_s_w,                           FALSE,  FALSE,
6445     EL_BUG,                             ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
6446   },
6447   {
6448     Ybug_e_n,                           FALSE,  FALSE,
6449     EL_BUG,                             ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
6450   },
6451   {
6452     Ybug_s_e,                           FALSE,  FALSE,
6453     EL_BUG,                             ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
6454   },
6455   {
6456     Ybug_w_s,                           FALSE,  FALSE,
6457     EL_BUG,                             ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
6458   },
6459   {
6460     Ybug_n_w,                           FALSE,  FALSE,
6461     EL_BUG,                             ACTION_TURNING_FROM_UP, MV_BIT_LEFT
6462   },
6463   {
6464     Ybug_stone,                         FALSE,  FALSE,
6465     EL_BUG,                             ACTION_SMASHED_BY_ROCK, -1
6466   },
6467   {
6468     Ybug_spring,                        FALSE,  FALSE,
6469     EL_BUG,                             ACTION_SMASHED_BY_SPRING, -1
6470   },
6471
6472   {
6473     Xtank_1_n,                          TRUE,   FALSE,
6474     EL_SPACESHIP_UP,                    -1, -1
6475   },
6476   {
6477     Xtank_1_e,                          TRUE,   FALSE,
6478     EL_SPACESHIP_RIGHT,                 -1, -1
6479   },
6480   {
6481     Xtank_1_s,                          TRUE,   FALSE,
6482     EL_SPACESHIP_DOWN,                  -1, -1
6483   },
6484   {
6485     Xtank_1_w,                          TRUE,   FALSE,
6486     EL_SPACESHIP_LEFT,                  -1, -1
6487   },
6488   {
6489     Xtank_2_n,                          FALSE,  FALSE,
6490     EL_SPACESHIP_UP,                    -1, -1
6491   },
6492   {
6493     Xtank_2_e,                          FALSE,  FALSE,
6494     EL_SPACESHIP_RIGHT,                 -1, -1
6495   },
6496   {
6497     Xtank_2_s,                          FALSE,  FALSE,
6498     EL_SPACESHIP_DOWN,                  -1, -1
6499   },
6500   {
6501     Xtank_2_w,                          FALSE,  FALSE,
6502     EL_SPACESHIP_LEFT,                  -1, -1
6503   },
6504   {
6505     Ytank_n,                            FALSE,  FALSE,
6506     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_UP
6507   },
6508   {
6509     Ytank_nB,                           FALSE,  TRUE,
6510     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_UP
6511   },
6512   {
6513     Ytank_e,                            FALSE,  FALSE,
6514     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_RIGHT
6515   },
6516   {
6517     Ytank_eB,                           FALSE,  TRUE,
6518     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_RIGHT
6519   },
6520   {
6521     Ytank_s,                            FALSE,  FALSE,
6522     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_DOWN
6523   },
6524   {
6525     Ytank_sB,                           FALSE,  TRUE,
6526     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_DOWN
6527   },
6528   {
6529     Ytank_w,                            FALSE,  FALSE,
6530     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_LEFT
6531   },
6532   {
6533     Ytank_wB,                           FALSE,  TRUE,
6534     EL_SPACESHIP,                       ACTION_MOVING, MV_BIT_LEFT
6535   },
6536   {
6537     Ytank_w_n,                          FALSE,  FALSE,
6538     EL_SPACESHIP,                       ACTION_TURNING_FROM_LEFT, MV_BIT_UP
6539   },
6540   {
6541     Ytank_n_e,                          FALSE,  FALSE,
6542     EL_SPACESHIP,                       ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
6543   },
6544   {
6545     Ytank_e_s,                          FALSE,  FALSE,
6546     EL_SPACESHIP,                       ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
6547   },
6548   {
6549     Ytank_s_w,                          FALSE,  FALSE,
6550     EL_SPACESHIP,                       ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
6551   },
6552   {
6553     Ytank_e_n,                          FALSE,  FALSE,
6554     EL_SPACESHIP,                       ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
6555   },
6556   {
6557     Ytank_s_e,                          FALSE,  FALSE,
6558     EL_SPACESHIP,                       ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
6559   },
6560   {
6561     Ytank_w_s,                          FALSE,  FALSE,
6562     EL_SPACESHIP,                       ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
6563   },
6564   {
6565     Ytank_n_w,                          FALSE,  FALSE,
6566     EL_SPACESHIP,                       ACTION_TURNING_FROM_UP, MV_BIT_LEFT
6567   },
6568   {
6569     Ytank_stone,                        FALSE,  FALSE,
6570     EL_SPACESHIP,                       ACTION_SMASHED_BY_ROCK, -1
6571   },
6572   {
6573     Ytank_spring,                       FALSE,  FALSE,
6574     EL_SPACESHIP,                       ACTION_SMASHED_BY_SPRING, -1
6575   },
6576
6577   {
6578     Xemerald,                           TRUE,   FALSE,
6579     EL_EMERALD,                         -1, -1
6580   },
6581   {
6582     Xemerald_pause,                     FALSE,  FALSE,
6583     EL_EMERALD,                         -1, -1
6584   },
6585   {
6586     Xemerald_fall,                      FALSE,  FALSE,
6587     EL_EMERALD,                         -1, -1
6588   },
6589   {
6590     Xemerald_shine,                     FALSE,  FALSE,
6591     EL_EMERALD,                         ACTION_TWINKLING, -1
6592   },
6593   {
6594     Yemerald_s,                         FALSE,  FALSE,
6595     EL_EMERALD,                         ACTION_FALLING, -1
6596   },
6597   {
6598     Yemerald_sB,                        FALSE,  TRUE,
6599     EL_EMERALD,                         ACTION_FALLING, -1
6600   },
6601   {
6602     Yemerald_e,                         FALSE,  FALSE,
6603     EL_EMERALD,                         ACTION_MOVING, MV_BIT_RIGHT
6604   },
6605   {
6606     Yemerald_eB,                        FALSE,  TRUE,
6607     EL_EMERALD,                         ACTION_MOVING, MV_BIT_RIGHT
6608   },
6609   {
6610     Yemerald_w,                         FALSE,  FALSE,
6611     EL_EMERALD,                         ACTION_MOVING, MV_BIT_LEFT
6612   },
6613   {
6614     Yemerald_wB,                        FALSE,  TRUE,
6615     EL_EMERALD,                         ACTION_MOVING, MV_BIT_LEFT
6616   },
6617   {
6618     Yemerald_blank,                     FALSE,  FALSE,
6619     EL_EMERALD,                         ACTION_COLLECTING, -1
6620   },
6621
6622   {
6623     Xdiamond,                           TRUE,   FALSE,
6624     EL_DIAMOND,                         -1, -1
6625   },
6626   {
6627     Xdiamond_pause,                     FALSE,  FALSE,
6628     EL_DIAMOND,                         -1, -1
6629   },
6630   {
6631     Xdiamond_fall,                      FALSE,  FALSE,
6632     EL_DIAMOND,                         -1, -1
6633   },
6634   {
6635     Xdiamond_shine,                     FALSE,  FALSE,
6636     EL_DIAMOND,                         ACTION_TWINKLING, -1
6637   },
6638   {
6639     Ydiamond_s,                         FALSE,  FALSE,
6640     EL_DIAMOND,                         ACTION_FALLING, -1
6641   },
6642   {
6643     Ydiamond_sB,                        FALSE,  TRUE,
6644     EL_DIAMOND,                         ACTION_FALLING, -1
6645   },
6646   {
6647     Ydiamond_e,                         FALSE,  FALSE,
6648     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_RIGHT
6649   },
6650   {
6651     Ydiamond_eB,                        FALSE,  TRUE,
6652     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_RIGHT
6653   },
6654   {
6655     Ydiamond_w,                         FALSE,  FALSE,
6656     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_LEFT
6657   },
6658   {
6659     Ydiamond_wB,                        FALSE,  TRUE,
6660     EL_DIAMOND,                         ACTION_MOVING, MV_BIT_LEFT
6661   },
6662   {
6663     Ydiamond_blank,                     FALSE,  FALSE,
6664     EL_DIAMOND,                         ACTION_COLLECTING, -1
6665   },
6666   {
6667     Ydiamond_stone,                     FALSE,  FALSE,
6668     EL_DIAMOND,                         ACTION_SMASHED_BY_ROCK, -1
6669   },
6670
6671   {
6672     Xstone,                             TRUE,   FALSE,
6673     EL_ROCK,                            -1, -1
6674   },
6675   {
6676     Xstone_pause,                       FALSE,  FALSE,
6677     EL_ROCK,                            -1, -1
6678   },
6679   {
6680     Xstone_fall,                        FALSE,  FALSE,
6681     EL_ROCK,                            -1, -1
6682   },
6683   {
6684     Ystone_s,                           FALSE,  FALSE,
6685     EL_ROCK,                            ACTION_FALLING, -1
6686   },
6687   {
6688     Ystone_sB,                          FALSE,  TRUE,
6689     EL_ROCK,                            ACTION_FALLING, -1
6690   },
6691   {
6692     Ystone_e,                           FALSE,  FALSE,
6693     EL_ROCK,                            ACTION_MOVING, MV_BIT_RIGHT
6694   },
6695   {
6696     Ystone_eB,                          FALSE,  TRUE,
6697     EL_ROCK,                            ACTION_MOVING, MV_BIT_RIGHT
6698   },
6699   {
6700     Ystone_w,                           FALSE,  FALSE,
6701     EL_ROCK,                            ACTION_MOVING, MV_BIT_LEFT
6702   },
6703   {
6704     Ystone_wB,                          FALSE,  TRUE,
6705     EL_ROCK,                            ACTION_MOVING, MV_BIT_LEFT
6706   },
6707
6708   {
6709     Xbomb,                              TRUE,   FALSE,
6710     EL_BOMB,                            -1, -1
6711   },
6712   {
6713     Xbomb_pause,                        FALSE,  FALSE,
6714     EL_BOMB,                            -1, -1
6715   },
6716   {
6717     Xbomb_fall,                         FALSE,  FALSE,
6718     EL_BOMB,                            -1, -1
6719   },
6720   {
6721     Ybomb_s,                            FALSE,  FALSE,
6722     EL_BOMB,                            ACTION_FALLING, -1
6723   },
6724   {
6725     Ybomb_sB,                           FALSE,  TRUE,
6726     EL_BOMB,                            ACTION_FALLING, -1
6727   },
6728   {
6729     Ybomb_e,                            FALSE,  FALSE,
6730     EL_BOMB,                            ACTION_MOVING, MV_BIT_RIGHT
6731   },
6732   {
6733     Ybomb_eB,                           FALSE,  TRUE,
6734     EL_BOMB,                            ACTION_MOVING, MV_BIT_RIGHT
6735   },
6736   {
6737     Ybomb_w,                            FALSE,  FALSE,
6738     EL_BOMB,                            ACTION_MOVING, MV_BIT_LEFT
6739   },
6740   {
6741     Ybomb_wB,                           FALSE,  TRUE,
6742     EL_BOMB,                            ACTION_MOVING, MV_BIT_LEFT
6743   },
6744   {
6745     Ybomb_blank,                        FALSE,  FALSE,
6746     EL_BOMB,                            ACTION_ACTIVATING, -1
6747   },
6748
6749   {
6750     Xnut,                               TRUE,   FALSE,
6751     EL_NUT,                             -1, -1
6752   },
6753   {
6754     Xnut_pause,                         FALSE,  FALSE,
6755     EL_NUT,                             -1, -1
6756   },
6757   {
6758     Xnut_fall,                          FALSE,  FALSE,
6759     EL_NUT,                             -1, -1
6760   },
6761   {
6762     Ynut_s,                             FALSE,  FALSE,
6763     EL_NUT,                             ACTION_FALLING, -1
6764   },
6765   {
6766     Ynut_sB,                            FALSE,  TRUE,
6767     EL_NUT,                             ACTION_FALLING, -1
6768   },
6769   {
6770     Ynut_e,                             FALSE,  FALSE,
6771     EL_NUT,                             ACTION_MOVING, MV_BIT_RIGHT
6772   },
6773   {
6774     Ynut_eB,                            FALSE,  TRUE,
6775     EL_NUT,                             ACTION_MOVING, MV_BIT_RIGHT
6776   },
6777   {
6778     Ynut_w,                             FALSE,  FALSE,
6779     EL_NUT,                             ACTION_MOVING, MV_BIT_LEFT
6780   },
6781   {
6782     Ynut_wB,                            FALSE,  TRUE,
6783     EL_NUT,                             ACTION_MOVING, MV_BIT_LEFT
6784   },
6785   {
6786     Ynut_stone,                         FALSE,  FALSE,
6787     EL_NUT,                             ACTION_BREAKING, -1
6788   },
6789
6790   {
6791     Xspring,                            TRUE,   FALSE,
6792     EL_SPRING,                          -1, -1
6793   },
6794   {
6795     Xspring_pause,                      FALSE,  FALSE,
6796     EL_SPRING,                          -1, -1
6797   },
6798   {
6799     Xspring_e,                          TRUE,   FALSE,
6800     EL_SPRING_RIGHT,                    -1, -1
6801   },
6802   {
6803     Xspring_w,                          TRUE,   FALSE,
6804     EL_SPRING_LEFT,                     -1, -1
6805   },
6806   {
6807     Xspring_fall,                       FALSE,  FALSE,
6808     EL_SPRING,                          -1, -1
6809   },
6810   {
6811     Yspring_s,                          FALSE,  FALSE,
6812     EL_SPRING,                          ACTION_FALLING, -1
6813   },
6814   {
6815     Yspring_sB,                         FALSE,  TRUE,
6816     EL_SPRING,                          ACTION_FALLING, -1
6817   },
6818   {
6819     Yspring_e,                          FALSE,  FALSE,
6820     EL_SPRING,                          ACTION_MOVING, MV_BIT_RIGHT
6821   },
6822   {
6823     Yspring_eB,                         FALSE,  TRUE,
6824     EL_SPRING,                          ACTION_MOVING, MV_BIT_RIGHT
6825   },
6826   {
6827     Yspring_w,                          FALSE,  FALSE,
6828     EL_SPRING,                          ACTION_MOVING, MV_BIT_LEFT
6829   },
6830   {
6831     Yspring_wB,                         FALSE,  TRUE,
6832     EL_SPRING,                          ACTION_MOVING, MV_BIT_LEFT
6833   },
6834   {
6835     Yspring_alien_e,                    FALSE,  FALSE,
6836     EL_SPRING,                          ACTION_EATING, MV_BIT_RIGHT
6837   },
6838   {
6839     Yspring_alien_eB,                   FALSE,  TRUE,
6840     EL_SPRING,                          ACTION_EATING, MV_BIT_RIGHT
6841   },
6842   {
6843     Yspring_alien_w,                    FALSE,  FALSE,
6844     EL_SPRING,                          ACTION_EATING, MV_BIT_LEFT
6845   },
6846   {
6847     Yspring_alien_wB,                   FALSE,  TRUE,
6848     EL_SPRING,                          ACTION_EATING, MV_BIT_LEFT
6849   },
6850
6851   {
6852     Xpush_emerald_e,                    FALSE,  FALSE,
6853     EL_EMERALD,                         -1, MV_BIT_RIGHT
6854   },
6855   {
6856     Xpush_emerald_w,                    FALSE,  FALSE,
6857     EL_EMERALD,                         -1, MV_BIT_LEFT
6858   },
6859   {
6860     Xpush_diamond_e,                    FALSE,  FALSE,
6861     EL_DIAMOND,                         -1, MV_BIT_RIGHT
6862   },
6863   {
6864     Xpush_diamond_w,                    FALSE,  FALSE,
6865     EL_DIAMOND,                         -1, MV_BIT_LEFT
6866   },
6867   {
6868     Xpush_stone_e,                      FALSE,  FALSE,
6869     EL_ROCK,                            -1, MV_BIT_RIGHT
6870   },
6871   {
6872     Xpush_stone_w,                      FALSE,  FALSE,
6873     EL_ROCK,                            -1, MV_BIT_LEFT
6874   },
6875   {
6876     Xpush_bomb_e,                       FALSE,  FALSE,
6877     EL_BOMB,                            -1, MV_BIT_RIGHT
6878   },
6879   {
6880     Xpush_bomb_w,                       FALSE,  FALSE,
6881     EL_BOMB,                            -1, MV_BIT_LEFT
6882   },
6883   {
6884     Xpush_nut_e,                        FALSE,  FALSE,
6885     EL_NUT,                             -1, MV_BIT_RIGHT
6886   },
6887   {
6888     Xpush_nut_w,                        FALSE,  FALSE,
6889     EL_NUT,                             -1, MV_BIT_LEFT
6890   },
6891   {
6892     Xpush_spring_e,                     FALSE,  FALSE,
6893     EL_SPRING_RIGHT,                    -1, MV_BIT_RIGHT
6894   },
6895   {
6896     Xpush_spring_w,                     FALSE,  FALSE,
6897     EL_SPRING_LEFT,                     -1, MV_BIT_LEFT
6898   },
6899
6900   {
6901     Xdynamite,                          TRUE,   FALSE,
6902     EL_EM_DYNAMITE,                     -1, -1
6903   },
6904   {
6905     Ydynamite_blank,                    FALSE,  FALSE,
6906     EL_EM_DYNAMITE,                     ACTION_COLLECTING, -1
6907   },
6908   {
6909     Xdynamite_1,                        TRUE,   FALSE,
6910     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6911   },
6912   {
6913     Xdynamite_2,                        FALSE,  FALSE,
6914     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6915   },
6916   {
6917     Xdynamite_3,                        FALSE,  FALSE,
6918     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6919   },
6920   {
6921     Xdynamite_4,                        FALSE,  FALSE,
6922     EL_EM_DYNAMITE_ACTIVE,              -1, -1
6923   },
6924
6925   {
6926     Xkey_1,                             TRUE,   FALSE,
6927     EL_EM_KEY_1,                        -1, -1
6928   },
6929   {
6930     Xkey_2,                             TRUE,   FALSE,
6931     EL_EM_KEY_2,                        -1, -1
6932   },
6933   {
6934     Xkey_3,                             TRUE,   FALSE,
6935     EL_EM_KEY_3,                        -1, -1
6936   },
6937   {
6938     Xkey_4,                             TRUE,   FALSE,
6939     EL_EM_KEY_4,                        -1, -1
6940   },
6941   {
6942     Xkey_5,                             TRUE,   FALSE,
6943     EL_EMC_KEY_5,                       -1, -1
6944   },
6945   {
6946     Xkey_6,                             TRUE,   FALSE,
6947     EL_EMC_KEY_6,                       -1, -1
6948   },
6949   {
6950     Xkey_7,                             TRUE,   FALSE,
6951     EL_EMC_KEY_7,                       -1, -1
6952   },
6953   {
6954     Xkey_8,                             TRUE,   FALSE,
6955     EL_EMC_KEY_8,                       -1, -1
6956   },
6957
6958   {
6959     Xdoor_1,                            TRUE,   FALSE,
6960     EL_EM_GATE_1,                       -1, -1
6961   },
6962   {
6963     Xdoor_2,                            TRUE,   FALSE,
6964     EL_EM_GATE_2,                       -1, -1
6965   },
6966   {
6967     Xdoor_3,                            TRUE,   FALSE,
6968     EL_EM_GATE_3,                       -1, -1
6969   },
6970   {
6971     Xdoor_4,                            TRUE,   FALSE,
6972     EL_EM_GATE_4,                       -1, -1
6973   },
6974   {
6975     Xdoor_5,                            TRUE,   FALSE,
6976     EL_EMC_GATE_5,                      -1, -1
6977   },
6978   {
6979     Xdoor_6,                            TRUE,   FALSE,
6980     EL_EMC_GATE_6,                      -1, -1
6981   },
6982   {
6983     Xdoor_7,                            TRUE,   FALSE,
6984     EL_EMC_GATE_7,                      -1, -1
6985   },
6986   {
6987     Xdoor_8,                            TRUE,   FALSE,
6988     EL_EMC_GATE_8,                      -1, -1
6989   },
6990
6991   {
6992     Xfake_door_1,                       TRUE,   FALSE,
6993     EL_EM_GATE_1_GRAY,                  -1, -1
6994   },
6995   {
6996     Xfake_door_2,                       TRUE,   FALSE,
6997     EL_EM_GATE_2_GRAY,                  -1, -1
6998   },
6999   {
7000     Xfake_door_3,                       TRUE,   FALSE,
7001     EL_EM_GATE_3_GRAY,                  -1, -1
7002   },
7003   {
7004     Xfake_door_4,                       TRUE,   FALSE,
7005     EL_EM_GATE_4_GRAY,                  -1, -1
7006   },
7007   {
7008     Xfake_door_5,                       TRUE,   FALSE,
7009     EL_EMC_GATE_5_GRAY,                 -1, -1
7010   },
7011   {
7012     Xfake_door_6,                       TRUE,   FALSE,
7013     EL_EMC_GATE_6_GRAY,                 -1, -1
7014   },
7015   {
7016     Xfake_door_7,                       TRUE,   FALSE,
7017     EL_EMC_GATE_7_GRAY,                 -1, -1
7018   },
7019   {
7020     Xfake_door_8,                       TRUE,   FALSE,
7021     EL_EMC_GATE_8_GRAY,                 -1, -1
7022   },
7023
7024   {
7025     Xballoon,                           TRUE,   FALSE,
7026     EL_BALLOON,                         -1, -1
7027   },
7028   {
7029     Yballoon_n,                         FALSE,  FALSE,
7030     EL_BALLOON,                         ACTION_MOVING, MV_BIT_UP
7031   },
7032   {
7033     Yballoon_nB,                        FALSE,  TRUE,
7034     EL_BALLOON,                         ACTION_MOVING, MV_BIT_UP
7035   },
7036   {
7037     Yballoon_e,                         FALSE,  FALSE,
7038     EL_BALLOON,                         ACTION_MOVING, MV_BIT_RIGHT
7039   },
7040   {
7041     Yballoon_eB,                        FALSE,  TRUE,
7042     EL_BALLOON,                         ACTION_MOVING, MV_BIT_RIGHT
7043   },
7044   {
7045     Yballoon_s,                         FALSE,  FALSE,
7046     EL_BALLOON,                         ACTION_MOVING, MV_BIT_DOWN
7047   },
7048   {
7049     Yballoon_sB,                        FALSE,  TRUE,
7050     EL_BALLOON,                         ACTION_MOVING, MV_BIT_DOWN
7051   },
7052   {
7053     Yballoon_w,                         FALSE,  FALSE,
7054     EL_BALLOON,                         ACTION_MOVING, MV_BIT_LEFT
7055   },
7056   {
7057     Yballoon_wB,                        FALSE,  TRUE,
7058     EL_BALLOON,                         ACTION_MOVING, MV_BIT_LEFT
7059   },
7060
7061   {
7062     Xball_1,                            TRUE,   FALSE,
7063     EL_EMC_MAGIC_BALL,                  -1, -1
7064   },
7065   {
7066     Yball_1,                            FALSE,  FALSE,
7067     EL_EMC_MAGIC_BALL,                  ACTION_ACTIVE, -1
7068   },
7069   {
7070     Xball_2,                            FALSE,  FALSE,
7071     EL_EMC_MAGIC_BALL,                  ACTION_ACTIVE, -1
7072   },
7073   {
7074     Yball_2,                            FALSE,  FALSE,
7075     EL_EMC_MAGIC_BALL,                  ACTION_ACTIVE, -1
7076   },
7077   {
7078     Yball_blank,                        FALSE,  FALSE,
7079     EL_EMC_MAGIC_BALL,                  ACTION_DROPPING, -1
7080   },
7081
7082   {
7083     Xamoeba_1,                          TRUE,   FALSE,
7084     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
7085   },
7086   {
7087     Xamoeba_2,                          FALSE,  FALSE,
7088     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
7089   },
7090   {
7091     Xamoeba_3,                          FALSE,  FALSE,
7092     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
7093   },
7094   {
7095     Xamoeba_4,                          FALSE,  FALSE,
7096     EL_AMOEBA_DRY,                      ACTION_OTHER, -1
7097   },
7098   {
7099     Xamoeba_5,                          TRUE,   FALSE,
7100     EL_AMOEBA_WET,                      ACTION_OTHER, -1
7101   },
7102   {
7103     Xamoeba_6,                          FALSE,  FALSE,
7104     EL_AMOEBA_WET,                      ACTION_OTHER, -1
7105   },
7106   {
7107     Xamoeba_7,                          FALSE,  FALSE,
7108     EL_AMOEBA_WET,                      ACTION_OTHER, -1
7109   },
7110   {
7111     Xamoeba_8,                          FALSE,  FALSE,
7112     EL_AMOEBA_WET,                      ACTION_OTHER, -1
7113   },
7114
7115   {
7116     Xdrip,                              TRUE,   FALSE,
7117     EL_AMOEBA_DROP,                     ACTION_GROWING, -1
7118   },
7119   {
7120     Xdrip_fall,                         FALSE,  FALSE,
7121     EL_AMOEBA_DROP,                     -1, -1
7122   },
7123   {
7124     Xdrip_stretch,                      FALSE,  FALSE,
7125     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
7126   },
7127   {
7128     Xdrip_stretchB,                     FALSE,  TRUE,
7129     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
7130   },
7131   {
7132     Ydrip_1_s,                          FALSE,  FALSE,
7133     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
7134   },
7135   {
7136     Ydrip_1_sB,                         FALSE,  TRUE,
7137     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
7138   },
7139   {
7140     Ydrip_2_s,                          FALSE,  FALSE,
7141     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
7142   },
7143   {
7144     Ydrip_2_sB,                         FALSE,  TRUE,
7145     EL_AMOEBA_DROP,                     ACTION_FALLING, -1
7146   },
7147
7148   {
7149     Xwonderwall,                        TRUE,   FALSE,
7150     EL_MAGIC_WALL,                      -1, -1
7151   },
7152   {
7153     Ywonderwall,                        FALSE,  FALSE,
7154     EL_MAGIC_WALL,                      ACTION_ACTIVE, -1
7155   },
7156
7157   {
7158     Xwheel,                             TRUE,   FALSE,
7159     EL_ROBOT_WHEEL,                     -1, -1
7160   },
7161   {
7162     Ywheel,                             FALSE,  FALSE,
7163     EL_ROBOT_WHEEL,                     ACTION_ACTIVE, -1
7164   },
7165
7166   {
7167     Xswitch,                            TRUE,   FALSE,
7168     EL_EMC_MAGIC_BALL_SWITCH,           -1, -1
7169   },
7170   {
7171     Yswitch,                            FALSE,  FALSE,
7172     EL_EMC_MAGIC_BALL_SWITCH,           ACTION_ACTIVE, -1
7173   },
7174
7175   {
7176     Xbumper,                            TRUE,   FALSE,
7177     EL_EMC_SPRING_BUMPER,               -1, -1
7178   },
7179   {
7180     Ybumper,                            FALSE,  FALSE,
7181     EL_EMC_SPRING_BUMPER,               ACTION_ACTIVE, -1
7182   },
7183
7184   {
7185     Xacid_nw,                           TRUE,   FALSE,
7186     EL_ACID_POOL_TOPLEFT,               -1, -1
7187   },
7188   {
7189     Xacid_ne,                           TRUE,   FALSE,
7190     EL_ACID_POOL_TOPRIGHT,              -1, -1
7191   },
7192   {
7193     Xacid_sw,                           TRUE,   FALSE,
7194     EL_ACID_POOL_BOTTOMLEFT,            -1, -1
7195   },
7196   {
7197     Xacid_s,                            TRUE,   FALSE,
7198     EL_ACID_POOL_BOTTOM,                -1, -1
7199   },
7200   {
7201     Xacid_se,                           TRUE,   FALSE,
7202     EL_ACID_POOL_BOTTOMRIGHT,           -1, -1
7203   },
7204
7205   {
7206     Xfake_blank,                        TRUE,   FALSE,
7207     EL_INVISIBLE_WALL,                  -1, -1
7208   },
7209   {
7210     Yfake_blank,                        FALSE,  FALSE,
7211     EL_INVISIBLE_WALL,                  ACTION_ACTIVE, -1
7212   },
7213
7214   {
7215     Xfake_grass,                        TRUE,   FALSE,
7216     EL_EMC_FAKE_GRASS,                  -1, -1
7217   },
7218   {
7219     Yfake_grass,                        FALSE,  FALSE,
7220     EL_EMC_FAKE_GRASS,                  ACTION_ACTIVE, -1
7221   },
7222
7223   {
7224     Xfake_amoeba,                       TRUE,   FALSE,
7225     EL_EMC_DRIPPER,                     -1, -1
7226   },
7227   {
7228     Yfake_amoeba,                       FALSE,  FALSE,
7229     EL_EMC_DRIPPER,                     ACTION_ACTIVE, -1
7230   },
7231
7232   {
7233     Xlenses,                            TRUE,   FALSE,
7234     EL_EMC_LENSES,                      -1, -1
7235   },
7236
7237   {
7238     Xmagnify,                           TRUE,   FALSE,
7239     EL_EMC_MAGNIFIER,                   -1, -1
7240   },
7241
7242   {
7243     Xsand,                              TRUE,   FALSE,
7244     EL_QUICKSAND_EMPTY,                 -1, -1
7245   },
7246   {
7247     Xsand_stone,                        TRUE,   FALSE,
7248     EL_QUICKSAND_FULL,                  -1, -1
7249   },
7250   {
7251     Xsand_stonein_1,                    FALSE,  TRUE,
7252     EL_ROCK,                            ACTION_FILLING, -1
7253   },
7254   {
7255     Xsand_stonein_2,                    FALSE,  TRUE,
7256     EL_ROCK,                            ACTION_FILLING, -1
7257   },
7258   {
7259     Xsand_stonein_3,                    FALSE,  TRUE,
7260     EL_ROCK,                            ACTION_FILLING, -1
7261   },
7262   {
7263     Xsand_stonein_4,                    FALSE,  TRUE,
7264     EL_ROCK,                            ACTION_FILLING, -1
7265   },
7266   {
7267     Xsand_sandstone_1,                  FALSE,  FALSE,
7268     EL_QUICKSAND_FILLING,               -1, -1
7269   },
7270   {
7271     Xsand_sandstone_2,                  FALSE,  FALSE,
7272     EL_QUICKSAND_FILLING,               -1, -1
7273   },
7274   {
7275     Xsand_sandstone_3,                  FALSE,  FALSE,
7276     EL_QUICKSAND_FILLING,               -1, -1
7277   },
7278   {
7279     Xsand_sandstone_4,                  FALSE,  FALSE,
7280     EL_QUICKSAND_FILLING,               -1, -1
7281   },
7282   {
7283     Xsand_stonesand_1,                  FALSE,  FALSE,
7284     EL_QUICKSAND_EMPTYING,              -1, -1
7285   },
7286   {
7287     Xsand_stonesand_2,                  FALSE,  FALSE,
7288     EL_QUICKSAND_EMPTYING,              -1, -1
7289   },
7290   {
7291     Xsand_stonesand_3,                  FALSE,  FALSE,
7292     EL_QUICKSAND_EMPTYING,              -1, -1
7293   },
7294   {
7295     Xsand_stonesand_4,                  FALSE,  FALSE,
7296     EL_QUICKSAND_EMPTYING,              -1, -1
7297   },
7298   {
7299     Xsand_stoneout_1,                   FALSE,  FALSE,
7300     EL_ROCK,                            ACTION_EMPTYING, -1
7301   },
7302   {
7303     Xsand_stoneout_2,                   FALSE,  FALSE,
7304     EL_ROCK,                            ACTION_EMPTYING, -1
7305   },
7306   {
7307     Xsand_stonesand_quickout_1,         FALSE,  FALSE,
7308     EL_QUICKSAND_EMPTYING,              -1, -1
7309   },
7310   {
7311     Xsand_stonesand_quickout_2,         FALSE,  FALSE,
7312     EL_QUICKSAND_EMPTYING,              -1, -1
7313   },
7314
7315   {
7316     Xslide_ns,                          TRUE,   FALSE,
7317     EL_EXPANDABLE_WALL_VERTICAL,        -1, -1
7318   },
7319   {
7320     Yslide_ns_blank,                    FALSE,  FALSE,
7321     EL_EXPANDABLE_WALL_VERTICAL,        ACTION_GROWING, -1
7322   },
7323   {
7324     Xslide_ew,                          TRUE,   FALSE,
7325     EL_EXPANDABLE_WALL_HORIZONTAL,      -1, -1
7326   },
7327   {
7328     Yslide_ew_blank,                    FALSE,  FALSE,
7329     EL_EXPANDABLE_WALL_HORIZONTAL,      ACTION_GROWING, -1
7330   },
7331
7332   {
7333     Xwind_n,                            TRUE,   FALSE,
7334     EL_BALLOON_SWITCH_UP,               -1, -1
7335   },
7336   {
7337     Xwind_e,                            TRUE,   FALSE,
7338     EL_BALLOON_SWITCH_RIGHT,            -1, -1
7339   },
7340   {
7341     Xwind_s,                            TRUE,   FALSE,
7342     EL_BALLOON_SWITCH_DOWN,             -1, -1
7343   },
7344   {
7345     Xwind_w,                            TRUE,   FALSE,
7346     EL_BALLOON_SWITCH_LEFT,             -1, -1
7347   },
7348   {
7349     Xwind_any,                          TRUE,   FALSE,
7350     EL_BALLOON_SWITCH_ANY,              -1, -1
7351   },
7352   {
7353     Xwind_stop,                         TRUE,   FALSE,
7354     EL_BALLOON_SWITCH_NONE,             -1, -1
7355   },
7356
7357   {
7358     Xexit,                              TRUE,   FALSE,
7359     EL_EM_EXIT_CLOSED,                  -1, -1
7360   },
7361   {
7362     Xexit_1,                            TRUE,   FALSE,
7363     EL_EM_EXIT_OPEN,                    -1, -1
7364   },
7365   {
7366     Xexit_2,                            FALSE,  FALSE,
7367     EL_EM_EXIT_OPEN,                    -1, -1
7368   },
7369   {
7370     Xexit_3,                            FALSE,  FALSE,
7371     EL_EM_EXIT_OPEN,                    -1, -1
7372   },
7373
7374   {
7375     Xpause,                             FALSE,  FALSE,
7376     EL_EMPTY,                           -1, -1
7377   },
7378
7379   {
7380     Xwall_1,                            TRUE,   FALSE,
7381     EL_WALL,                            -1, -1
7382   },
7383   {
7384     Xwall_2,                            TRUE,   FALSE,
7385     EL_EMC_WALL_14,                     -1, -1
7386   },
7387   {
7388     Xwall_3,                            TRUE,   FALSE,
7389     EL_EMC_WALL_15,                     -1, -1
7390   },
7391   {
7392     Xwall_4,                            TRUE,   FALSE,
7393     EL_EMC_WALL_16,                     -1, -1
7394   },
7395
7396   {
7397     Xroundwall_1,                       TRUE,   FALSE,
7398     EL_WALL_SLIPPERY,                   -1, -1
7399   },
7400   {
7401     Xroundwall_2,                       TRUE,   FALSE,
7402     EL_EMC_WALL_SLIPPERY_2,             -1, -1
7403   },
7404   {
7405     Xroundwall_3,                       TRUE,   FALSE,
7406     EL_EMC_WALL_SLIPPERY_3,             -1, -1
7407   },
7408   {
7409     Xroundwall_4,                       TRUE,   FALSE,
7410     EL_EMC_WALL_SLIPPERY_4,             -1, -1
7411   },
7412
7413   {
7414     Xsteel_1,                           TRUE,   FALSE,
7415     EL_STEELWALL,                       -1, -1
7416   },
7417   {
7418     Xsteel_2,                           TRUE,   FALSE,
7419     EL_EMC_STEELWALL_2,                 -1, -1
7420   },
7421   {
7422     Xsteel_3,                           TRUE,   FALSE,
7423     EL_EMC_STEELWALL_3,                 -1, -1
7424   },
7425   {
7426     Xsteel_4,                           TRUE,   FALSE,
7427     EL_EMC_STEELWALL_4,                 -1, -1
7428   },
7429
7430   {
7431     Xdecor_1,                           TRUE,   FALSE,
7432     EL_EMC_WALL_8,                      -1, -1
7433   },
7434   {
7435     Xdecor_2,                           TRUE,   FALSE,
7436     EL_EMC_WALL_6,                      -1, -1
7437   },
7438   {
7439     Xdecor_3,                           TRUE,   FALSE,
7440     EL_EMC_WALL_4,                      -1, -1
7441   },
7442   {
7443     Xdecor_4,                           TRUE,   FALSE,
7444     EL_EMC_WALL_7,                      -1, -1
7445   },
7446   {
7447     Xdecor_5,                           TRUE,   FALSE,
7448     EL_EMC_WALL_5,                      -1, -1
7449   },
7450   {
7451     Xdecor_6,                           TRUE,   FALSE,
7452     EL_EMC_WALL_9,                      -1, -1
7453   },
7454   {
7455     Xdecor_7,                           TRUE,   FALSE,
7456     EL_EMC_WALL_10,                     -1, -1
7457   },
7458   {
7459     Xdecor_8,                           TRUE,   FALSE,
7460     EL_EMC_WALL_1,                      -1, -1
7461   },
7462   {
7463     Xdecor_9,                           TRUE,   FALSE,
7464     EL_EMC_WALL_2,                      -1, -1
7465   },
7466   {
7467     Xdecor_10,                          TRUE,   FALSE,
7468     EL_EMC_WALL_3,                      -1, -1
7469   },
7470   {
7471     Xdecor_11,                          TRUE,   FALSE,
7472     EL_EMC_WALL_11,                     -1, -1
7473   },
7474   {
7475     Xdecor_12,                          TRUE,   FALSE,
7476     EL_EMC_WALL_12,                     -1, -1
7477   },
7478
7479   {
7480     Xalpha_0,                           TRUE,   FALSE,
7481     EL_CHAR('0'),                       -1, -1
7482   },
7483   {
7484     Xalpha_1,                           TRUE,   FALSE,
7485     EL_CHAR('1'),                       -1, -1
7486   },
7487   {
7488     Xalpha_2,                           TRUE,   FALSE,
7489     EL_CHAR('2'),                       -1, -1
7490   },
7491   {
7492     Xalpha_3,                           TRUE,   FALSE,
7493     EL_CHAR('3'),                       -1, -1
7494   },
7495   {
7496     Xalpha_4,                           TRUE,   FALSE,
7497     EL_CHAR('4'),                       -1, -1
7498   },
7499   {
7500     Xalpha_5,                           TRUE,   FALSE,
7501     EL_CHAR('5'),                       -1, -1
7502   },
7503   {
7504     Xalpha_6,                           TRUE,   FALSE,
7505     EL_CHAR('6'),                       -1, -1
7506   },
7507   {
7508     Xalpha_7,                           TRUE,   FALSE,
7509     EL_CHAR('7'),                       -1, -1
7510   },
7511   {
7512     Xalpha_8,                           TRUE,   FALSE,
7513     EL_CHAR('8'),                       -1, -1
7514   },
7515   {
7516     Xalpha_9,                           TRUE,   FALSE,
7517     EL_CHAR('9'),                       -1, -1
7518   },
7519   {
7520     Xalpha_excla,                       TRUE,   FALSE,
7521     EL_CHAR('!'),                       -1, -1
7522   },
7523   {
7524     Xalpha_apost,                       TRUE,   FALSE,
7525     EL_CHAR('\''),                      -1, -1
7526   },
7527   {
7528     Xalpha_comma,                       TRUE,   FALSE,
7529     EL_CHAR(','),                       -1, -1
7530   },
7531   {
7532     Xalpha_minus,                       TRUE,   FALSE,
7533     EL_CHAR('-'),                       -1, -1
7534   },
7535   {
7536     Xalpha_perio,                       TRUE,   FALSE,
7537     EL_CHAR('.'),                       -1, -1
7538   },
7539   {
7540     Xalpha_colon,                       TRUE,   FALSE,
7541     EL_CHAR(':'),                       -1, -1
7542   },
7543   {
7544     Xalpha_quest,                       TRUE,   FALSE,
7545     EL_CHAR('?'),                       -1, -1
7546   },
7547   {
7548     Xalpha_a,                           TRUE,   FALSE,
7549     EL_CHAR('A'),                       -1, -1
7550   },
7551   {
7552     Xalpha_b,                           TRUE,   FALSE,
7553     EL_CHAR('B'),                       -1, -1
7554   },
7555   {
7556     Xalpha_c,                           TRUE,   FALSE,
7557     EL_CHAR('C'),                       -1, -1
7558   },
7559   {
7560     Xalpha_d,                           TRUE,   FALSE,
7561     EL_CHAR('D'),                       -1, -1
7562   },
7563   {
7564     Xalpha_e,                           TRUE,   FALSE,
7565     EL_CHAR('E'),                       -1, -1
7566   },
7567   {
7568     Xalpha_f,                           TRUE,   FALSE,
7569     EL_CHAR('F'),                       -1, -1
7570   },
7571   {
7572     Xalpha_g,                           TRUE,   FALSE,
7573     EL_CHAR('G'),                       -1, -1
7574   },
7575   {
7576     Xalpha_h,                           TRUE,   FALSE,
7577     EL_CHAR('H'),                       -1, -1
7578   },
7579   {
7580     Xalpha_i,                           TRUE,   FALSE,
7581     EL_CHAR('I'),                       -1, -1
7582   },
7583   {
7584     Xalpha_j,                           TRUE,   FALSE,
7585     EL_CHAR('J'),                       -1, -1
7586   },
7587   {
7588     Xalpha_k,                           TRUE,   FALSE,
7589     EL_CHAR('K'),                       -1, -1
7590   },
7591   {
7592     Xalpha_l,                           TRUE,   FALSE,
7593     EL_CHAR('L'),                       -1, -1
7594   },
7595   {
7596     Xalpha_m,                           TRUE,   FALSE,
7597     EL_CHAR('M'),                       -1, -1
7598   },
7599   {
7600     Xalpha_n,                           TRUE,   FALSE,
7601     EL_CHAR('N'),                       -1, -1
7602   },
7603   {
7604     Xalpha_o,                           TRUE,   FALSE,
7605     EL_CHAR('O'),                       -1, -1
7606   },
7607   {
7608     Xalpha_p,                           TRUE,   FALSE,
7609     EL_CHAR('P'),                       -1, -1
7610   },
7611   {
7612     Xalpha_q,                           TRUE,   FALSE,
7613     EL_CHAR('Q'),                       -1, -1
7614   },
7615   {
7616     Xalpha_r,                           TRUE,   FALSE,
7617     EL_CHAR('R'),                       -1, -1
7618   },
7619   {
7620     Xalpha_s,                           TRUE,   FALSE,
7621     EL_CHAR('S'),                       -1, -1
7622   },
7623   {
7624     Xalpha_t,                           TRUE,   FALSE,
7625     EL_CHAR('T'),                       -1, -1
7626   },
7627   {
7628     Xalpha_u,                           TRUE,   FALSE,
7629     EL_CHAR('U'),                       -1, -1
7630   },
7631   {
7632     Xalpha_v,                           TRUE,   FALSE,
7633     EL_CHAR('V'),                       -1, -1
7634   },
7635   {
7636     Xalpha_w,                           TRUE,   FALSE,
7637     EL_CHAR('W'),                       -1, -1
7638   },
7639   {
7640     Xalpha_x,                           TRUE,   FALSE,
7641     EL_CHAR('X'),                       -1, -1
7642   },
7643   {
7644     Xalpha_y,                           TRUE,   FALSE,
7645     EL_CHAR('Y'),                       -1, -1
7646   },
7647   {
7648     Xalpha_z,                           TRUE,   FALSE,
7649     EL_CHAR('Z'),                       -1, -1
7650   },
7651   {
7652     Xalpha_arrow_e,                     TRUE,   FALSE,
7653     EL_CHAR('>'),                       -1, -1
7654   },
7655   {
7656     Xalpha_arrow_w,                     TRUE,   FALSE,
7657     EL_CHAR('<'),                       -1, -1
7658   },
7659   {
7660     Xalpha_copyr,                       TRUE,   FALSE,
7661     EL_CHAR(CHAR_BYTE_COPYRIGHT),       -1, -1
7662   },
7663
7664   {
7665     Ykey_1_blank,                       FALSE,  FALSE,
7666     EL_EM_KEY_1,                        ACTION_COLLECTING, -1
7667   },
7668   {
7669     Ykey_2_blank,                       FALSE,  FALSE,
7670     EL_EM_KEY_2,                        ACTION_COLLECTING, -1
7671   },
7672   {
7673     Ykey_3_blank,                       FALSE,  FALSE,
7674     EL_EM_KEY_3,                        ACTION_COLLECTING, -1
7675   },
7676   {
7677     Ykey_4_blank,                       FALSE,  FALSE,
7678     EL_EM_KEY_4,                        ACTION_COLLECTING, -1
7679   },
7680   {
7681     Ykey_5_blank,                       FALSE,  FALSE,
7682     EL_EMC_KEY_5,                       ACTION_COLLECTING, -1
7683   },
7684   {
7685     Ykey_6_blank,                       FALSE,  FALSE,
7686     EL_EMC_KEY_6,                       ACTION_COLLECTING, -1
7687   },
7688   {
7689     Ykey_7_blank,                       FALSE,  FALSE,
7690     EL_EMC_KEY_7,                       ACTION_COLLECTING, -1
7691   },
7692   {
7693     Ykey_8_blank,                       FALSE,  FALSE,
7694     EL_EMC_KEY_8,                       ACTION_COLLECTING, -1
7695   },
7696   {
7697     Ylenses_blank,                      FALSE,  FALSE,
7698     EL_EMC_LENSES,                      ACTION_COLLECTING, -1
7699   },
7700   {
7701     Ymagnify_blank,                     FALSE,  FALSE,
7702     EL_EMC_MAGNIFIER,                   ACTION_COLLECTING, -1
7703   },
7704   {
7705     Ygrass_blank,                       FALSE,  FALSE,
7706     EL_EMC_GRASS,                       ACTION_SNAPPING, -1
7707   },
7708   {
7709     Ydirt_blank,                        FALSE,  FALSE,
7710     EL_SAND,                            ACTION_SNAPPING, -1
7711   },
7712
7713   {
7714     -1,                                 FALSE,  FALSE,
7715     -1,                                 -1, -1
7716   }
7717 };
7718
7719 static struct Mapping_EM_to_RND_player
7720 {
7721   int action_em;
7722   int player_nr;
7723
7724   int element_rnd;
7725   int action;
7726   int direction;
7727 }
7728 em_player_mapping_list[MAX_PLAYERS * PLY_MAX + 1] =
7729 {
7730   {
7731     PLY_walk_n,                         0,
7732     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_UP,
7733   },
7734   {
7735     PLY_walk_e,                         0,
7736     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_RIGHT,
7737   },
7738   {
7739     PLY_walk_s,                         0,
7740     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_DOWN,
7741   },
7742   {
7743     PLY_walk_w,                         0,
7744     EL_PLAYER_1,                        ACTION_MOVING, MV_BIT_LEFT,
7745   },
7746   {
7747     PLY_push_n,                         0,
7748     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_UP,
7749   },
7750   {
7751     PLY_push_e,                         0,
7752     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_RIGHT,
7753   },
7754   {
7755     PLY_push_s,                         0,
7756     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_DOWN,
7757   },
7758   {
7759     PLY_push_w,                         0,
7760     EL_PLAYER_1,                        ACTION_PUSHING, MV_BIT_LEFT,
7761   },
7762   {
7763     PLY_shoot_n,                        0,
7764     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_UP,
7765   },
7766   {
7767     PLY_shoot_e,                        0,
7768     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7769   },
7770   {
7771     PLY_shoot_s,                        0,
7772     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_DOWN,
7773   },
7774   {
7775     PLY_shoot_w,                        0,
7776     EL_PLAYER_1,                        ACTION_SNAPPING, MV_BIT_LEFT,
7777   },
7778   {
7779     PLY_walk_n,                         1,
7780     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_UP,
7781   },
7782   {
7783     PLY_walk_e,                         1,
7784     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_RIGHT,
7785   },
7786   {
7787     PLY_walk_s,                         1,
7788     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_DOWN,
7789   },
7790   {
7791     PLY_walk_w,                         1,
7792     EL_PLAYER_2,                        ACTION_MOVING, MV_BIT_LEFT,
7793   },
7794   {
7795     PLY_push_n,                         1,
7796     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_UP,
7797   },
7798   {
7799     PLY_push_e,                         1,
7800     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_RIGHT,
7801   },
7802   {
7803     PLY_push_s,                         1,
7804     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_DOWN,
7805   },
7806   {
7807     PLY_push_w,                         1,
7808     EL_PLAYER_2,                        ACTION_PUSHING, MV_BIT_LEFT,
7809   },
7810   {
7811     PLY_shoot_n,                        1,
7812     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_UP,
7813   },
7814   {
7815     PLY_shoot_e,                        1,
7816     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7817   },
7818   {
7819     PLY_shoot_s,                        1,
7820     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_DOWN,
7821   },
7822   {
7823     PLY_shoot_w,                        1,
7824     EL_PLAYER_2,                        ACTION_SNAPPING, MV_BIT_LEFT,
7825   },
7826   {
7827     PLY_still,                          0,
7828     EL_PLAYER_1,                        ACTION_DEFAULT, -1,
7829   },
7830   {
7831     PLY_still,                          1,
7832     EL_PLAYER_2,                        ACTION_DEFAULT, -1,
7833   },
7834   {
7835     PLY_walk_n,                         2,
7836     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_UP,
7837   },
7838   {
7839     PLY_walk_e,                         2,
7840     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_RIGHT,
7841   },
7842   {
7843     PLY_walk_s,                         2,
7844     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_DOWN,
7845   },
7846   {
7847     PLY_walk_w,                         2,
7848     EL_PLAYER_3,                        ACTION_MOVING, MV_BIT_LEFT,
7849   },
7850   {
7851     PLY_push_n,                         2,
7852     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_UP,
7853   },
7854   {
7855     PLY_push_e,                         2,
7856     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_RIGHT,
7857   },
7858   {
7859     PLY_push_s,                         2,
7860     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_DOWN,
7861   },
7862   {
7863     PLY_push_w,                         2,
7864     EL_PLAYER_3,                        ACTION_PUSHING, MV_BIT_LEFT,
7865   },
7866   {
7867     PLY_shoot_n,                        2,
7868     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_UP,
7869   },
7870   {
7871     PLY_shoot_e,                        2,
7872     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7873   },
7874   {
7875     PLY_shoot_s,                        2,
7876     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_DOWN,
7877   },
7878   {
7879     PLY_shoot_w,                        2,
7880     EL_PLAYER_3,                        ACTION_SNAPPING, MV_BIT_LEFT,
7881   },
7882   {
7883     PLY_walk_n,                         3,
7884     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_UP,
7885   },
7886   {
7887     PLY_walk_e,                         3,
7888     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_RIGHT,
7889   },
7890   {
7891     PLY_walk_s,                         3,
7892     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_DOWN,
7893   },
7894   {
7895     PLY_walk_w,                         3,
7896     EL_PLAYER_4,                        ACTION_MOVING, MV_BIT_LEFT,
7897   },
7898   {
7899     PLY_push_n,                         3,
7900     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_UP,
7901   },
7902   {
7903     PLY_push_e,                         3,
7904     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_RIGHT,
7905   },
7906   {
7907     PLY_push_s,                         3,
7908     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_DOWN,
7909   },
7910   {
7911     PLY_push_w,                         3,
7912     EL_PLAYER_4,                        ACTION_PUSHING, MV_BIT_LEFT,
7913   },
7914   {
7915     PLY_shoot_n,                        3,
7916     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_UP,
7917   },
7918   {
7919     PLY_shoot_e,                        3,
7920     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_RIGHT,
7921   },
7922   {
7923     PLY_shoot_s,                        3,
7924     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_DOWN,
7925   },
7926   {
7927     PLY_shoot_w,                        3,
7928     EL_PLAYER_4,                        ACTION_SNAPPING, MV_BIT_LEFT,
7929   },
7930   {
7931     PLY_still,                          2,
7932     EL_PLAYER_3,                        ACTION_DEFAULT, -1,
7933   },
7934   {
7935     PLY_still,                          3,
7936     EL_PLAYER_4,                        ACTION_DEFAULT, -1,
7937   },
7938
7939   {
7940     -1,                                 -1,
7941     -1,                                 -1, -1
7942   }
7943 };
7944
7945 int map_element_RND_to_EM_cave(int element_rnd)
7946 {
7947   static unsigned short mapping_RND_to_EM[NUM_FILE_ELEMENTS];
7948   static boolean mapping_initialized = FALSE;
7949
7950   if (!mapping_initialized)
7951   {
7952     int i;
7953
7954     // return "Xalpha_quest" for all undefined elements in mapping array
7955     for (i = 0; i < NUM_FILE_ELEMENTS; i++)
7956       mapping_RND_to_EM[i] = Xalpha_quest;
7957
7958     for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
7959       if (em_object_mapping_list[i].is_rnd_to_em_mapping)
7960         mapping_RND_to_EM[em_object_mapping_list[i].element_rnd] =
7961           em_object_mapping_list[i].element_em;
7962
7963     mapping_initialized = TRUE;
7964   }
7965
7966   if (element_rnd < 0 || element_rnd >= NUM_FILE_ELEMENTS)
7967   {
7968     Warn("invalid RND level element %d", element_rnd);
7969
7970     return EL_UNKNOWN;
7971   }
7972
7973   return map_em_element_X_to_C(mapping_RND_to_EM[element_rnd]);
7974 }
7975
7976 int map_element_EM_to_RND_cave(int element_em_cave)
7977 {
7978   static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
7979   static boolean mapping_initialized = FALSE;
7980
7981   if (!mapping_initialized)
7982   {
7983     int i;
7984
7985     // return "EL_UNKNOWN" for all undefined elements in mapping array
7986     for (i = 0; i < GAME_TILE_MAX; i++)
7987       mapping_EM_to_RND[i] = EL_UNKNOWN;
7988
7989     for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
7990       mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
7991         em_object_mapping_list[i].element_rnd;
7992
7993     mapping_initialized = TRUE;
7994   }
7995
7996   if (element_em_cave < 0 || element_em_cave >= CAVE_TILE_MAX)
7997   {
7998     Warn("invalid EM cave element %d", element_em_cave);
7999
8000     return EL_UNKNOWN;
8001   }
8002
8003   return mapping_EM_to_RND[map_em_element_C_to_X(element_em_cave)];
8004 }
8005
8006 int map_element_EM_to_RND_game(int element_em_game)
8007 {
8008   static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
8009   static boolean mapping_initialized = FALSE;
8010
8011   if (!mapping_initialized)
8012   {
8013     int i;
8014
8015     // return "EL_UNKNOWN" for all undefined elements in mapping array
8016     for (i = 0; i < GAME_TILE_MAX; i++)
8017       mapping_EM_to_RND[i] = EL_UNKNOWN;
8018
8019     for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8020       mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
8021         em_object_mapping_list[i].element_rnd;
8022
8023     mapping_initialized = TRUE;
8024   }
8025
8026   if (element_em_game < 0 || element_em_game >= GAME_TILE_MAX)
8027   {
8028     Warn("invalid EM game element %d", element_em_game);
8029
8030     return EL_UNKNOWN;
8031   }
8032
8033   return mapping_EM_to_RND[element_em_game];
8034 }
8035
8036 void map_android_clone_elements_RND_to_EM(struct LevelInfo *level)
8037 {
8038   struct LevelInfo_EM *level_em = level->native_em_level;
8039   struct CAVE *cav = level_em->cav;
8040   int i, j;
8041
8042   for (i = 0; i < GAME_TILE_MAX; i++)
8043     cav->android_array[i] = Cblank;
8044
8045   for (i = 0; i < level->num_android_clone_elements; i++)
8046   {
8047     int element_rnd = level->android_clone_element[i];
8048     int element_em_cave = map_element_RND_to_EM_cave(element_rnd);
8049
8050     for (j = 0; em_object_mapping_list[j].element_em != -1; j++)
8051       if (em_object_mapping_list[j].element_rnd == element_rnd)
8052         cav->android_array[em_object_mapping_list[j].element_em] =
8053           element_em_cave;
8054   }
8055 }
8056
8057 void map_android_clone_elements_EM_to_RND(struct LevelInfo *level)
8058 {
8059   struct LevelInfo_EM *level_em = level->native_em_level;
8060   struct CAVE *cav = level_em->cav;
8061   int i, j;
8062
8063   level->num_android_clone_elements = 0;
8064
8065   for (i = 0; i < GAME_TILE_MAX; i++)
8066   {
8067     int element_em_cave = cav->android_array[i];
8068     int element_rnd;
8069     boolean element_found = FALSE;
8070
8071     if (element_em_cave == Cblank)
8072       continue;
8073
8074     element_rnd = map_element_EM_to_RND_cave(element_em_cave);
8075
8076     for (j = 0; j < level->num_android_clone_elements; j++)
8077       if (level->android_clone_element[j] == element_rnd)
8078         element_found = TRUE;
8079
8080     if (!element_found)
8081     {
8082       level->android_clone_element[level->num_android_clone_elements++] =
8083         element_rnd;
8084
8085       if (level->num_android_clone_elements == MAX_ANDROID_ELEMENTS)
8086         break;
8087     }
8088   }
8089
8090   if (level->num_android_clone_elements == 0)
8091   {
8092     level->num_android_clone_elements = 1;
8093     level->android_clone_element[0] = EL_EMPTY;
8094   }
8095 }
8096
8097 int map_direction_RND_to_EM(int direction)
8098 {
8099   return (direction == MV_UP    ? 0 :
8100           direction == MV_RIGHT ? 1 :
8101           direction == MV_DOWN  ? 2 :
8102           direction == MV_LEFT  ? 3 :
8103           -1);
8104 }
8105
8106 int map_direction_EM_to_RND(int direction)
8107 {
8108   return (direction == 0 ? MV_UP    :
8109           direction == 1 ? MV_RIGHT :
8110           direction == 2 ? MV_DOWN  :
8111           direction == 3 ? MV_LEFT  :
8112           MV_NONE);
8113 }
8114
8115 int map_element_RND_to_SP(int element_rnd)
8116 {
8117   int element_sp = 0x20;        // map unknown elements to yellow "hardware"
8118
8119   if (element_rnd >= EL_SP_START &&
8120       element_rnd <= EL_SP_END)
8121     element_sp = element_rnd - EL_SP_START;
8122   else if (element_rnd == EL_EMPTY_SPACE)
8123     element_sp = 0x00;
8124   else if (element_rnd == EL_INVISIBLE_WALL)
8125     element_sp = 0x28;
8126
8127   return element_sp;
8128 }
8129
8130 int map_element_SP_to_RND(int element_sp)
8131 {
8132   int element_rnd = EL_UNKNOWN;
8133
8134   if (element_sp >= 0x00 &&
8135       element_sp <= 0x27)
8136     element_rnd = EL_SP_START + element_sp;
8137   else if (element_sp == 0x28)
8138     element_rnd = EL_INVISIBLE_WALL;
8139
8140   return element_rnd;
8141 }
8142
8143 int map_action_SP_to_RND(int action_sp)
8144 {
8145   switch (action_sp)
8146   {
8147     case actActive:             return ACTION_ACTIVE;
8148     case actImpact:             return ACTION_IMPACT;
8149     case actExploding:          return ACTION_EXPLODING;
8150     case actDigging:            return ACTION_DIGGING;
8151     case actSnapping:           return ACTION_SNAPPING;
8152     case actCollecting:         return ACTION_COLLECTING;
8153     case actPassing:            return ACTION_PASSING;
8154     case actPushing:            return ACTION_PUSHING;
8155     case actDropping:           return ACTION_DROPPING;
8156
8157     default:                    return ACTION_DEFAULT;
8158   }
8159 }
8160
8161 int map_element_RND_to_MM(int element_rnd)
8162 {
8163   return (element_rnd >= EL_MM_START_1 &&
8164           element_rnd <= EL_MM_END_1 ?
8165           EL_MM_START_1_NATIVE + element_rnd - EL_MM_START_1 :
8166
8167           element_rnd >= EL_MM_START_2 &&
8168           element_rnd <= EL_MM_END_2 ?
8169           EL_MM_START_2_NATIVE + element_rnd - EL_MM_START_2 :
8170
8171           element_rnd >= EL_MM_START_3 &&
8172           element_rnd <= EL_MM_END_3 ?
8173           EL_MM_START_3_NATIVE + element_rnd - EL_MM_START_3 :
8174
8175           element_rnd >= EL_CHAR_START &&
8176           element_rnd <= EL_CHAR_END ?
8177           EL_MM_CHAR_START_NATIVE + element_rnd - EL_CHAR_START :
8178
8179           element_rnd >= EL_MM_RUNTIME_START &&
8180           element_rnd <= EL_MM_RUNTIME_END ?
8181           EL_MM_RUNTIME_START_NATIVE + element_rnd - EL_MM_RUNTIME_START :
8182
8183           EL_MM_EMPTY_NATIVE);
8184 }
8185
8186 int map_element_MM_to_RND(int element_mm)
8187 {
8188   return (element_mm == EL_MM_EMPTY_NATIVE ||
8189           element_mm == EL_DF_EMPTY_NATIVE ?
8190           EL_EMPTY :
8191
8192           element_mm >= EL_MM_START_1_NATIVE &&
8193           element_mm <= EL_MM_END_1_NATIVE ?
8194           EL_MM_START_1 + element_mm - EL_MM_START_1_NATIVE :
8195
8196           element_mm >= EL_MM_START_2_NATIVE &&
8197           element_mm <= EL_MM_END_2_NATIVE ?
8198           EL_MM_START_2 + element_mm - EL_MM_START_2_NATIVE :
8199
8200           element_mm >= EL_MM_START_3_NATIVE &&
8201           element_mm <= EL_MM_END_3_NATIVE ?
8202           EL_MM_START_3 + element_mm - EL_MM_START_3_NATIVE :
8203
8204           element_mm >= EL_MM_CHAR_START_NATIVE &&
8205           element_mm <= EL_MM_CHAR_END_NATIVE ?
8206           EL_CHAR_START + element_mm - EL_MM_CHAR_START_NATIVE :
8207
8208           element_mm >= EL_MM_RUNTIME_START_NATIVE &&
8209           element_mm <= EL_MM_RUNTIME_END_NATIVE ?
8210           EL_MM_RUNTIME_START + element_mm - EL_MM_RUNTIME_START_NATIVE :
8211
8212           EL_EMPTY);
8213 }
8214
8215 int map_action_MM_to_RND(int action_mm)
8216 {
8217   // all MM actions are defined to exactly match their RND counterparts
8218   return action_mm;
8219 }
8220
8221 int map_sound_MM_to_RND(int sound_mm)
8222 {
8223   switch (sound_mm)
8224   {
8225     case SND_MM_GAME_LEVELTIME_CHARGING:
8226       return SND_GAME_LEVELTIME_CHARGING;
8227
8228     case SND_MM_GAME_HEALTH_CHARGING:
8229       return SND_GAME_HEALTH_CHARGING;
8230
8231     default:
8232       return SND_UNDEFINED;
8233   }
8234 }
8235
8236 int map_mm_wall_element(int element)
8237 {
8238   return (element >= EL_MM_STEEL_WALL_START &&
8239           element <= EL_MM_STEEL_WALL_END ?
8240           EL_MM_STEEL_WALL :
8241
8242           element >= EL_MM_WOODEN_WALL_START &&
8243           element <= EL_MM_WOODEN_WALL_END ?
8244           EL_MM_WOODEN_WALL :
8245
8246           element >= EL_MM_ICE_WALL_START &&
8247           element <= EL_MM_ICE_WALL_END ?
8248           EL_MM_ICE_WALL :
8249
8250           element >= EL_MM_AMOEBA_WALL_START &&
8251           element <= EL_MM_AMOEBA_WALL_END ?
8252           EL_MM_AMOEBA_WALL :
8253
8254           element >= EL_DF_STEEL_WALL_START &&
8255           element <= EL_DF_STEEL_WALL_END ?
8256           EL_DF_STEEL_WALL :
8257
8258           element >= EL_DF_WOODEN_WALL_START &&
8259           element <= EL_DF_WOODEN_WALL_END ?
8260           EL_DF_WOODEN_WALL :
8261
8262           element);
8263 }
8264
8265 int map_mm_wall_element_editor(int element)
8266 {
8267   switch (element)
8268   {
8269     case EL_MM_STEEL_WALL:      return EL_MM_STEEL_WALL_START;
8270     case EL_MM_WOODEN_WALL:     return EL_MM_WOODEN_WALL_START;
8271     case EL_MM_ICE_WALL:        return EL_MM_ICE_WALL_START;
8272     case EL_MM_AMOEBA_WALL:     return EL_MM_AMOEBA_WALL_START;
8273     case EL_DF_STEEL_WALL:      return EL_DF_STEEL_WALL_START;
8274     case EL_DF_WOODEN_WALL:     return EL_DF_WOODEN_WALL_START;
8275
8276     default:                    return element;
8277   }
8278 }
8279
8280 int get_next_element(int element)
8281 {
8282   switch (element)
8283   {
8284     case EL_QUICKSAND_FILLING:          return EL_QUICKSAND_FULL;
8285     case EL_QUICKSAND_EMPTYING:         return EL_QUICKSAND_EMPTY;
8286     case EL_QUICKSAND_FAST_FILLING:     return EL_QUICKSAND_FAST_FULL;
8287     case EL_QUICKSAND_FAST_EMPTYING:    return EL_QUICKSAND_FAST_EMPTY;
8288     case EL_MAGIC_WALL_FILLING:         return EL_MAGIC_WALL_FULL;
8289     case EL_MAGIC_WALL_EMPTYING:        return EL_MAGIC_WALL_ACTIVE;
8290     case EL_BD_MAGIC_WALL_FILLING:      return EL_BD_MAGIC_WALL_FULL;
8291     case EL_BD_MAGIC_WALL_EMPTYING:     return EL_BD_MAGIC_WALL_ACTIVE;
8292     case EL_DC_MAGIC_WALL_FILLING:      return EL_DC_MAGIC_WALL_FULL;
8293     case EL_DC_MAGIC_WALL_EMPTYING:     return EL_DC_MAGIC_WALL_ACTIVE;
8294     case EL_AMOEBA_DROPPING:            return EL_AMOEBA_WET;
8295
8296     default:                            return element;
8297   }
8298 }
8299
8300 int el2img_mm(int element_mm)
8301 {
8302   return el2img(map_element_MM_to_RND(element_mm));
8303 }
8304
8305 int el_act2img_mm(int element_mm, int action)
8306 {
8307   return el_act2img(map_element_MM_to_RND(element_mm), action);
8308 }
8309
8310 int el_act_dir2img(int element, int action, int direction)
8311 {
8312   element = GFX_ELEMENT(element);
8313   direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
8314
8315   // direction_graphic[][] == graphic[] for undefined direction graphics
8316   return element_info[element].direction_graphic[action][direction];
8317 }
8318
8319 static int el_act_dir2crm(int element, int action, int direction)
8320 {
8321   element = GFX_ELEMENT(element);
8322   direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
8323
8324   // direction_graphic[][] == graphic[] for undefined direction graphics
8325   return element_info[element].direction_crumbled[action][direction];
8326 }
8327
8328 int el_act2img(int element, int action)
8329 {
8330   element = GFX_ELEMENT(element);
8331
8332   return element_info[element].graphic[action];
8333 }
8334
8335 int el_act2crm(int element, int action)
8336 {
8337   element = GFX_ELEMENT(element);
8338
8339   return element_info[element].crumbled[action];
8340 }
8341
8342 int el_dir2img(int element, int direction)
8343 {
8344   element = GFX_ELEMENT(element);
8345
8346   return el_act_dir2img(element, ACTION_DEFAULT, direction);
8347 }
8348
8349 int el2baseimg(int element)
8350 {
8351   return element_info[element].graphic[ACTION_DEFAULT];
8352 }
8353
8354 int el2img(int element)
8355 {
8356   element = GFX_ELEMENT(element);
8357
8358   return element_info[element].graphic[ACTION_DEFAULT];
8359 }
8360
8361 int el2edimg(int element)
8362 {
8363   element = GFX_ELEMENT(element);
8364
8365   return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
8366 }
8367
8368 int el2preimg(int element)
8369 {
8370   element = GFX_ELEMENT(element);
8371
8372   return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
8373 }
8374
8375 int el2panelimg(int element)
8376 {
8377   element = GFX_ELEMENT(element);
8378
8379   return element_info[element].special_graphic[GFX_SPECIAL_ARG_PANEL];
8380 }
8381
8382 int font2baseimg(int font_nr)
8383 {
8384   return font_info[font_nr].special_graphic[GFX_SPECIAL_ARG_DEFAULT];
8385 }
8386
8387 int getBeltNrFromBeltElement(int element)
8388 {
8389   return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
8390           element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
8391           element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
8392 }
8393
8394 int getBeltNrFromBeltActiveElement(int element)
8395 {
8396   return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
8397           element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
8398           element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
8399 }
8400
8401 int getBeltNrFromBeltSwitchElement(int element)
8402 {
8403   return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
8404           element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
8405           element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
8406 }
8407
8408 int getBeltDirNrFromBeltElement(int element)
8409 {
8410   static int belt_base_element[4] =
8411   {
8412     EL_CONVEYOR_BELT_1_LEFT,
8413     EL_CONVEYOR_BELT_2_LEFT,
8414     EL_CONVEYOR_BELT_3_LEFT,
8415     EL_CONVEYOR_BELT_4_LEFT
8416   };
8417
8418   int belt_nr = getBeltNrFromBeltElement(element);
8419   int belt_dir_nr = element - belt_base_element[belt_nr];
8420
8421   return (belt_dir_nr % 3);
8422 }
8423
8424 int getBeltDirNrFromBeltSwitchElement(int element)
8425 {
8426   static int belt_base_element[4] =
8427   {
8428     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
8429     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
8430     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
8431     EL_CONVEYOR_BELT_4_SWITCH_LEFT
8432   };
8433
8434   int belt_nr = getBeltNrFromBeltSwitchElement(element);
8435   int belt_dir_nr = element - belt_base_element[belt_nr];
8436
8437   return (belt_dir_nr % 3);
8438 }
8439
8440 int getBeltDirFromBeltElement(int element)
8441 {
8442   static int belt_move_dir[3] =
8443   {
8444     MV_LEFT,
8445     MV_NONE,
8446     MV_RIGHT
8447   };
8448
8449   int belt_dir_nr = getBeltDirNrFromBeltElement(element);
8450
8451   return belt_move_dir[belt_dir_nr];
8452 }
8453
8454 int getBeltDirFromBeltSwitchElement(int element)
8455 {
8456   static int belt_move_dir[3] =
8457   {
8458     MV_LEFT,
8459     MV_NONE,
8460     MV_RIGHT
8461   };
8462
8463   int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
8464
8465   return belt_move_dir[belt_dir_nr];
8466 }
8467
8468 int getBeltElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
8469 {
8470   static int belt_base_element[4] =
8471   {
8472     EL_CONVEYOR_BELT_1_LEFT,
8473     EL_CONVEYOR_BELT_2_LEFT,
8474     EL_CONVEYOR_BELT_3_LEFT,
8475     EL_CONVEYOR_BELT_4_LEFT
8476   };
8477
8478   return belt_base_element[belt_nr] + belt_dir_nr;
8479 }
8480
8481 int getBeltElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
8482 {
8483   int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
8484
8485   return getBeltElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
8486 }
8487
8488 int getBeltSwitchElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
8489 {
8490   static int belt_base_element[4] =
8491   {
8492     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
8493     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
8494     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
8495     EL_CONVEYOR_BELT_4_SWITCH_LEFT
8496   };
8497
8498   return belt_base_element[belt_nr] + belt_dir_nr;
8499 }
8500
8501 int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
8502 {
8503   int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
8504
8505   return getBeltSwitchElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
8506 }
8507
8508 boolean swapTiles_EM(boolean is_pre_emc_cave)
8509 {
8510   return is_pre_emc_cave && leveldir_current->use_emc_tiles;
8511 }
8512
8513 boolean getTeamMode_EM(void)
8514 {
8515   return game.team_mode || network_playing;
8516 }
8517
8518 boolean isActivePlayer_EM(int player_nr)
8519 {
8520   return stored_player[player_nr].active;
8521 }
8522
8523 unsigned int InitRND(int seed)
8524 {
8525   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
8526     return InitEngineRandom_EM(seed);
8527   else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
8528     return InitEngineRandom_SP(seed);
8529   else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
8530     return InitEngineRandom_MM(seed);
8531   else
8532     return InitEngineRandom_RND(seed);
8533 }
8534
8535 static struct Mapping_EM_to_RND_object object_mapping[GAME_TILE_MAX];
8536 static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][PLY_MAX];
8537
8538 static int get_effective_element_EM(int tile, int frame_em)
8539 {
8540   int element             = object_mapping[tile].element_rnd;
8541   int action              = object_mapping[tile].action;
8542   boolean is_backside     = object_mapping[tile].is_backside;
8543   boolean action_removing = (action == ACTION_DIGGING ||
8544                              action == ACTION_SNAPPING ||
8545                              action == ACTION_COLLECTING);
8546
8547   if (frame_em < 7)
8548   {
8549     switch (tile)
8550     {
8551       case Xsplash_e:
8552       case Xsplash_w:
8553         return (frame_em > 5 ? EL_EMPTY : element);
8554
8555       default:
8556         return element;
8557     }
8558   }
8559   else  // frame_em == 7
8560   {
8561     switch (tile)
8562     {
8563       case Xsplash_e:
8564       case Xsplash_w:
8565         return EL_EMPTY;
8566
8567       case Ynut_stone:
8568         return EL_EMERALD;
8569
8570       case Ydiamond_stone:
8571         return EL_ROCK;
8572
8573       case Xdrip_stretch:
8574       case Xdrip_stretchB:
8575       case Ydrip_1_s:
8576       case Ydrip_1_sB:
8577       case Yball_1:
8578       case Xball_2:
8579       case Yball_2:
8580       case Yball_blank:
8581       case Ykey_1_blank:
8582       case Ykey_2_blank:
8583       case Ykey_3_blank:
8584       case Ykey_4_blank:
8585       case Ykey_5_blank:
8586       case Ykey_6_blank:
8587       case Ykey_7_blank:
8588       case Ykey_8_blank:
8589       case Ylenses_blank:
8590       case Ymagnify_blank:
8591       case Ygrass_blank:
8592       case Ydirt_blank:
8593       case Xsand_stonein_1:
8594       case Xsand_stonein_2:
8595       case Xsand_stonein_3:
8596       case Xsand_stonein_4:
8597         return element;
8598
8599       default:
8600         return (is_backside || action_removing ? EL_EMPTY : element);
8601     }
8602   }
8603 }
8604
8605 static boolean check_linear_animation_EM(int tile)
8606 {
8607   switch (tile)
8608   {
8609     case Xsand_stonesand_1:
8610     case Xsand_stonesand_quickout_1:
8611     case Xsand_sandstone_1:
8612     case Xsand_stonein_1:
8613     case Xsand_stoneout_1:
8614     case Xboom_1:
8615     case Xdynamite_1:
8616     case Ybug_w_n:
8617     case Ybug_n_e:
8618     case Ybug_e_s:
8619     case Ybug_s_w:
8620     case Ybug_e_n:
8621     case Ybug_s_e:
8622     case Ybug_w_s:
8623     case Ybug_n_w:
8624     case Ytank_w_n:
8625     case Ytank_n_e:
8626     case Ytank_e_s:
8627     case Ytank_s_w:
8628     case Ytank_e_n:
8629     case Ytank_s_e:
8630     case Ytank_w_s:
8631     case Ytank_n_w:
8632     case Xsplash_e:
8633     case Xsplash_w:
8634     case Ynut_stone:
8635       return TRUE;
8636   }
8637
8638   return FALSE;
8639 }
8640
8641 static void set_crumbled_graphics_EM(struct GraphicInfo_EM *g_em,
8642                                      boolean has_crumbled_graphics,
8643                                      int crumbled, int sync_frame)
8644 {
8645   // if element can be crumbled, but certain action graphics are just empty
8646   // space (like instantly snapping sand to empty space in 1 frame), do not
8647   // treat these empty space graphics as crumbled graphics in EMC engine
8648   if (crumbled == IMG_EMPTY_SPACE)
8649     has_crumbled_graphics = FALSE;
8650
8651   if (has_crumbled_graphics)
8652   {
8653     struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
8654     int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
8655                                            g_crumbled->anim_delay,
8656                                            g_crumbled->anim_mode,
8657                                            g_crumbled->anim_start_frame,
8658                                            sync_frame);
8659
8660     getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
8661                      &g_em->crumbled_src_x, &g_em->crumbled_src_y);
8662
8663     g_em->crumbled_border_size = graphic_info[crumbled].border_size;
8664     g_em->crumbled_tile_size = graphic_info[crumbled].tile_size;
8665
8666     g_em->has_crumbled_graphics = TRUE;
8667   }
8668   else
8669   {
8670     g_em->crumbled_bitmap = NULL;
8671     g_em->crumbled_src_x = 0;
8672     g_em->crumbled_src_y = 0;
8673     g_em->crumbled_border_size = 0;
8674     g_em->crumbled_tile_size = 0;
8675
8676     g_em->has_crumbled_graphics = FALSE;
8677   }
8678 }
8679
8680 #if 0
8681 void ResetGfxAnimation_EM(int x, int y, int tile)
8682 {
8683   GfxFrame[x][y] = 0;
8684 }
8685 #endif
8686
8687 void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
8688                         int tile, int frame_em, int x, int y)
8689 {
8690   int action = object_mapping[tile].action;
8691   int direction = object_mapping[tile].direction;
8692   int effective_element = get_effective_element_EM(tile, frame_em);
8693   int graphic = (direction == MV_NONE ?
8694                  el_act2img(effective_element, action) :
8695                  el_act_dir2img(effective_element, action, direction));
8696   struct GraphicInfo *g = &graphic_info[graphic];
8697   int sync_frame;
8698   boolean action_removing = (action == ACTION_DIGGING ||
8699                              action == ACTION_SNAPPING ||
8700                              action == ACTION_COLLECTING);
8701   boolean action_moving   = (action == ACTION_FALLING ||
8702                              action == ACTION_MOVING ||
8703                              action == ACTION_PUSHING ||
8704                              action == ACTION_EATING ||
8705                              action == ACTION_FILLING ||
8706                              action == ACTION_EMPTYING);
8707   boolean action_falling  = (action == ACTION_FALLING ||
8708                              action == ACTION_FILLING ||
8709                              action == ACTION_EMPTYING);
8710
8711   // special case: graphic uses "2nd movement tile" and has defined
8712   // 7 frames for movement animation (or less) => use default graphic
8713   // for last (8th) frame which ends the movement animation
8714   if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
8715   {
8716     action = ACTION_DEFAULT;    // (keep action_* unchanged for now)
8717     graphic = (direction == MV_NONE ?
8718                el_act2img(effective_element, action) :
8719                el_act_dir2img(effective_element, action, direction));
8720
8721     g = &graphic_info[graphic];
8722   }
8723
8724   if ((action_removing || check_linear_animation_EM(tile)) && frame_em == 0)
8725   {
8726     GfxFrame[x][y] = 0;
8727   }
8728   else if (action_moving)
8729   {
8730     boolean is_backside = object_mapping[tile].is_backside;
8731
8732     if (is_backside)
8733     {
8734       int direction = object_mapping[tile].direction;
8735       int move_dir = (action_falling ? MV_DOWN : direction);
8736
8737       GfxFrame[x][y]++;
8738
8739 #if 1
8740       // !!! TEST !!! NEW !!! DOES NOT WORK RIGHT YET !!!
8741       if (g->double_movement && frame_em == 0)
8742         GfxFrame[x][y] = 0;
8743 #endif
8744
8745       if (move_dir == MV_LEFT)
8746         GfxFrame[x - 1][y] = GfxFrame[x][y];
8747       else if (move_dir == MV_RIGHT)
8748         GfxFrame[x + 1][y] = GfxFrame[x][y];
8749       else if (move_dir == MV_UP)
8750         GfxFrame[x][y - 1] = GfxFrame[x][y];
8751       else if (move_dir == MV_DOWN)
8752         GfxFrame[x][y + 1] = GfxFrame[x][y];
8753     }
8754   }
8755   else
8756   {
8757     GfxFrame[x][y]++;
8758
8759     // special case: animation for Xsand_stonesand_quickout_1/2 twice as fast
8760     if (tile == Xsand_stonesand_quickout_1 ||
8761         tile == Xsand_stonesand_quickout_2)
8762       GfxFrame[x][y]++;
8763   }
8764
8765   if (graphic_info[graphic].anim_global_sync)
8766     sync_frame = FrameCounter;
8767   else if (graphic_info[graphic].anim_global_anim_sync)
8768     sync_frame = getGlobalAnimSyncFrame();
8769   else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
8770     sync_frame = GfxFrame[x][y];
8771   else
8772     sync_frame = 0;     // playfield border (pseudo steel)
8773
8774   SetRandomAnimationValue(x, y);
8775
8776   int frame = getAnimationFrame(g->anim_frames,
8777                                 g->anim_delay,
8778                                 g->anim_mode,
8779                                 g->anim_start_frame,
8780                                 sync_frame);
8781
8782   g_em->unique_identifier =
8783     (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
8784 }
8785
8786 void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
8787                                   int tile, int frame_em, int x, int y)
8788 {
8789   int action = object_mapping[tile].action;
8790   int direction = object_mapping[tile].direction;
8791   boolean is_backside = object_mapping[tile].is_backside;
8792   int effective_element = get_effective_element_EM(tile, frame_em);
8793   int effective_action = action;
8794   int graphic = (direction == MV_NONE ?
8795                  el_act2img(effective_element, effective_action) :
8796                  el_act_dir2img(effective_element, effective_action,
8797                                 direction));
8798   int crumbled = (direction == MV_NONE ?
8799                   el_act2crm(effective_element, effective_action) :
8800                   el_act_dir2crm(effective_element, effective_action,
8801                                  direction));
8802   int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
8803   int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
8804   boolean has_crumbled_graphics = (base_crumbled != base_graphic);
8805   struct GraphicInfo *g = &graphic_info[graphic];
8806   int sync_frame;
8807
8808   // special case: graphic uses "2nd movement tile" and has defined
8809   // 7 frames for movement animation (or less) => use default graphic
8810   // for last (8th) frame which ends the movement animation
8811   if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
8812   {
8813     effective_action = ACTION_DEFAULT;
8814     graphic = (direction == MV_NONE ?
8815                el_act2img(effective_element, effective_action) :
8816                el_act_dir2img(effective_element, effective_action,
8817                               direction));
8818     crumbled = (direction == MV_NONE ?
8819                 el_act2crm(effective_element, effective_action) :
8820                 el_act_dir2crm(effective_element, effective_action,
8821                                direction));
8822
8823     g = &graphic_info[graphic];
8824   }
8825
8826   if (graphic_info[graphic].anim_global_sync)
8827     sync_frame = FrameCounter;
8828   else if (graphic_info[graphic].anim_global_anim_sync)
8829     sync_frame = getGlobalAnimSyncFrame();
8830   else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
8831     sync_frame = GfxFrame[x][y];
8832   else
8833     sync_frame = 0;     // playfield border (pseudo steel)
8834
8835   SetRandomAnimationValue(x, y);
8836
8837   int frame = getAnimationFrame(g->anim_frames,
8838                                 g->anim_delay,
8839                                 g->anim_mode,
8840                                 g->anim_start_frame,
8841                                 sync_frame);
8842
8843   getGraphicSourceExt(graphic, frame, &g_em->bitmap, &g_em->src_x, &g_em->src_y,
8844                       g->double_movement && is_backside);
8845
8846   // (updating the "crumbled" graphic definitions is probably not really needed,
8847   // as animations for crumbled graphics can't be longer than one EMC cycle)
8848   set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
8849                            sync_frame);
8850 }
8851
8852 void getGraphicSourcePlayerExt_EM(struct GraphicInfo_EM *g_em,
8853                                   int player_nr, int anim, int frame_em)
8854 {
8855   int element   = player_mapping[player_nr][anim].element_rnd;
8856   int action    = player_mapping[player_nr][anim].action;
8857   int direction = player_mapping[player_nr][anim].direction;
8858   int graphic = (direction == MV_NONE ?
8859                  el_act2img(element, action) :
8860                  el_act_dir2img(element, action, direction));
8861   struct GraphicInfo *g = &graphic_info[graphic];
8862   int sync_frame;
8863
8864   InitPlayerGfxAnimation(&stored_player[player_nr], action, direction);
8865
8866   stored_player[player_nr].StepFrame = frame_em;
8867
8868   sync_frame = stored_player[player_nr].Frame;
8869
8870   int frame = getAnimationFrame(g->anim_frames,
8871                                 g->anim_delay,
8872                                 g->anim_mode,
8873                                 g->anim_start_frame,
8874                                 sync_frame);
8875
8876   getGraphicSourceExt(graphic, frame, &g_em->bitmap,
8877                       &g_em->src_x, &g_em->src_y, FALSE);
8878 }
8879
8880 void InitGraphicInfo_EM(void)
8881 {
8882   int i, j, p;
8883
8884   // always start with reliable default values
8885   for (i = 0; i < GAME_TILE_MAX; i++)
8886   {
8887     object_mapping[i].element_rnd = EL_UNKNOWN;
8888     object_mapping[i].is_backside = FALSE;
8889     object_mapping[i].action = ACTION_DEFAULT;
8890     object_mapping[i].direction = MV_NONE;
8891   }
8892
8893   // always start with reliable default values
8894   for (p = 0; p < MAX_PLAYERS; p++)
8895   {
8896     for (i = 0; i < PLY_MAX; i++)
8897     {
8898       player_mapping[p][i].element_rnd = EL_UNKNOWN;
8899       player_mapping[p][i].action = ACTION_DEFAULT;
8900       player_mapping[p][i].direction = MV_NONE;
8901     }
8902   }
8903
8904   for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8905   {
8906     int e = em_object_mapping_list[i].element_em;
8907
8908     object_mapping[e].element_rnd = em_object_mapping_list[i].element_rnd;
8909     object_mapping[e].is_backside = em_object_mapping_list[i].is_backside;
8910
8911     if (em_object_mapping_list[i].action != -1)
8912       object_mapping[e].action = em_object_mapping_list[i].action;
8913
8914     if (em_object_mapping_list[i].direction != -1)
8915       object_mapping[e].direction =
8916         MV_DIR_FROM_BIT(em_object_mapping_list[i].direction);
8917   }
8918
8919   for (i = 0; em_player_mapping_list[i].action_em != -1; i++)
8920   {
8921     int a = em_player_mapping_list[i].action_em;
8922     int p = em_player_mapping_list[i].player_nr;
8923
8924     player_mapping[p][a].element_rnd = em_player_mapping_list[i].element_rnd;
8925
8926     if (em_player_mapping_list[i].action != -1)
8927       player_mapping[p][a].action = em_player_mapping_list[i].action;
8928
8929     if (em_player_mapping_list[i].direction != -1)
8930       player_mapping[p][a].direction =
8931         MV_DIR_FROM_BIT(em_player_mapping_list[i].direction);
8932   }
8933
8934   for (i = 0; i < GAME_TILE_MAX; i++)
8935   {
8936     int element = object_mapping[i].element_rnd;
8937     int action = object_mapping[i].action;
8938     int direction = object_mapping[i].direction;
8939     boolean is_backside = object_mapping[i].is_backside;
8940     boolean action_exploding = ((action == ACTION_EXPLODING ||
8941                                  action == ACTION_SMASHED_BY_ROCK ||
8942                                  action == ACTION_SMASHED_BY_SPRING) &&
8943                                 element != EL_DIAMOND);
8944     boolean action_active = (action == ACTION_ACTIVE);
8945     boolean action_other = (action == ACTION_OTHER);
8946
8947     for (j = 0; j < 8; j++)
8948     {
8949       int effective_element = get_effective_element_EM(i, j);
8950       int effective_action = (j < 7 ? action :
8951                               i == Xdrip_stretch ? action :
8952                               i == Xdrip_stretchB ? action :
8953                               i == Ydrip_1_s ? action :
8954                               i == Ydrip_1_sB ? action :
8955                               i == Yball_1 ? action :
8956                               i == Xball_2 ? action :
8957                               i == Yball_2 ? action :
8958                               i == Yball_blank ? action :
8959                               i == Ykey_1_blank ? action :
8960                               i == Ykey_2_blank ? action :
8961                               i == Ykey_3_blank ? action :
8962                               i == Ykey_4_blank ? action :
8963                               i == Ykey_5_blank ? action :
8964                               i == Ykey_6_blank ? action :
8965                               i == Ykey_7_blank ? action :
8966                               i == Ykey_8_blank ? action :
8967                               i == Ylenses_blank ? action :
8968                               i == Ymagnify_blank ? action :
8969                               i == Ygrass_blank ? action :
8970                               i == Ydirt_blank ? action :
8971                               i == Xsand_stonein_1 ? action :
8972                               i == Xsand_stonein_2 ? action :
8973                               i == Xsand_stonein_3 ? action :
8974                               i == Xsand_stonein_4 ? action :
8975                               i == Xsand_stoneout_1 ? action :
8976                               i == Xsand_stoneout_2 ? action :
8977                               i == Xboom_android ? ACTION_EXPLODING :
8978                               action_exploding ? ACTION_EXPLODING :
8979                               action_active ? action :
8980                               action_other ? action :
8981                               ACTION_DEFAULT);
8982       int graphic = (el_act_dir2img(effective_element, effective_action,
8983                                     direction));
8984       int crumbled = (el_act_dir2crm(effective_element, effective_action,
8985                                      direction));
8986       int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
8987       int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
8988       boolean has_action_graphics = (graphic != base_graphic);
8989       boolean has_crumbled_graphics = (base_crumbled != base_graphic);
8990       struct GraphicInfo *g = &graphic_info[graphic];
8991       struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
8992       Bitmap *src_bitmap;
8993       int src_x, src_y;
8994       // ensure to get symmetric 3-frame, 2-delay animations as used in EM
8995       boolean special_animation = (action != ACTION_DEFAULT &&
8996                                    g->anim_frames == 3 &&
8997                                    g->anim_delay == 2 &&
8998                                    g->anim_mode & ANIM_LINEAR);
8999       int sync_frame = (i == Xdrip_stretch ? 7 :
9000                         i == Xdrip_stretchB ? 7 :
9001                         i == Ydrip_2_s ? j + 8 :
9002                         i == Ydrip_2_sB ? j + 8 :
9003                         i == Xacid_1 ? 0 :
9004                         i == Xacid_2 ? 10 :
9005                         i == Xacid_3 ? 20 :
9006                         i == Xacid_4 ? 30 :
9007                         i == Xacid_5 ? 40 :
9008                         i == Xacid_6 ? 50 :
9009                         i == Xacid_7 ? 60 :
9010                         i == Xacid_8 ? 70 :
9011                         i == Xfake_acid_1 ? 0 :
9012                         i == Xfake_acid_2 ? 10 :
9013                         i == Xfake_acid_3 ? 20 :
9014                         i == Xfake_acid_4 ? 30 :
9015                         i == Xfake_acid_5 ? 40 :
9016                         i == Xfake_acid_6 ? 50 :
9017                         i == Xfake_acid_7 ? 60 :
9018                         i == Xfake_acid_8 ? 70 :
9019                         i == Xfake_acid_1_player ? 0 :
9020                         i == Xfake_acid_2_player ? 10 :
9021                         i == Xfake_acid_3_player ? 20 :
9022                         i == Xfake_acid_4_player ? 30 :
9023                         i == Xfake_acid_5_player ? 40 :
9024                         i == Xfake_acid_6_player ? 50 :
9025                         i == Xfake_acid_7_player ? 60 :
9026                         i == Xfake_acid_8_player ? 70 :
9027                         i == Xball_2 ? 7 :
9028                         i == Yball_2 ? j + 8 :
9029                         i == Yball_blank ? j + 1 :
9030                         i == Ykey_1_blank ? j + 1 :
9031                         i == Ykey_2_blank ? j + 1 :
9032                         i == Ykey_3_blank ? j + 1 :
9033                         i == Ykey_4_blank ? j + 1 :
9034                         i == Ykey_5_blank ? j + 1 :
9035                         i == Ykey_6_blank ? j + 1 :
9036                         i == Ykey_7_blank ? j + 1 :
9037                         i == Ykey_8_blank ? j + 1 :
9038                         i == Ylenses_blank ? j + 1 :
9039                         i == Ymagnify_blank ? j + 1 :
9040                         i == Ygrass_blank ? j + 1 :
9041                         i == Ydirt_blank ? j + 1 :
9042                         i == Xamoeba_1 ? 0 :
9043                         i == Xamoeba_2 ? 1 :
9044                         i == Xamoeba_3 ? 2 :
9045                         i == Xamoeba_4 ? 3 :
9046                         i == Xamoeba_5 ? 0 :
9047                         i == Xamoeba_6 ? 1 :
9048                         i == Xamoeba_7 ? 2 :
9049                         i == Xamoeba_8 ? 3 :
9050                         i == Xexit_2 ? j + 8 :
9051                         i == Xexit_3 ? j + 16 :
9052                         i == Xdynamite_1 ? 0 :
9053                         i == Xdynamite_2 ? 8 :
9054                         i == Xdynamite_3 ? 16 :
9055                         i == Xdynamite_4 ? 24 :
9056                         i == Xsand_stonein_1 ? j + 1 :
9057                         i == Xsand_stonein_2 ? j + 9 :
9058                         i == Xsand_stonein_3 ? j + 17 :
9059                         i == Xsand_stonein_4 ? j + 25 :
9060                         i == Xsand_stoneout_1 && j == 0 ? 0 :
9061                         i == Xsand_stoneout_1 && j == 1 ? 0 :
9062                         i == Xsand_stoneout_1 && j == 2 ? 1 :
9063                         i == Xsand_stoneout_1 && j == 3 ? 2 :
9064                         i == Xsand_stoneout_1 && j == 4 ? 2 :
9065                         i == Xsand_stoneout_1 && j == 5 ? 3 :
9066                         i == Xsand_stoneout_1 && j == 6 ? 4 :
9067                         i == Xsand_stoneout_1 && j == 7 ? 4 :
9068                         i == Xsand_stoneout_2 && j == 0 ? 5 :
9069                         i == Xsand_stoneout_2 && j == 1 ? 6 :
9070                         i == Xsand_stoneout_2 && j == 2 ? 7 :
9071                         i == Xsand_stoneout_2 && j == 3 ? 8 :
9072                         i == Xsand_stoneout_2 && j == 4 ? 9 :
9073                         i == Xsand_stoneout_2 && j == 5 ? 11 :
9074                         i == Xsand_stoneout_2 && j == 6 ? 13 :
9075                         i == Xsand_stoneout_2 && j == 7 ? 15 :
9076                         i == Xboom_bug && j == 1 ? 2 :
9077                         i == Xboom_bug && j == 2 ? 2 :
9078                         i == Xboom_bug && j == 3 ? 4 :
9079                         i == Xboom_bug && j == 4 ? 4 :
9080                         i == Xboom_bug && j == 5 ? 2 :
9081                         i == Xboom_bug && j == 6 ? 2 :
9082                         i == Xboom_bug && j == 7 ? 0 :
9083                         i == Xboom_tank && j == 1 ? 2 :
9084                         i == Xboom_tank && j == 2 ? 2 :
9085                         i == Xboom_tank && j == 3 ? 4 :
9086                         i == Xboom_tank && j == 4 ? 4 :
9087                         i == Xboom_tank && j == 5 ? 2 :
9088                         i == Xboom_tank && j == 6 ? 2 :
9089                         i == Xboom_tank && j == 7 ? 0 :
9090                         i == Xboom_android && j == 7 ? 6 :
9091                         i == Xboom_1 && j == 1 ? 2 :
9092                         i == Xboom_1 && j == 2 ? 2 :
9093                         i == Xboom_1 && j == 3 ? 4 :
9094                         i == Xboom_1 && j == 4 ? 4 :
9095                         i == Xboom_1 && j == 5 ? 6 :
9096                         i == Xboom_1 && j == 6 ? 6 :
9097                         i == Xboom_1 && j == 7 ? 8 :
9098                         i == Xboom_2 && j == 0 ? 8 :
9099                         i == Xboom_2 && j == 1 ? 8 :
9100                         i == Xboom_2 && j == 2 ? 10 :
9101                         i == Xboom_2 && j == 3 ? 10 :
9102                         i == Xboom_2 && j == 4 ? 10 :
9103                         i == Xboom_2 && j == 5 ? 12 :
9104                         i == Xboom_2 && j == 6 ? 12 :
9105                         i == Xboom_2 && j == 7 ? 12 :
9106                         special_animation && j == 4 ? 3 :
9107                         effective_action != action ? 0 :
9108                         j);
9109       int frame = getAnimationFrame(g->anim_frames,
9110                                     g->anim_delay,
9111                                     g->anim_mode,
9112                                     g->anim_start_frame,
9113                                     sync_frame);
9114
9115       getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y,
9116                           g->double_movement && is_backside);
9117
9118       g_em->bitmap = src_bitmap;
9119       g_em->src_x = src_x;
9120       g_em->src_y = src_y;
9121       g_em->src_offset_x = 0;
9122       g_em->src_offset_y = 0;
9123       g_em->dst_offset_x = 0;
9124       g_em->dst_offset_y = 0;
9125       g_em->width  = TILEX;
9126       g_em->height = TILEY;
9127
9128       g_em->preserve_background = FALSE;
9129
9130       set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
9131                                sync_frame);
9132
9133       if ((!g->double_movement && (effective_action == ACTION_FALLING ||
9134                                    effective_action == ACTION_MOVING  ||
9135                                    effective_action == ACTION_PUSHING ||
9136                                    effective_action == ACTION_EATING)) ||
9137           (!has_action_graphics && (effective_action == ACTION_FILLING ||
9138                                     effective_action == ACTION_EMPTYING)))
9139       {
9140         int move_dir =
9141           (effective_action == ACTION_FALLING ||
9142            effective_action == ACTION_FILLING ||
9143            effective_action == ACTION_EMPTYING ? MV_DOWN : direction);
9144         int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? 1 : 0);
9145         int dy = (move_dir == MV_UP   ? -1 : move_dir == MV_DOWN  ? 1 : 0);
9146         int num_steps = (i == Ydrip_1_s  ? 16 :
9147                          i == Ydrip_1_sB ? 16 :
9148                          i == Ydrip_2_s  ? 16 :
9149                          i == Ydrip_2_sB ? 16 :
9150                          i == Xsand_stonein_1 ? 32 :
9151                          i == Xsand_stonein_2 ? 32 :
9152                          i == Xsand_stonein_3 ? 32 :
9153                          i == Xsand_stonein_4 ? 32 :
9154                          i == Xsand_stoneout_1 ? 16 :
9155                          i == Xsand_stoneout_2 ? 16 : 8);
9156         int cx = ABS(dx) * (TILEX / num_steps);
9157         int cy = ABS(dy) * (TILEY / num_steps);
9158         int step_frame = (i == Ydrip_2_s        ? j + 8 :
9159                           i == Ydrip_2_sB       ? j + 8 :
9160                           i == Xsand_stonein_2  ? j + 8 :
9161                           i == Xsand_stonein_3  ? j + 16 :
9162                           i == Xsand_stonein_4  ? j + 24 :
9163                           i == Xsand_stoneout_2 ? j + 8 : j) + 1;
9164         int step = (is_backside ? step_frame : num_steps - step_frame);
9165
9166         if (is_backside)        // tile where movement starts
9167         {
9168           if (dx < 0 || dy < 0)
9169           {
9170             g_em->src_offset_x = cx * step;
9171             g_em->src_offset_y = cy * step;
9172           }
9173           else
9174           {
9175             g_em->dst_offset_x = cx * step;
9176             g_em->dst_offset_y = cy * step;
9177           }
9178         }
9179         else                    // tile where movement ends
9180         {
9181           if (dx < 0 || dy < 0)
9182           {
9183             g_em->dst_offset_x = cx * step;
9184             g_em->dst_offset_y = cy * step;
9185           }
9186           else
9187           {
9188             g_em->src_offset_x = cx * step;
9189             g_em->src_offset_y = cy * step;
9190           }
9191         }
9192
9193         g_em->width  = TILEX - cx * step;
9194         g_em->height = TILEY - cy * step;
9195       }
9196
9197       // create unique graphic identifier to decide if tile must be redrawn
9198       /* bit 31 - 16 (16 bit): EM style graphic
9199          bit 15 - 12 ( 4 bit): EM style frame
9200          bit 11 -  6 ( 6 bit): graphic width
9201          bit  5 -  0 ( 6 bit): graphic height */
9202       g_em->unique_identifier =
9203         (graphic << 16) | (frame << 12) | (g_em->width << 6) | g_em->height;
9204     }
9205   }
9206
9207   for (i = 0; i < GAME_TILE_MAX; i++)
9208   {
9209     for (j = 0; j < 8; j++)
9210     {
9211       int element = object_mapping[i].element_rnd;
9212       int action = object_mapping[i].action;
9213       int direction = object_mapping[i].direction;
9214       boolean is_backside = object_mapping[i].is_backside;
9215       int graphic_action  = el_act_dir2img(element, action, direction);
9216       int graphic_default = el_act_dir2img(element, ACTION_DEFAULT, direction);
9217
9218       if ((action == ACTION_SMASHED_BY_ROCK ||
9219            action == ACTION_SMASHED_BY_SPRING ||
9220            action == ACTION_EATING) &&
9221           graphic_action == graphic_default)
9222       {
9223         int e = (action == ACTION_SMASHED_BY_ROCK   ? Ystone_s  :
9224                  action == ACTION_SMASHED_BY_SPRING ? Yspring_s :
9225                  direction == MV_LEFT  ? (is_backside? Yspring_wB: Yspring_w) :
9226                  direction == MV_RIGHT ? (is_backside? Yspring_eB: Yspring_e) :
9227                  Xspring);
9228
9229         // no separate animation for "smashed by rock" -- use rock instead
9230         struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
9231         struct GraphicInfo_EM *g_xx = &graphic_info_em_object[e][j];
9232
9233         g_em->bitmap            = g_xx->bitmap;
9234         g_em->src_x             = g_xx->src_x;
9235         g_em->src_y             = g_xx->src_y;
9236         g_em->src_offset_x      = g_xx->src_offset_x;
9237         g_em->src_offset_y      = g_xx->src_offset_y;
9238         g_em->dst_offset_x      = g_xx->dst_offset_x;
9239         g_em->dst_offset_y      = g_xx->dst_offset_y;
9240         g_em->width             = g_xx->width;
9241         g_em->height            = g_xx->height;
9242         g_em->unique_identifier = g_xx->unique_identifier;
9243
9244         if (!is_backside)
9245           g_em->preserve_background = TRUE;
9246       }
9247     }
9248   }
9249
9250   for (p = 0; p < MAX_PLAYERS; p++)
9251   {
9252     for (i = 0; i < PLY_MAX; i++)
9253     {
9254       int element = player_mapping[p][i].element_rnd;
9255       int action = player_mapping[p][i].action;
9256       int direction = player_mapping[p][i].direction;
9257
9258       for (j = 0; j < 8; j++)
9259       {
9260         int effective_element = element;
9261         int effective_action = action;
9262         int graphic = (direction == MV_NONE ?
9263                        el_act2img(effective_element, effective_action) :
9264                        el_act_dir2img(effective_element, effective_action,
9265                                       direction));
9266         struct GraphicInfo *g = &graphic_info[graphic];
9267         struct GraphicInfo_EM *g_em = &graphic_info_em_player[p][i][j];
9268         Bitmap *src_bitmap;
9269         int src_x, src_y;
9270         int sync_frame = j;
9271         int frame = getAnimationFrame(g->anim_frames,
9272                                       g->anim_delay,
9273                                       g->anim_mode,
9274                                       g->anim_start_frame,
9275                                       sync_frame);
9276
9277         getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
9278
9279         g_em->bitmap = src_bitmap;
9280         g_em->src_x = src_x;
9281         g_em->src_y = src_y;
9282         g_em->src_offset_x = 0;
9283         g_em->src_offset_y = 0;
9284         g_em->dst_offset_x = 0;
9285         g_em->dst_offset_y = 0;
9286         g_em->width  = TILEX;
9287         g_em->height = TILEY;
9288       }
9289     }
9290   }
9291 }
9292
9293 static void CheckSaveEngineSnapshot_EM(int frame,
9294                                        boolean any_player_moving,
9295                                        boolean any_player_snapping,
9296                                        boolean any_player_dropping)
9297 {
9298   if (frame == 7 && !any_player_dropping)
9299   {
9300     if (!local_player->was_waiting)
9301     {
9302       if (!CheckSaveEngineSnapshotToList())
9303         return;
9304
9305       local_player->was_waiting = TRUE;
9306     }
9307   }
9308   else if (any_player_moving || any_player_snapping || any_player_dropping)
9309   {
9310     local_player->was_waiting = FALSE;
9311   }
9312 }
9313
9314 static void CheckSaveEngineSnapshot_SP(boolean murphy_is_waiting,
9315                                        boolean murphy_is_dropping)
9316 {
9317   if (murphy_is_waiting)
9318   {
9319     if (!local_player->was_waiting)
9320     {
9321       if (!CheckSaveEngineSnapshotToList())
9322         return;
9323
9324       local_player->was_waiting = TRUE;
9325     }
9326   }
9327   else
9328   {
9329     local_player->was_waiting = FALSE;
9330   }
9331 }
9332
9333 static void CheckSaveEngineSnapshot_MM(boolean element_clicked,
9334                                        boolean button_released)
9335 {
9336   if (button_released)
9337   {
9338     if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE)
9339       CheckSaveEngineSnapshotToList();
9340   }
9341   else if (element_clicked)
9342   {
9343     if (game.snapshot.mode != SNAPSHOT_MODE_EVERY_MOVE)
9344       CheckSaveEngineSnapshotToList();
9345
9346     game.snapshot.changed_action = TRUE;
9347   }
9348 }
9349
9350 boolean CheckSingleStepMode_EM(int frame,
9351                                boolean any_player_moving,
9352                                boolean any_player_snapping,
9353                                boolean any_player_dropping)
9354 {
9355   if (tape.single_step && tape.recording && !tape.pausing)
9356     if (frame == 7 && !any_player_dropping && FrameCounter > 6)
9357       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9358
9359   CheckSaveEngineSnapshot_EM(frame, any_player_moving,
9360                              any_player_snapping, any_player_dropping);
9361
9362   return tape.pausing;
9363 }
9364
9365 void CheckSingleStepMode_SP(boolean murphy_is_waiting,
9366                             boolean murphy_is_dropping)
9367 {
9368   boolean murphy_starts_dropping = FALSE;
9369   int i;
9370
9371   for (i = 0; i < MAX_PLAYERS; i++)
9372     if (stored_player[i].force_dropping)
9373       murphy_starts_dropping = TRUE;
9374
9375   if (tape.single_step && tape.recording && !tape.pausing)
9376     if (murphy_is_waiting && !murphy_starts_dropping)
9377       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9378
9379   CheckSaveEngineSnapshot_SP(murphy_is_waiting, murphy_is_dropping);
9380 }
9381
9382 void CheckSingleStepMode_MM(boolean element_clicked,
9383                             boolean button_released)
9384 {
9385   if (tape.single_step && tape.recording && !tape.pausing)
9386     if (button_released)
9387       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9388
9389   CheckSaveEngineSnapshot_MM(element_clicked, button_released);
9390 }
9391
9392 void getGraphicSource_SP(struct GraphicInfo_SP *g_sp,
9393                          int graphic, int sync_frame)
9394 {
9395   int frame = getGraphicAnimationFrame(graphic, sync_frame);
9396
9397   getGraphicSource(graphic, frame, &g_sp->bitmap, &g_sp->src_x, &g_sp->src_y);
9398 }
9399
9400 boolean isNextAnimationFrame_SP(int graphic, int sync_frame)
9401 {
9402   return (IS_NEXT_FRAME(sync_frame, graphic));
9403 }
9404
9405 int getGraphicInfo_Delay(int graphic)
9406 {
9407   return graphic_info[graphic].anim_delay;
9408 }
9409
9410 boolean getGraphicInfo_NewFrame(int x, int y, int graphic)
9411 {
9412   if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
9413     return FALSE;
9414
9415   if (ANIM_MODE(graphic) & (ANIM_TILED | ANIM_RANDOM_STATIC))
9416     return FALSE;
9417
9418   return TRUE;
9419 }
9420
9421 void PlayMenuSoundExt(int sound)
9422 {
9423   if (sound == SND_UNDEFINED)
9424     return;
9425
9426   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9427       (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9428     return;
9429
9430   if (IS_LOOP_SOUND(sound))
9431     PlaySoundLoop(sound);
9432   else
9433     PlaySound(sound);
9434 }
9435
9436 void PlayMenuSound(void)
9437 {
9438   PlayMenuSoundExt(menu.sound[game_status]);
9439 }
9440
9441 void PlayMenuSoundStereo(int sound, int stereo_position)
9442 {
9443   if (sound == SND_UNDEFINED)
9444     return;
9445
9446   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9447       (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9448     return;
9449
9450   if (IS_LOOP_SOUND(sound))
9451     PlaySoundExt(sound, SOUND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_LOOP);
9452   else
9453     PlaySoundStereo(sound, stereo_position);
9454 }
9455
9456 void PlayMenuSoundIfLoopExt(int sound)
9457 {
9458   if (sound == SND_UNDEFINED)
9459     return;
9460
9461   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9462       (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9463     return;
9464
9465   if (IS_LOOP_SOUND(sound))
9466     PlaySoundLoop(sound);
9467 }
9468
9469 void PlayMenuSoundIfLoop(void)
9470 {
9471   PlayMenuSoundIfLoopExt(menu.sound[game_status]);
9472 }
9473
9474 void PlayMenuMusicExt(int music)
9475 {
9476   if (music == MUS_UNDEFINED)
9477     return;
9478
9479   if (!setup.sound_music)
9480     return;
9481
9482   if (IS_LOOP_MUSIC(music))
9483     PlayMusicLoop(music);
9484   else
9485     PlayMusic(music);
9486 }
9487
9488 void PlayMenuMusic(void)
9489 {
9490   char *curr_music = getCurrentlyPlayingMusicFilename();
9491   char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
9492
9493   if (!strEqual(curr_music, next_music))
9494     PlayMenuMusicExt(menu.music[game_status]);
9495 }
9496
9497 void PlayMenuSoundsAndMusic(void)
9498 {
9499   PlayMenuSound();
9500   PlayMenuMusic();
9501 }
9502
9503 static void FadeMenuSounds(void)
9504 {
9505   FadeSounds();
9506 }
9507
9508 static void FadeMenuMusic(void)
9509 {
9510   char *curr_music = getCurrentlyPlayingMusicFilename();
9511   char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
9512
9513   if (!strEqual(curr_music, next_music))
9514     FadeMusic();
9515 }
9516
9517 void FadeMenuSoundsAndMusic(void)
9518 {
9519   FadeMenuSounds();
9520   FadeMenuMusic();
9521 }
9522
9523 void PlaySoundActivating(void)
9524 {
9525 #if 0
9526   PlaySound(SND_MENU_ITEM_ACTIVATING);
9527 #endif
9528 }
9529
9530 void PlaySoundSelecting(void)
9531 {
9532 #if 0
9533   PlaySound(SND_MENU_ITEM_SELECTING);
9534 #endif
9535 }
9536
9537 void ToggleFullscreenIfNeeded(void)
9538 {
9539   // if setup and video fullscreen state are already matching, nothing do do
9540   if (setup.fullscreen == video.fullscreen_enabled ||
9541       !video.fullscreen_available)
9542     return;
9543
9544   SDLSetWindowFullscreen(setup.fullscreen);
9545
9546   // set setup value according to successfully changed fullscreen mode
9547   setup.fullscreen = video.fullscreen_enabled;
9548 }
9549
9550 void ChangeWindowScalingIfNeeded(void)
9551 {
9552   // if setup and video window scaling are already matching, nothing do do
9553   if (setup.window_scaling_percent == video.window_scaling_percent ||
9554       video.fullscreen_enabled)
9555     return;
9556
9557   SDLSetWindowScaling(setup.window_scaling_percent);
9558
9559   // set setup value according to successfully changed window scaling
9560   setup.window_scaling_percent = video.window_scaling_percent;
9561 }
9562
9563 void ChangeVsyncModeIfNeeded(void)
9564 {
9565   int setup_vsync_mode = VSYNC_MODE_STR_TO_INT(setup.vsync_mode);
9566   int video_vsync_mode = video.vsync_mode;
9567
9568   // if setup and video vsync mode are already matching, nothing do do
9569   if (setup_vsync_mode == video_vsync_mode)
9570     return;
9571
9572   // if renderer is using OpenGL, vsync mode can directly be changed
9573   SDLSetScreenVsyncMode(setup.vsync_mode);
9574
9575   // if vsync mode unchanged, try re-creating renderer to set vsync mode
9576   if (video.vsync_mode == video_vsync_mode)
9577   {
9578     Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
9579
9580     // save backbuffer content which gets lost when re-creating screen
9581     BlitBitmap(backbuffer, tmp_backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9582
9583     // force re-creating screen and renderer to set new vsync mode
9584     video.fullscreen_enabled = !setup.fullscreen;
9585
9586     // when creating new renderer, destroy textures linked to old renderer
9587     FreeAllImageTextures();     // needs old renderer to free the textures
9588
9589     // re-create screen and renderer (including change of vsync mode)
9590     ChangeVideoModeIfNeeded(setup.fullscreen);
9591
9592     // set setup value according to successfully changed fullscreen mode
9593     setup.fullscreen = video.fullscreen_enabled;
9594
9595     // restore backbuffer content from temporary backbuffer backup bitmap
9596     BlitBitmap(tmp_backbuffer, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9597     FreeBitmap(tmp_backbuffer);
9598
9599     // update visible window/screen
9600     BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9601
9602     // when changing vsync mode, re-create textures for new renderer
9603     InitImageTextures();
9604   }
9605
9606   // set setup value according to successfully changed vsync mode
9607   setup.vsync_mode = VSYNC_MODE_INT_TO_STR(video.vsync_mode);
9608 }
9609
9610 static void JoinRectangles(int *x, int *y, int *width, int *height,
9611                            int x2, int y2, int width2, int height2)
9612 {
9613   // do not join with "off-screen" rectangle
9614   if (x2 == -1 || y2 == -1)
9615     return;
9616
9617   *x = MIN(*x, x2);
9618   *y = MIN(*y, y2);
9619   *width = MAX(*width, width2);
9620   *height = MAX(*height, height2);
9621 }
9622
9623 void SetAnimStatus(int anim_status_new)
9624 {
9625   if (anim_status_new == GAME_MODE_MAIN)
9626     anim_status_new = GAME_MODE_PSEUDO_MAINONLY;
9627   else if (anim_status_new == GAME_MODE_NAMES)
9628     anim_status_new = GAME_MODE_PSEUDO_NAMESONLY;
9629   else if (anim_status_new == GAME_MODE_SCORES)
9630     anim_status_new = GAME_MODE_PSEUDO_SCORESOLD;
9631
9632   global.anim_status_next = anim_status_new;
9633
9634   // directly set screen modes that are entered without fading
9635   if ((global.anim_status      == GAME_MODE_PSEUDO_MAINONLY &&
9636        global.anim_status_next == GAME_MODE_PSEUDO_TYPENAME) ||
9637       (global.anim_status      == GAME_MODE_PSEUDO_TYPENAME &&
9638        global.anim_status_next == GAME_MODE_PSEUDO_MAINONLY) ||
9639       (global.anim_status      == GAME_MODE_PSEUDO_NAMESONLY &&
9640        global.anim_status_next == GAME_MODE_PSEUDO_TYPENAMES) ||
9641       (global.anim_status      == GAME_MODE_PSEUDO_TYPENAMES &&
9642        global.anim_status_next == GAME_MODE_PSEUDO_NAMESONLY))
9643     global.anim_status = global.anim_status_next;
9644 }
9645
9646 void SetGameStatus(int game_status_new)
9647 {
9648   if (game_status_new != game_status)
9649     game_status_last_screen = game_status;
9650
9651   game_status = game_status_new;
9652
9653   SetAnimStatus(game_status_new);
9654 }
9655
9656 void SetFontStatus(int game_status_new)
9657 {
9658   static int last_game_status = -1;
9659
9660   if (game_status_new != -1)
9661   {
9662     // set game status for font use after storing last game status
9663     last_game_status = game_status;
9664     game_status = game_status_new;
9665   }
9666   else
9667   {
9668     // reset game status after font use from last stored game status
9669     game_status = last_game_status;
9670   }
9671 }
9672
9673 void ResetFontStatus(void)
9674 {
9675   SetFontStatus(-1);
9676 }
9677
9678 void SetLevelSetInfo(char *identifier, int level_nr)
9679 {
9680   setString(&levelset.identifier, identifier);
9681
9682   levelset.level_nr = level_nr;
9683 }
9684
9685 boolean CheckIfAllViewportsHaveChanged(void)
9686 {
9687   // if game status has not changed, viewports have not changed either
9688   if (game_status == game_status_last)
9689     return FALSE;
9690
9691   // check if all viewports have changed with current game status
9692
9693   struct RectWithBorder *vp_playfield = &viewport.playfield[game_status];
9694   struct RectWithBorder *vp_door_1    = &viewport.door_1[game_status];
9695   struct RectWithBorder *vp_door_2    = &viewport.door_2[game_status];
9696   int new_real_sx       = vp_playfield->x;
9697   int new_real_sy       = vp_playfield->y;
9698   int new_full_sxsize   = vp_playfield->width;
9699   int new_full_sysize   = vp_playfield->height;
9700   int new_dx            = vp_door_1->x;
9701   int new_dy            = vp_door_1->y;
9702   int new_dxsize        = vp_door_1->width;
9703   int new_dysize        = vp_door_1->height;
9704   int new_vx            = vp_door_2->x;
9705   int new_vy            = vp_door_2->y;
9706   int new_vxsize        = vp_door_2->width;
9707   int new_vysize        = vp_door_2->height;
9708
9709   boolean playfield_viewport_has_changed =
9710     (new_real_sx != REAL_SX ||
9711      new_real_sy != REAL_SY ||
9712      new_full_sxsize != FULL_SXSIZE ||
9713      new_full_sysize != FULL_SYSIZE);
9714
9715   boolean door_1_viewport_has_changed =
9716     (new_dx != DX ||
9717      new_dy != DY ||
9718      new_dxsize != DXSIZE ||
9719      new_dysize != DYSIZE);
9720
9721   boolean door_2_viewport_has_changed =
9722     (new_vx != VX ||
9723      new_vy != VY ||
9724      new_vxsize != VXSIZE ||
9725      new_vysize != VYSIZE ||
9726      game_status_last == GAME_MODE_EDITOR);
9727
9728   return (playfield_viewport_has_changed &&
9729           door_1_viewport_has_changed &&
9730           door_2_viewport_has_changed);
9731 }
9732
9733 boolean CheckFadeAll(void)
9734 {
9735   return (CheckIfGlobalBorderHasChanged() ||
9736           CheckIfAllViewportsHaveChanged());
9737 }
9738
9739 void ChangeViewportPropertiesIfNeeded(void)
9740 {
9741   boolean use_mini_tilesize = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
9742                                FALSE : setup.small_game_graphics);
9743   int gfx_game_mode = getGlobalGameStatus(game_status);
9744   int gfx_game_mode2 = (gfx_game_mode == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
9745                         gfx_game_mode);
9746   struct RectWithBorder *vp_window    = &viewport.window[gfx_game_mode];
9747   struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
9748   struct RectWithBorder *vp_door_1    = &viewport.door_1[gfx_game_mode];
9749   struct RectWithBorder *vp_door_2    = &viewport.door_2[gfx_game_mode2];
9750   struct RectWithBorder *vp_door_3    = &viewport.door_2[GAME_MODE_EDITOR];
9751   int new_win_xsize     = vp_window->width;
9752   int new_win_ysize     = vp_window->height;
9753   int border_left       = vp_playfield->border_left;
9754   int border_right      = vp_playfield->border_right;
9755   int border_top        = vp_playfield->border_top;
9756   int border_bottom     = vp_playfield->border_bottom;
9757   int new_sx            = vp_playfield->x      + border_left;
9758   int new_sy            = vp_playfield->y      + border_top;
9759   int new_sxsize        = vp_playfield->width  - border_left - border_right;
9760   int new_sysize        = vp_playfield->height - border_top  - border_bottom;
9761   int new_real_sx       = vp_playfield->x;
9762   int new_real_sy       = vp_playfield->y;
9763   int new_full_sxsize   = vp_playfield->width;
9764   int new_full_sysize   = vp_playfield->height;
9765   int new_dx            = vp_door_1->x;
9766   int new_dy            = vp_door_1->y;
9767   int new_dxsize        = vp_door_1->width;
9768   int new_dysize        = vp_door_1->height;
9769   int new_vx            = vp_door_2->x;
9770   int new_vy            = vp_door_2->y;
9771   int new_vxsize        = vp_door_2->width;
9772   int new_vysize        = vp_door_2->height;
9773   int new_ex            = vp_door_3->x;
9774   int new_ey            = vp_door_3->y;
9775   int new_exsize        = vp_door_3->width;
9776   int new_eysize        = vp_door_3->height;
9777   int new_tilesize_var = (use_mini_tilesize ? MINI_TILESIZE : game.tile_size);
9778   int tilesize = (gfx_game_mode == GAME_MODE_PLAYING ? new_tilesize_var :
9779                   gfx_game_mode == GAME_MODE_EDITOR ? MINI_TILESIZE : TILESIZE);
9780   int new_scr_fieldx = new_sxsize / tilesize;
9781   int new_scr_fieldy = new_sysize / tilesize;
9782   int new_scr_fieldx_buffers = new_sxsize / new_tilesize_var;
9783   int new_scr_fieldy_buffers = new_sysize / new_tilesize_var;
9784   boolean init_gfx_buffers = FALSE;
9785   boolean init_video_buffer = FALSE;
9786   boolean init_gadgets_and_anims = FALSE;
9787   boolean init_em_graphics = FALSE;
9788
9789   if (new_win_xsize != WIN_XSIZE ||
9790       new_win_ysize != WIN_YSIZE)
9791   {
9792     WIN_XSIZE = new_win_xsize;
9793     WIN_YSIZE = new_win_ysize;
9794
9795     init_video_buffer = TRUE;
9796     init_gfx_buffers = TRUE;
9797     init_gadgets_and_anims = TRUE;
9798
9799     // Debug("tools:viewport", "video: init_video_buffer, init_gfx_buffers");
9800   }
9801
9802   if (new_scr_fieldx != SCR_FIELDX ||
9803       new_scr_fieldy != SCR_FIELDY)
9804   {
9805     // this always toggles between MAIN and GAME when using small tile size
9806
9807     SCR_FIELDX = new_scr_fieldx;
9808     SCR_FIELDY = new_scr_fieldy;
9809
9810     // Debug("tools:viewport", "new_scr_fieldx != SCR_FIELDX ...");
9811   }
9812
9813   if (new_sx != SX ||
9814       new_sy != SY ||
9815       new_dx != DX ||
9816       new_dy != DY ||
9817       new_vx != VX ||
9818       new_vy != VY ||
9819       new_ex != EX ||
9820       new_ey != EY ||
9821       new_sxsize != SXSIZE ||
9822       new_sysize != SYSIZE ||
9823       new_dxsize != DXSIZE ||
9824       new_dysize != DYSIZE ||
9825       new_vxsize != VXSIZE ||
9826       new_vysize != VYSIZE ||
9827       new_exsize != EXSIZE ||
9828       new_eysize != EYSIZE ||
9829       new_real_sx != REAL_SX ||
9830       new_real_sy != REAL_SY ||
9831       new_full_sxsize != FULL_SXSIZE ||
9832       new_full_sysize != FULL_SYSIZE ||
9833       new_tilesize_var != TILESIZE_VAR
9834       )
9835   {
9836     // ------------------------------------------------------------------------
9837     // determine next fading area for changed viewport definitions
9838     // ------------------------------------------------------------------------
9839
9840     // start with current playfield area (default fading area)
9841     FADE_SX = REAL_SX;
9842     FADE_SY = REAL_SY;
9843     FADE_SXSIZE = FULL_SXSIZE;
9844     FADE_SYSIZE = FULL_SYSIZE;
9845
9846     // add new playfield area if position or size has changed
9847     if (new_real_sx != REAL_SX || new_real_sy != REAL_SY ||
9848         new_full_sxsize != FULL_SXSIZE || new_full_sysize != FULL_SYSIZE)
9849     {
9850       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9851                      new_real_sx, new_real_sy, new_full_sxsize,new_full_sysize);
9852     }
9853
9854     // add current and new door 1 area if position or size has changed
9855     if (new_dx != DX || new_dy != DY ||
9856         new_dxsize != DXSIZE || new_dysize != DYSIZE)
9857     {
9858       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9859                      DX, DY, DXSIZE, DYSIZE);
9860       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9861                      new_dx, new_dy, new_dxsize, new_dysize);
9862     }
9863
9864     // add current and new door 2 area if position or size has changed
9865     if (new_vx != VX || new_vy != VY ||
9866         new_vxsize != VXSIZE || new_vysize != VYSIZE)
9867     {
9868       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9869                      VX, VY, VXSIZE, VYSIZE);
9870       JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9871                      new_vx, new_vy, new_vxsize, new_vysize);
9872     }
9873
9874     // ------------------------------------------------------------------------
9875     // handle changed tile size
9876     // ------------------------------------------------------------------------
9877
9878     if (new_tilesize_var != TILESIZE_VAR)
9879     {
9880       // Debug("tools:viewport", "new_tilesize_var != TILESIZE_VAR");
9881
9882       // changing tile size invalidates scroll values of engine snapshots
9883       FreeEngineSnapshotSingle();
9884
9885       // changing tile size requires update of graphic mapping for EM engine
9886       init_em_graphics = TRUE;
9887     }
9888
9889     SX = new_sx;
9890     SY = new_sy;
9891     DX = new_dx;
9892     DY = new_dy;
9893     VX = new_vx;
9894     VY = new_vy;
9895     EX = new_ex;
9896     EY = new_ey;
9897     SXSIZE = new_sxsize;
9898     SYSIZE = new_sysize;
9899     DXSIZE = new_dxsize;
9900     DYSIZE = new_dysize;
9901     VXSIZE = new_vxsize;
9902     VYSIZE = new_vysize;
9903     EXSIZE = new_exsize;
9904     EYSIZE = new_eysize;
9905     REAL_SX = new_real_sx;
9906     REAL_SY = new_real_sy;
9907     FULL_SXSIZE = new_full_sxsize;
9908     FULL_SYSIZE = new_full_sysize;
9909     TILESIZE_VAR = new_tilesize_var;
9910
9911     init_gfx_buffers = TRUE;
9912     init_gadgets_and_anims = TRUE;
9913
9914     // Debug("tools:viewport", "viewports: init_gfx_buffers");
9915     // Debug("tools:viewport", "viewports: init_gadgets_and_anims");
9916   }
9917
9918   if (init_gfx_buffers)
9919   {
9920     // Debug("tools:viewport", "init_gfx_buffers");
9921
9922     SCR_FIELDX = new_scr_fieldx_buffers;
9923     SCR_FIELDY = new_scr_fieldy_buffers;
9924
9925     InitGfxBuffers();
9926
9927     SCR_FIELDX = new_scr_fieldx;
9928     SCR_FIELDY = new_scr_fieldy;
9929
9930     SetDrawDeactivationMask(REDRAW_NONE);
9931     SetDrawBackgroundMask(REDRAW_FIELD);
9932   }
9933
9934   if (init_video_buffer)
9935   {
9936     // Debug("tools:viewport", "init_video_buffer");
9937
9938     FreeAllImageTextures();     // needs old renderer to free the textures
9939
9940     InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen);
9941     InitImageTextures();
9942   }
9943
9944   if (init_gadgets_and_anims)
9945   {
9946     // Debug("tools:viewport", "init_gadgets_and_anims");
9947
9948     InitGadgets();
9949     InitGlobalAnimations();
9950   }
9951
9952   if (init_em_graphics)
9953   {
9954     InitGraphicInfo_EM();
9955   }
9956 }
9957
9958 void OpenURL(char *url)
9959 {
9960 #if SDL_VERSION_ATLEAST(2,0,14)
9961   SDL_OpenURL(url);
9962 #else
9963   Warn("SDL_OpenURL(\"%s\") not supported by SDL %d.%d.%d!",
9964        url, SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
9965   Warn("Please upgrade to at least SDL 2.0.14 for URL support!");
9966 #endif
9967 }
9968
9969 void OpenURLFromHash(SetupFileHash *hash, int hash_key)
9970 {
9971   OpenURL(getHashEntry(hash, int2str(hash_key, 0)));
9972 }
9973
9974
9975 // ============================================================================
9976 // tests
9977 // ============================================================================
9978
9979 #if defined(PLATFORM_WINDOWS)
9980 /* FILETIME of Jan 1 1970 00:00:00. */
9981 static const unsigned __int64 epoch = ((unsigned __int64) 116444736000000000ULL);
9982
9983 /*
9984  * timezone information is stored outside the kernel so tzp isn't used anymore.
9985  *
9986  * Note: this function is not for Win32 high precision timing purpose. See
9987  * elapsed_time().
9988  */
9989 static int gettimeofday_windows(struct timeval * tp, struct timezone * tzp)
9990 {
9991   FILETIME    file_time;
9992   SYSTEMTIME  system_time;
9993   ULARGE_INTEGER ularge;
9994
9995   GetSystemTime(&system_time);
9996   SystemTimeToFileTime(&system_time, &file_time);
9997   ularge.LowPart = file_time.dwLowDateTime;
9998   ularge.HighPart = file_time.dwHighDateTime;
9999
10000   tp->tv_sec = (long) ((ularge.QuadPart - epoch) / 10000000L);
10001   tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
10002
10003   return 0;
10004 }
10005 #endif
10006
10007 static char *test_init_uuid_random_function_simple(void)
10008 {
10009   static char seed_text[100];
10010   unsigned int seed = InitSimpleRandom(NEW_RANDOMIZE);
10011
10012   sprintf(seed_text, "%d", seed);
10013
10014   return seed_text;
10015 }
10016
10017 static char *test_init_uuid_random_function_better(void)
10018 {
10019   static char seed_text[100];
10020   struct timeval current_time;
10021
10022   gettimeofday(&current_time, NULL);
10023
10024   prng_seed_bytes(&current_time, sizeof(current_time));
10025
10026   sprintf(seed_text, "%ld.%ld",
10027           (long)current_time.tv_sec,
10028           (long)current_time.tv_usec);
10029
10030   return seed_text;
10031 }
10032
10033 #if defined(PLATFORM_WINDOWS)
10034 static char *test_init_uuid_random_function_better_windows(void)
10035 {
10036   static char seed_text[100];
10037   struct timeval current_time;
10038
10039   gettimeofday_windows(&current_time, NULL);
10040
10041   prng_seed_bytes(&current_time, sizeof(current_time));
10042
10043   sprintf(seed_text, "%ld.%ld",
10044           (long)current_time.tv_sec,
10045           (long)current_time.tv_usec);
10046
10047   return seed_text;
10048 }
10049 #endif
10050
10051 static unsigned int test_uuid_random_function_simple(int max)
10052 {
10053   return GetSimpleRandom(max);
10054 }
10055
10056 static unsigned int test_uuid_random_function_better(int max)
10057 {
10058   return (max > 0 ? prng_get_uint() % max : 0);
10059 }
10060
10061 #if defined(PLATFORM_WINDOWS)
10062 #define NUM_UUID_TESTS                  3
10063 #else
10064 #define NUM_UUID_TESTS                  2
10065 #endif
10066
10067 static void TestGeneratingUUIDs_RunTest(int nr, int always_seed, int num_uuids)
10068 {
10069   struct hashtable *hash_seeds =
10070     create_hashtable(16, 0.75, get_hash_from_key, hash_keys_are_equal);
10071   struct hashtable *hash_uuids =
10072     create_hashtable(16, 0.75, get_hash_from_key, hash_keys_are_equal);
10073   static char message[100];
10074   int i;
10075
10076   char *random_name = (nr == 0 ? "simple" : "better");
10077   char *random_type = (always_seed ? "always" : "only once");
10078   char *(*init_random_function)(void) =
10079     (nr == 0 ?
10080      test_init_uuid_random_function_simple :
10081      test_init_uuid_random_function_better);
10082   unsigned int (*random_function)(int) =
10083     (nr == 0 ?
10084      test_uuid_random_function_simple :
10085      test_uuid_random_function_better);
10086   int xpos = 40;
10087
10088 #if defined(PLATFORM_WINDOWS)
10089   if (nr == 2)
10090   {
10091     random_name = "windows";
10092     init_random_function = test_init_uuid_random_function_better_windows;
10093   }
10094 #endif
10095
10096   ClearField();
10097
10098   DrawTextF(xpos, 40, FC_GREEN, "Test: Generating UUIDs");
10099   DrawTextF(xpos, 80, FC_YELLOW, "Test %d.%d:", nr + 1, always_seed + 1);
10100
10101   DrawTextF(xpos, 100, FC_YELLOW, "Random Generator Name: %s", random_name);
10102   DrawTextF(xpos, 120, FC_YELLOW, "Seeding Random Generator: %s", random_type);
10103   DrawTextF(xpos, 140, FC_YELLOW, "Number of UUIDs generated: %d", num_uuids);
10104
10105   DrawTextF(xpos, 180, FC_GREEN, "Please wait ...");
10106
10107   BackToFront();
10108
10109   // always initialize random number generator at least once
10110   init_random_function();
10111
10112   unsigned int time_start = SDL_GetTicks();
10113
10114   for (i = 0; i < num_uuids; i++)
10115   {
10116     if (always_seed)
10117     {
10118       char *seed = getStringCopy(init_random_function());
10119
10120       hashtable_remove(hash_seeds, seed);
10121       hashtable_insert(hash_seeds, seed, "1");
10122     }
10123
10124     char *uuid = getStringCopy(getUUIDExt(random_function));
10125
10126     hashtable_remove(hash_uuids, uuid);
10127     hashtable_insert(hash_uuids, uuid, "1");
10128   }
10129
10130   int num_unique_seeds = hashtable_count(hash_seeds);
10131   int num_unique_uuids = hashtable_count(hash_uuids);
10132
10133   unsigned int time_needed = SDL_GetTicks() - time_start;
10134
10135   DrawTextF(xpos, 220, FC_YELLOW, "Time needed: %d ms", time_needed);
10136
10137   DrawTextF(xpos, 240, FC_YELLOW, "Number of unique UUIDs: %d", num_unique_uuids);
10138
10139   if (always_seed)
10140     DrawTextF(xpos, 260, FC_YELLOW, "Number of unique seeds: %d", num_unique_seeds);
10141
10142   if (nr == NUM_UUID_TESTS - 1 && always_seed)
10143     DrawTextF(xpos, 300, FC_GREEN, "All tests done!");
10144   else
10145     DrawTextF(xpos, 300, FC_GREEN, "Confirm dialog for next test ...");
10146
10147   sprintf(message, "Test %d.%d finished!", nr + 1, always_seed + 1);
10148
10149   Request(message, REQ_CONFIRM);
10150
10151   hashtable_destroy(hash_seeds, 0);
10152   hashtable_destroy(hash_uuids, 0);
10153 }
10154
10155 void TestGeneratingUUIDs(void)
10156 {
10157   int num_uuids = 1000000;
10158   int i, j;
10159
10160   for (i = 0; i < NUM_UUID_TESTS; i++)
10161     for (j = 0; j < 2; j++)
10162       TestGeneratingUUIDs_RunTest(i, j, num_uuids);
10163
10164   CloseAllAndExit(0);
10165 }