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