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