1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
14 #include "libgame/libgame.h"
26 #define DEBUG_FRAME_TIME FALSE
28 // tool button identifiers
29 #define TOOL_CTRL_ID_YES 0
30 #define TOOL_CTRL_ID_NO 1
31 #define TOOL_CTRL_ID_CONFIRM 2
32 #define TOOL_CTRL_ID_PLAYER_1 3
33 #define TOOL_CTRL_ID_PLAYER_2 4
34 #define TOOL_CTRL_ID_PLAYER_3 5
35 #define TOOL_CTRL_ID_PLAYER_4 6
36 #define TOOL_CTRL_ID_TOUCH_YES 7
37 #define TOOL_CTRL_ID_TOUCH_NO 8
38 #define TOOL_CTRL_ID_TOUCH_CONFIRM 9
40 #define NUM_TOOL_BUTTONS 10
42 // constants for number of doors and door parts
44 #define NUM_PANELS NUM_DOORS
45 // #define NUM_PANELS 0
46 #define MAX_PARTS_PER_DOOR 8
47 #define MAX_DOOR_PARTS (NUM_DOORS * MAX_PARTS_PER_DOOR + NUM_PANELS)
48 #define DOOR_PART_IS_PANEL(i) ((i) >= NUM_DOORS * MAX_PARTS_PER_DOOR)
51 struct DoorPartOrderInfo
57 static struct DoorPartOrderInfo door_part_order[MAX_DOOR_PARTS];
59 struct DoorPartControlInfo
63 struct DoorPartPosInfo *pos;
66 static struct DoorPartControlInfo door_part_controls[] =
70 IMG_GFX_DOOR_1_PART_1,
75 IMG_GFX_DOOR_1_PART_2,
80 IMG_GFX_DOOR_1_PART_3,
85 IMG_GFX_DOOR_1_PART_4,
90 IMG_GFX_DOOR_1_PART_5,
95 IMG_GFX_DOOR_1_PART_6,
100 IMG_GFX_DOOR_1_PART_7,
105 IMG_GFX_DOOR_1_PART_8,
111 IMG_GFX_DOOR_2_PART_1,
116 IMG_GFX_DOOR_2_PART_2,
121 IMG_GFX_DOOR_2_PART_3,
126 IMG_GFX_DOOR_2_PART_4,
131 IMG_GFX_DOOR_2_PART_5,
136 IMG_GFX_DOOR_2_PART_6,
141 IMG_GFX_DOOR_2_PART_7,
146 IMG_GFX_DOOR_2_PART_8,
152 IMG_BACKGROUND_PANEL,
168 static struct XY xy_topdown[] =
177 // forward declaration for internal use
178 static void UnmapToolButtons(void);
179 static void HandleToolButtons(struct GadgetInfo *);
180 static int el_act_dir2crm(int, int, int);
181 static int el_act2crm(int, int);
183 static struct GadgetInfo *tool_gadget[NUM_TOOL_BUTTONS];
184 static int request_gadget_id = -1;
186 static char *print_if_not_empty(int element)
188 static char *s = NULL;
189 char *token_name = element_info[element].token_name;
194 s = checked_malloc(strlen(token_name) + 10 + 1);
196 if (element != EL_EMPTY)
197 sprintf(s, "%d\t['%s']", element, token_name);
199 sprintf(s, "%d", element);
204 int getFieldbufferOffsetX_RND(int dir, int pos)
206 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
207 int dx = (dir & MV_HORIZONTAL ? pos : 0);
208 int dx_var = dx * TILESIZE_VAR / TILESIZE;
211 if (EVEN(SCR_FIELDX))
213 int sbx_right = SBX_Right + (BorderElement != EL_EMPTY ? 1 : 0);
214 int ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx_var;
216 if (ffx < sbx_right * TILEX_VAR + TILEX_VAR / 2)
217 fx += dx_var - MIN(ffx, TILEX_VAR / 2) + TILEX_VAR;
219 fx += (dx_var > 0 ? TILEX_VAR : 0);
226 if (full_lev_fieldx <= SCR_FIELDX)
228 if (EVEN(SCR_FIELDX))
229 fx = 2 * TILEX_VAR - (ODD(lev_fieldx) ? TILEX_VAR / 2 : 0);
231 fx = 2 * TILEX_VAR - (EVEN(lev_fieldx) ? TILEX_VAR / 2 : 0);
237 int getFieldbufferOffsetY_RND(int dir, int pos)
239 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
240 int dy = (dir & MV_VERTICAL ? pos : 0);
241 int dy_var = dy * TILESIZE_VAR / TILESIZE;
244 if (EVEN(SCR_FIELDY))
246 int sby_lower = SBY_Lower + (BorderElement != EL_EMPTY ? 1 : 0);
247 int ffy = (scroll_y - SBY_Upper) * TILEY_VAR + dy_var;
249 if (ffy < sby_lower * TILEY_VAR + TILEY_VAR / 2)
250 fy += dy_var - MIN(ffy, TILEY_VAR / 2) + TILEY_VAR;
252 fy += (dy_var > 0 ? TILEY_VAR : 0);
259 if (full_lev_fieldy <= SCR_FIELDY)
261 if (EVEN(SCR_FIELDY))
262 fy = 2 * TILEY_VAR - (ODD(lev_fieldy) ? TILEY_VAR / 2 : 0);
264 fy = 2 * TILEY_VAR - (EVEN(lev_fieldy) ? TILEY_VAR / 2 : 0);
270 static int getLevelFromScreenX_RND(int sx)
272 int fx = getFieldbufferOffsetX_RND(ScreenMovDir, ScreenGfxPos);
275 int lx = LEVELX((px + dx) / TILESIZE_VAR);
280 static int getLevelFromScreenY_RND(int sy)
282 int fy = getFieldbufferOffsetY_RND(ScreenMovDir, ScreenGfxPos);
285 int ly = LEVELY((py + dy) / TILESIZE_VAR);
290 static int getLevelFromScreenX_EM(int sx)
292 int level_xsize = level.native_em_level->cav->width;
293 int full_xsize = level_xsize * TILESIZE_VAR;
295 sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
297 int fx = getFieldbufferOffsetX_EM();
300 int lx = LEVELX((px + dx) / TILESIZE_VAR);
305 static int getLevelFromScreenY_EM(int sy)
307 int level_ysize = level.native_em_level->cav->height;
308 int full_ysize = level_ysize * TILESIZE_VAR;
310 sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
312 int fy = getFieldbufferOffsetY_EM();
315 int ly = LEVELY((py + dy) / TILESIZE_VAR);
320 static int getLevelFromScreenX_SP(int sx)
322 int menBorder = setup.sp_show_border_elements;
323 int level_xsize = level.native_sp_level->width;
324 int full_xsize = (level_xsize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
326 sx += (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
328 int fx = getFieldbufferOffsetX_SP();
331 int lx = LEVELX((px + dx) / TILESIZE_VAR);
336 static int getLevelFromScreenY_SP(int sy)
338 int menBorder = setup.sp_show_border_elements;
339 int level_ysize = level.native_sp_level->height;
340 int full_ysize = (level_ysize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
342 sy += (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
344 int fy = getFieldbufferOffsetY_SP();
347 int ly = LEVELY((py + dy) / TILESIZE_VAR);
352 static int getLevelFromScreenX_MM(int sx)
354 int level_xsize = level.native_mm_level->fieldx;
355 int full_xsize = level_xsize * TILESIZE_VAR;
357 sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
360 int lx = (px + TILESIZE_VAR) / TILESIZE_VAR - 1;
365 static int getLevelFromScreenY_MM(int sy)
367 int level_ysize = level.native_mm_level->fieldy;
368 int full_ysize = level_ysize * TILESIZE_VAR;
370 sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
373 int ly = (py + TILESIZE_VAR) / TILESIZE_VAR - 1;
378 int getLevelFromScreenX(int x)
380 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
381 return getLevelFromScreenX_EM(x);
382 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
383 return getLevelFromScreenX_SP(x);
384 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
385 return getLevelFromScreenX_MM(x);
387 return getLevelFromScreenX_RND(x);
390 int getLevelFromScreenY(int y)
392 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
393 return getLevelFromScreenY_EM(y);
394 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
395 return getLevelFromScreenY_SP(y);
396 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
397 return getLevelFromScreenY_MM(y);
399 return getLevelFromScreenY_RND(y);
402 int getScreenFieldSizeX(void)
404 return (tape.playing ? tape.scr_fieldx : SCR_FIELDX);
407 int getScreenFieldSizeY(void)
409 return (tape.playing ? tape.scr_fieldy : SCR_FIELDY);
412 void DumpTile(int x, int y)
419 Info("Field Info: SCREEN(%d, %d), LEVEL(%d, %d)", sx, sy, x, y);
422 if (!IN_LEV_FIELD(x, y))
424 Info("(not in level field)");
430 token_name = element_info[Tile[x][y]].token_name;
432 Info("Tile: %d\t['%s']", Tile[x][y], token_name);
433 Info("Back: %s", print_if_not_empty(Back[x][y]));
434 Info("Store: %s", print_if_not_empty(Store[x][y]));
435 Info("Store2: %s", print_if_not_empty(Store2[x][y]));
436 Info("StorePlayer: %s", print_if_not_empty(StorePlayer[x][y]));
437 Info("MovPos: %d", MovPos[x][y]);
438 Info("MovDir: %d", MovDir[x][y]);
439 Info("MovDelay: %d", MovDelay[x][y]);
440 Info("ChangeDelay: %d", ChangeDelay[x][y]);
441 Info("CustomValue: %d", CustomValue[x][y]);
442 Info("GfxElement: %d", GfxElement[x][y]);
443 Info("GfxAction: %d", GfxAction[x][y]);
444 Info("GfxFrame: %d [%d]", GfxFrame[x][y], FrameCounter);
445 Info("Player x/y: %d, %d", local_player->jx, local_player->jy);
449 void DumpTileFromScreen(int sx, int sy)
451 int lx = getLevelFromScreenX(sx);
452 int ly = getLevelFromScreenY(sy);
457 void SetDrawtoField(int mode)
459 if (mode == DRAW_TO_FIELDBUFFER)
465 BX2 = SCR_FIELDX + 1;
466 BY2 = SCR_FIELDY + 1;
468 drawto_field = fieldbuffer;
470 else // DRAW_TO_BACKBUFFER
476 BX2 = SCR_FIELDX - 1;
477 BY2 = SCR_FIELDY - 1;
479 drawto_field = backbuffer;
483 int GetDrawtoField(void)
485 return (drawto_field == fieldbuffer ? DRAW_TO_FIELDBUFFER : DRAW_TO_BACKBUFFER);
488 static void RedrawPlayfield_RND(void)
490 if (game.envelope_active)
493 DrawLevel(REDRAW_ALL);
497 void RedrawPlayfield(void)
499 if (game_status != GAME_MODE_PLAYING)
502 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
503 RedrawPlayfield_EM(TRUE);
504 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
505 RedrawPlayfield_SP(TRUE);
506 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
507 RedrawPlayfield_MM();
508 else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
509 RedrawPlayfield_RND();
511 BlitScreenToBitmap(backbuffer);
513 BlitBitmap(drawto, window, gfx.sx, gfx.sy, gfx.sxsize, gfx.sysize,
517 static void DrawMaskedBorderExt_Rect(int x, int y, int width, int height,
520 Bitmap *src_bitmap = getGlobalBorderBitmapFromStatus(global.border_status);
521 Bitmap *dst_bitmap = gfx.masked_border_bitmap_ptr;
523 // may happen for "border.draw_masked.*" with undefined "global.border.*"
524 if (src_bitmap == NULL)
527 if (x == -1 && y == -1)
530 if (draw_target == DRAW_TO_SCREEN)
531 BlitToScreenMasked(src_bitmap, x, y, width, height, x, y);
533 BlitBitmapMasked(src_bitmap, dst_bitmap, x, y, width, height, x, y);
536 static void DrawMaskedBorderExt_FIELD(int draw_target)
538 if (global.border_status >= GAME_MODE_MAIN &&
539 global.border_status <= GAME_MODE_PLAYING &&
540 border.draw_masked[global.border_status])
541 DrawMaskedBorderExt_Rect(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
545 static void DrawMaskedBorderExt_DOOR_1(int draw_target)
547 // when drawing to backbuffer, never draw border over open doors
548 if (draw_target == DRAW_TO_BACKBUFFER &&
549 (GetDoorState() & DOOR_OPEN_1))
552 if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
553 (global.border_status != GAME_MODE_EDITOR ||
554 border.draw_masked[GFX_SPECIAL_ARG_EDITOR]))
555 DrawMaskedBorderExt_Rect(DX, DY, DXSIZE, DYSIZE, draw_target);
558 static void DrawMaskedBorderExt_DOOR_2(int draw_target)
560 // when drawing to backbuffer, never draw border over open doors
561 if (draw_target == DRAW_TO_BACKBUFFER &&
562 (GetDoorState() & DOOR_OPEN_2))
565 if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
566 global.border_status != GAME_MODE_EDITOR)
567 DrawMaskedBorderExt_Rect(VX, VY, VXSIZE, VYSIZE, draw_target);
570 static void DrawMaskedBorderExt_DOOR_3(int draw_target)
572 // currently not available
575 static void DrawMaskedBorderExt_ALL(int draw_target)
577 DrawMaskedBorderExt_FIELD(draw_target);
578 DrawMaskedBorderExt_DOOR_1(draw_target);
579 DrawMaskedBorderExt_DOOR_2(draw_target);
580 DrawMaskedBorderExt_DOOR_3(draw_target);
583 static void DrawMaskedBorderExt(int redraw_mask, int draw_target)
585 // never draw masked screen borders on borderless screens
586 if (global.border_status == GAME_MODE_LOADING ||
587 global.border_status == GAME_MODE_TITLE)
590 if (redraw_mask & REDRAW_ALL)
591 DrawMaskedBorderExt_ALL(draw_target);
594 if (redraw_mask & REDRAW_FIELD)
595 DrawMaskedBorderExt_FIELD(draw_target);
596 if (redraw_mask & REDRAW_DOOR_1)
597 DrawMaskedBorderExt_DOOR_1(draw_target);
598 if (redraw_mask & REDRAW_DOOR_2)
599 DrawMaskedBorderExt_DOOR_2(draw_target);
600 if (redraw_mask & REDRAW_DOOR_3)
601 DrawMaskedBorderExt_DOOR_3(draw_target);
605 void DrawMaskedBorder_FIELD(void)
607 DrawMaskedBorderExt_FIELD(DRAW_TO_BACKBUFFER);
610 void DrawMaskedBorder(int redraw_mask)
612 DrawMaskedBorderExt(redraw_mask, DRAW_TO_BACKBUFFER);
615 void DrawMaskedBorderToTarget(int draw_target)
617 if (draw_target == DRAW_TO_BACKBUFFER ||
618 draw_target == DRAW_TO_SCREEN)
620 DrawMaskedBorderExt(REDRAW_ALL, draw_target);
624 int last_border_status = global.border_status;
626 if (draw_target == DRAW_TO_FADE_SOURCE)
628 global.border_status = gfx.fade_border_source_status;
629 gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_source;
631 else if (draw_target == DRAW_TO_FADE_TARGET)
633 global.border_status = gfx.fade_border_target_status;
634 gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_target;
637 DrawMaskedBorderExt(REDRAW_ALL, draw_target);
639 global.border_status = last_border_status;
640 gfx.masked_border_bitmap_ptr = backbuffer;
644 void DrawTileCursor(int draw_target)
646 DrawTileCursor_MM(draw_target, game_status == GAME_MODE_PLAYING);
649 void BlitScreenToBitmapExt_RND(Bitmap *target_bitmap, int fx, int fy)
651 BlitBitmap(drawto_field, target_bitmap, fx, fy, SXSIZE, SYSIZE, SX, SY);
654 void BlitScreenToBitmap_RND(Bitmap *target_bitmap)
656 int fx = getFieldbufferOffsetX_RND(ScreenMovDir, ScreenGfxPos);
657 int fy = getFieldbufferOffsetY_RND(ScreenMovDir, ScreenGfxPos);
659 BlitScreenToBitmapExt_RND(target_bitmap, fx, fy);
662 void BlitScreenToBitmap(Bitmap *target_bitmap)
664 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
665 BlitScreenToBitmap_EM(target_bitmap);
666 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
667 BlitScreenToBitmap_SP(target_bitmap);
668 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
669 BlitScreenToBitmap_MM(target_bitmap);
670 else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
671 BlitScreenToBitmap_RND(target_bitmap);
673 redraw_mask |= REDRAW_FIELD;
676 static void DrawFramesPerSecond(void)
679 int font_nr = FONT_TEXT_2;
680 int font_width = getFontWidth(font_nr);
681 int draw_deactivation_mask = GetDrawDeactivationMask();
682 boolean draw_masked = (draw_deactivation_mask == REDRAW_NONE);
684 // draw FPS with leading space (needed if field buffer deactivated)
685 sprintf(text, " %04.1f fps", global.frames_per_second);
687 // override draw deactivation mask (required for invisible warp mode)
688 SetDrawDeactivationMask(REDRAW_NONE);
690 // draw opaque FPS if field buffer deactivated, else draw masked FPS
691 DrawTextExt(backbuffer, SX + SXSIZE - font_width * strlen(text), SY, text,
692 font_nr, (draw_masked ? BLIT_MASKED : BLIT_OPAQUE));
694 // set draw deactivation mask to previous value
695 SetDrawDeactivationMask(draw_deactivation_mask);
697 // force full-screen redraw in this frame
698 redraw_mask = REDRAW_ALL;
702 static void PrintFrameTimeDebugging(void)
704 static unsigned int last_counter = 0;
705 unsigned int counter = Counter();
706 int diff_1 = counter - last_counter;
707 int diff_2 = diff_1 - GAME_FRAME_DELAY;
709 int diff_2_cut = MIN(ABS(diff_2), diff_2_max);
710 char diff_bar[2 * diff_2_max + 5];
714 diff_bar[pos++] = (diff_2 < -diff_2_max ? '<' : ' ');
716 for (i = 0; i < diff_2_max; i++)
717 diff_bar[pos++] = (diff_2 >= 0 ? ' ' :
718 i >= diff_2_max - diff_2_cut ? '-' : ' ');
720 diff_bar[pos++] = '|';
722 for (i = 0; i < diff_2_max; i++)
723 diff_bar[pos++] = (diff_2 <= 0 ? ' ' : i < diff_2_cut ? '+' : ' ');
725 diff_bar[pos++] = (diff_2 > diff_2_max ? '>' : ' ');
727 diff_bar[pos++] = '\0';
729 Debug("time:frame", "%06d [%02d] [%c%02d] %s",
732 (diff_2 < 0 ? '-' : diff_2 > 0 ? '+' : ' '), ABS(diff_2),
735 last_counter = counter;
739 static int unifiedRedrawMask(int mask)
741 if (mask & REDRAW_ALL)
744 if (mask & REDRAW_FIELD && mask & REDRAW_DOORS)
750 static boolean equalRedrawMasks(int mask_1, int mask_2)
752 return unifiedRedrawMask(mask_1) == unifiedRedrawMask(mask_2);
755 void BackToFront(void)
757 static int last_redraw_mask = REDRAW_NONE;
759 // force screen redraw in every frame to continue drawing global animations
760 // (but always use the last redraw mask to prevent unwanted side effects)
761 if (redraw_mask == REDRAW_NONE)
762 redraw_mask = last_redraw_mask;
764 last_redraw_mask = redraw_mask;
767 // masked border now drawn immediately when blitting backbuffer to window
769 // draw masked border to all viewports, if defined
770 DrawMaskedBorder(redraw_mask);
773 // draw frames per second (only if debug mode is enabled)
774 if (redraw_mask & REDRAW_FPS)
775 DrawFramesPerSecond();
777 // remove playfield redraw before potentially merging with doors redraw
778 if (DrawingDeactivated(REAL_SX, REAL_SY))
779 redraw_mask &= ~REDRAW_FIELD;
781 // redraw complete window if both playfield and (some) doors need redraw
782 if (redraw_mask & REDRAW_FIELD && redraw_mask & REDRAW_DOORS)
783 redraw_mask = REDRAW_ALL;
785 /* although redrawing the whole window would be fine for normal gameplay,
786 being able to only redraw the playfield is required for deactivating
787 certain drawing areas (mainly playfield) to work, which is needed for
788 warp-forward to be fast enough (by skipping redraw of most frames) */
790 if (redraw_mask & REDRAW_ALL)
792 BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
794 else if (redraw_mask & REDRAW_FIELD)
796 BlitBitmap(backbuffer, window,
797 REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
799 else if (redraw_mask & REDRAW_DOORS)
801 // merge door areas to prevent calling screen redraw more than once
807 if (redraw_mask & REDRAW_DOOR_1)
811 x2 = MAX(x2, DX + DXSIZE);
812 y2 = MAX(y2, DY + DYSIZE);
815 if (redraw_mask & REDRAW_DOOR_2)
819 x2 = MAX(x2, VX + VXSIZE);
820 y2 = MAX(y2, VY + VYSIZE);
823 if (redraw_mask & REDRAW_DOOR_3)
827 x2 = MAX(x2, EX + EXSIZE);
828 y2 = MAX(y2, EY + EYSIZE);
831 // make sure that at least one pixel is blitted, and inside the screen
832 // (else nothing is blitted, causing the animations not to be updated)
833 x1 = MIN(MAX(0, x1), WIN_XSIZE - 1);
834 y1 = MIN(MAX(0, y1), WIN_YSIZE - 1);
835 x2 = MIN(MAX(1, x2), WIN_XSIZE);
836 y2 = MIN(MAX(1, y2), WIN_YSIZE);
838 BlitBitmap(backbuffer, window, x1, y1, x2 - x1, y2 - y1, x1, y1);
841 redraw_mask = REDRAW_NONE;
844 PrintFrameTimeDebugging();
848 void BackToFront_WithFrameDelay(unsigned int frame_delay_value)
850 unsigned int frame_delay_value_old = GetVideoFrameDelay();
852 SetVideoFrameDelay(frame_delay_value);
856 SetVideoFrameDelay(frame_delay_value_old);
859 static int fade_type_skip = FADE_TYPE_NONE;
861 static void FadeExt(int fade_mask, int fade_mode, int fade_type)
863 void (*draw_border_function)(void) = NULL;
864 int x, y, width, height;
865 int fade_delay, post_delay;
867 if (fade_type == FADE_TYPE_FADE_OUT)
869 if (fade_type_skip != FADE_TYPE_NONE)
871 // skip all fade operations until specified fade operation
872 if (fade_type & fade_type_skip)
873 fade_type_skip = FADE_TYPE_NONE;
878 if (fading.fade_mode & FADE_TYPE_TRANSFORM)
882 redraw_mask |= fade_mask;
884 if (fade_type == FADE_TYPE_SKIP)
886 fade_type_skip = fade_mode;
891 fade_delay = fading.fade_delay;
892 post_delay = (fade_mode == FADE_MODE_FADE_OUT ? fading.post_delay : 0);
894 if (fade_type_skip != FADE_TYPE_NONE)
896 // skip all fade operations until specified fade operation
897 if (fade_type & fade_type_skip)
898 fade_type_skip = FADE_TYPE_NONE;
903 if (global.autoplay_leveldir)
908 if (fade_mask == REDRAW_FIELD)
913 height = FADE_SYSIZE;
915 if (border.draw_masked_when_fading)
916 draw_border_function = DrawMaskedBorder_FIELD; // update when fading
918 DrawMaskedBorder_FIELD(); // draw once
928 // when switching screens without fading, set fade delay to zero
929 if (!setup.fade_screens || fading.fade_mode == FADE_MODE_NONE)
932 // do not display black frame when fading out without fade delay
933 if (fade_mode == FADE_MODE_FADE_OUT && fade_delay == 0)
936 FadeRectangle(x, y, width, height, fade_mode, fade_delay, post_delay,
937 draw_border_function);
939 redraw_mask &= ~fade_mask;
941 ClearAutoRepeatKeyEvents();
944 static void SetScreenStates_BeforeFadingIn(void)
946 // temporarily set screen mode for animations to screen after fading in
947 global.anim_status = global.anim_status_next;
949 // store backbuffer with all animations that will be started after fading in
950 PrepareFadeBitmap(DRAW_TO_FADE_TARGET);
952 // set screen mode for animations back to fading
953 global.anim_status = GAME_MODE_PSEUDO_FADING;
956 static void SetScreenStates_AfterFadingIn(void)
958 // store new source screen (to use correct masked border for fading)
959 gfx.fade_border_source_status = global.border_status;
961 global.anim_status = global.anim_status_next;
964 static void SetScreenStates_BeforeFadingOut(void)
966 // store new target screen (to use correct masked border for fading)
967 gfx.fade_border_target_status = game_status;
969 // set screen mode for animations to fading
970 global.anim_status = GAME_MODE_PSEUDO_FADING;
972 // store backbuffer with all animations that will be stopped for fading out
973 PrepareFadeBitmap(DRAW_TO_FADE_SOURCE);
976 static void SetScreenStates_AfterFadingOut(void)
978 global.border_status = game_status;
981 void FadeIn(int fade_mask)
983 SetScreenStates_BeforeFadingIn();
986 DrawMaskedBorder(REDRAW_ALL);
989 if (fading.fade_mode & FADE_TYPE_TRANSFORM)
990 FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_IN);
992 FadeExt(fade_mask, FADE_MODE_FADE_IN, FADE_TYPE_FADE_IN);
996 FADE_SXSIZE = FULL_SXSIZE;
997 FADE_SYSIZE = FULL_SYSIZE;
999 // activate virtual buttons depending on upcoming game status
1000 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS) &&
1001 game_status == GAME_MODE_PLAYING && !tape.playing)
1002 SetOverlayActive(TRUE);
1004 SetScreenStates_AfterFadingIn();
1006 // force update of global animation status in case of rapid screen changes
1007 redraw_mask = REDRAW_ALL;
1011 void FadeOut(int fade_mask)
1013 // update screen if areas covered by "fade_mask" and "redraw_mask" differ
1014 if (!equalRedrawMasks(fade_mask, redraw_mask) &&
1015 fade_type_skip != FADE_MODE_SKIP_FADE_OUT)
1018 SetScreenStates_BeforeFadingOut();
1020 SetTileCursorActive(FALSE);
1021 SetOverlayActive(FALSE);
1024 DrawMaskedBorder(REDRAW_ALL);
1027 if (fading.fade_mode & FADE_TYPE_TRANSFORM)
1028 FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_OUT);
1030 FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
1032 SetScreenStates_AfterFadingOut();
1035 static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
1037 static struct TitleFadingInfo fading_leave_stored;
1040 fading_leave_stored = fading_leave;
1042 fading = fading_leave_stored;
1045 void FadeSetEnterMenu(void)
1047 fading = menu.enter_menu;
1049 FadeSetLeaveNext(fading, TRUE); // (keep same fade mode)
1052 void FadeSetLeaveMenu(void)
1054 fading = menu.leave_menu;
1056 FadeSetLeaveNext(fading, TRUE); // (keep same fade mode)
1059 void FadeSetEnterScreen(void)
1061 fading = menu.enter_screen[game_status];
1063 FadeSetLeaveNext(menu.leave_screen[game_status], TRUE); // store
1066 void FadeSetNextScreen(void)
1068 fading = menu.next_screen[game_status];
1070 // (do not overwrite fade mode set by FadeSetEnterScreen)
1071 // FadeSetLeaveNext(fading, TRUE); // (keep same fade mode)
1074 void FadeSetLeaveScreen(void)
1076 FadeSetLeaveNext(menu.leave_screen[game_status], FALSE); // recall
1079 void FadeSetFromType(int type)
1081 if (type & TYPE_ENTER_SCREEN)
1082 FadeSetEnterScreen();
1083 else if (type & TYPE_ENTER)
1085 else if (type & TYPE_LEAVE)
1089 void FadeSetDisabled(void)
1091 static struct TitleFadingInfo fading_none = { FADE_MODE_NONE, -1, -1, -1 };
1093 fading = fading_none;
1096 void FadeSkipNextFadeIn(void)
1098 FadeExt(0, FADE_MODE_SKIP_FADE_IN, FADE_TYPE_SKIP);
1101 void FadeSkipNextFadeOut(void)
1103 FadeExt(0, FADE_MODE_SKIP_FADE_OUT, FADE_TYPE_SKIP);
1106 static int getGlobalGameStatus(int status)
1108 return (status == GAME_MODE_PSEUDO_TYPENAME ? GAME_MODE_MAIN :
1109 status == GAME_MODE_SCOREINFO ? GAME_MODE_SCORES :
1113 Bitmap *getBitmapFromGraphicOrDefault(int graphic, int default_graphic)
1115 if (graphic == IMG_UNDEFINED)
1118 boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
1120 return (graphic_info[graphic].bitmap != NULL || redefined ?
1121 graphic_info[graphic].bitmap :
1122 graphic_info[default_graphic].bitmap);
1125 static Bitmap *getBackgroundBitmap(int graphic)
1127 return getBitmapFromGraphicOrDefault(graphic, IMG_BACKGROUND);
1130 static Bitmap *getGlobalBorderBitmap(int graphic)
1132 return getBitmapFromGraphicOrDefault(graphic, IMG_GLOBAL_BORDER);
1135 Bitmap *getGlobalBorderBitmapFromStatus(int status_raw)
1137 int status = getGlobalGameStatus(status_raw);
1139 (status == GAME_MODE_MAIN ? IMG_GLOBAL_BORDER_MAIN :
1140 status == GAME_MODE_SCORES ? IMG_GLOBAL_BORDER_SCORES :
1141 status == GAME_MODE_EDITOR ? IMG_GLOBAL_BORDER_EDITOR :
1142 status == GAME_MODE_PLAYING ? IMG_GLOBAL_BORDER_PLAYING :
1145 return getGlobalBorderBitmap(graphic);
1148 void SetWindowBackgroundImageIfDefined(int graphic)
1150 if (graphic_info[graphic].bitmap)
1151 SetWindowBackgroundBitmap(graphic_info[graphic].bitmap);
1154 void SetMainBackgroundImageIfDefined(int graphic)
1156 if (graphic_info[graphic].bitmap)
1157 SetMainBackgroundBitmap(graphic_info[graphic].bitmap);
1160 void SetDoorBackgroundImageIfDefined(int graphic)
1162 if (graphic_info[graphic].bitmap)
1163 SetDoorBackgroundBitmap(graphic_info[graphic].bitmap);
1166 void SetWindowBackgroundImage(int graphic)
1168 SetWindowBackgroundBitmap(getBackgroundBitmap(graphic));
1171 void SetMainBackgroundImage(int graphic)
1173 SetMainBackgroundBitmap(getBackgroundBitmap(graphic));
1176 void SetDoorBackgroundImage(int graphic)
1178 SetDoorBackgroundBitmap(getBackgroundBitmap(graphic));
1181 void SetPanelBackground(void)
1183 struct GraphicInfo *gfx = &graphic_info[IMG_BACKGROUND_PANEL];
1185 BlitBitmapTiled(gfx->bitmap, bitmap_db_panel, gfx->src_x, gfx->src_y,
1186 gfx->width, gfx->height, 0, 0, DXSIZE, DYSIZE);
1188 SetDoorBackgroundBitmap(bitmap_db_panel);
1191 void DrawBackground(int x, int y, int width, int height)
1193 // "drawto" might still point to playfield buffer here (hall of fame)
1194 ClearRectangleOnBackground(backbuffer, x, y, width, height);
1196 if (IN_GFX_FIELD_FULL(x, y))
1197 redraw_mask |= REDRAW_FIELD;
1198 else if (IN_GFX_DOOR_1(x, y))
1199 redraw_mask |= REDRAW_DOOR_1;
1200 else if (IN_GFX_DOOR_2(x, y))
1201 redraw_mask |= REDRAW_DOOR_2;
1202 else if (IN_GFX_DOOR_3(x, y))
1203 redraw_mask |= REDRAW_DOOR_3;
1206 void DrawBackgroundForFont(int x, int y, int width, int height, int font_nr)
1208 struct FontBitmapInfo *font = getFontBitmapInfo(font_nr);
1210 if (font->bitmap == NULL)
1213 DrawBackground(x, y, width, height);
1216 void DrawBackgroundForGraphic(int x, int y, int width, int height, int graphic)
1218 struct GraphicInfo *g = &graphic_info[graphic];
1220 if (g->bitmap == NULL)
1223 DrawBackground(x, y, width, height);
1226 static int game_status_last = -1;
1227 static Bitmap *global_border_bitmap_last = NULL;
1228 static Bitmap *global_border_bitmap = NULL;
1229 static int real_sx_last = -1, real_sy_last = -1;
1230 static int full_sxsize_last = -1, full_sysize_last = -1;
1231 static int dx_last = -1, dy_last = -1;
1232 static int dxsize_last = -1, dysize_last = -1;
1233 static int vx_last = -1, vy_last = -1;
1234 static int vxsize_last = -1, vysize_last = -1;
1235 static int ex_last = -1, ey_last = -1;
1236 static int exsize_last = -1, eysize_last = -1;
1238 boolean CheckIfGlobalBorderHasChanged(void)
1240 // if game status has not changed, global border has not changed either
1241 if (game_status == game_status_last)
1244 // determine and store new global border bitmap for current game status
1245 global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
1247 return (global_border_bitmap_last != global_border_bitmap);
1250 #define ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED 0
1252 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1253 static boolean CheckIfGlobalBorderRedrawIsNeeded(void)
1255 // if game status has not changed, nothing has to be redrawn
1256 if (game_status == game_status_last)
1259 // redraw if last screen was title screen
1260 if (game_status_last == GAME_MODE_TITLE)
1263 // redraw if global screen border has changed
1264 if (CheckIfGlobalBorderHasChanged())
1267 // redraw if position or size of playfield area has changed
1268 if (real_sx_last != REAL_SX || real_sy_last != REAL_SY ||
1269 full_sxsize_last != FULL_SXSIZE || full_sysize_last != FULL_SYSIZE)
1272 // redraw if position or size of door area has changed
1273 if (dx_last != DX || dy_last != DY ||
1274 dxsize_last != DXSIZE || dysize_last != DYSIZE)
1277 // redraw if position or size of tape area has changed
1278 if (vx_last != VX || vy_last != VY ||
1279 vxsize_last != VXSIZE || vysize_last != VYSIZE)
1282 // redraw if position or size of editor area has changed
1283 if (ex_last != EX || ey_last != EY ||
1284 exsize_last != EXSIZE || eysize_last != EYSIZE)
1291 static void RedrawGlobalBorderFromBitmap(Bitmap *bitmap)
1294 BlitBitmap(bitmap, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1296 ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
1299 void RedrawGlobalBorder(void)
1301 Bitmap *bitmap = getGlobalBorderBitmapFromStatus(game_status);
1303 RedrawGlobalBorderFromBitmap(bitmap);
1305 redraw_mask = REDRAW_ALL;
1308 static void RedrawGlobalBorderIfNeeded(void)
1310 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1311 if (game_status == game_status_last)
1315 // copy current draw buffer to later copy back areas that have not changed
1316 if (game_status_last != GAME_MODE_TITLE)
1317 BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1319 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1320 if (CheckIfGlobalBorderRedrawIsNeeded())
1322 // determine and store new global border bitmap for current game status
1323 global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
1326 // redraw global screen border (or clear, if defined to be empty)
1327 RedrawGlobalBorderFromBitmap(global_border_bitmap);
1329 if (game_status == GAME_MODE_EDITOR)
1330 DrawSpecialEditorDoor();
1332 // copy previous playfield and door areas, if they are defined on both
1333 // previous and current screen and if they still have the same size
1335 if (real_sx_last != -1 && real_sy_last != -1 &&
1336 REAL_SX != -1 && REAL_SY != -1 &&
1337 full_sxsize_last == FULL_SXSIZE && full_sysize_last == FULL_SYSIZE)
1338 BlitBitmap(bitmap_db_store_1, backbuffer,
1339 real_sx_last, real_sy_last, FULL_SXSIZE, FULL_SYSIZE,
1342 if (dx_last != -1 && dy_last != -1 &&
1343 DX != -1 && DY != -1 &&
1344 dxsize_last == DXSIZE && dysize_last == DYSIZE)
1345 BlitBitmap(bitmap_db_store_1, backbuffer,
1346 dx_last, dy_last, DXSIZE, DYSIZE, DX, DY);
1348 if (game_status != GAME_MODE_EDITOR)
1350 if (vx_last != -1 && vy_last != -1 &&
1351 VX != -1 && VY != -1 &&
1352 vxsize_last == VXSIZE && vysize_last == VYSIZE)
1353 BlitBitmap(bitmap_db_store_1, backbuffer,
1354 vx_last, vy_last, VXSIZE, VYSIZE, VX, VY);
1358 if (ex_last != -1 && ey_last != -1 &&
1359 EX != -1 && EY != -1 &&
1360 exsize_last == EXSIZE && eysize_last == EYSIZE)
1361 BlitBitmap(bitmap_db_store_1, backbuffer,
1362 ex_last, ey_last, EXSIZE, EYSIZE, EX, EY);
1365 redraw_mask = REDRAW_ALL;
1368 game_status_last = game_status;
1370 global_border_bitmap_last = global_border_bitmap;
1372 real_sx_last = REAL_SX;
1373 real_sy_last = REAL_SY;
1374 full_sxsize_last = FULL_SXSIZE;
1375 full_sysize_last = FULL_SYSIZE;
1378 dxsize_last = DXSIZE;
1379 dysize_last = DYSIZE;
1382 vxsize_last = VXSIZE;
1383 vysize_last = VYSIZE;
1386 exsize_last = EXSIZE;
1387 eysize_last = EYSIZE;
1390 void ClearField(void)
1392 RedrawGlobalBorderIfNeeded();
1394 // !!! "drawto" might still point to playfield buffer here (see above) !!!
1395 // (when entering hall of fame after playing)
1396 DrawBackground(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
1398 // !!! maybe this should be done before clearing the background !!!
1399 if (game_status == GAME_MODE_PLAYING)
1401 ClearRectangle(fieldbuffer, 0, 0, FXSIZE, FYSIZE);
1402 SetDrawtoField(DRAW_TO_FIELDBUFFER);
1406 SetDrawtoField(DRAW_TO_BACKBUFFER);
1410 void MarkTileDirty(int x, int y)
1412 redraw_mask |= REDRAW_FIELD;
1415 void SetBorderElement(void)
1419 BorderElement = EL_EMPTY;
1421 // only the R'n'D game engine may use an additional steelwall border
1422 if (level.game_engine_type != GAME_ENGINE_TYPE_RND)
1425 for (y = 0; y < lev_fieldy && BorderElement == EL_EMPTY; y++)
1427 for (x = 0; x < lev_fieldx; x++)
1429 if (!IS_INDESTRUCTIBLE(Tile[x][y]))
1430 BorderElement = EL_STEELWALL;
1432 if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
1438 void FloodFillLevelExt(int start_x, int start_y, int fill_element,
1439 int max_array_fieldx, int max_array_fieldy,
1440 short field[max_array_fieldx][max_array_fieldy],
1441 int max_fieldx, int max_fieldy)
1443 static struct XY stack_buffer[MAX_LEV_FIELDX * MAX_LEV_FIELDY];
1444 struct XY *check = xy_topdown;
1445 int old_element = field[start_x][start_y];
1448 // do nothing if start field already has the desired content
1449 if (old_element == fill_element)
1452 stack_buffer[stack_pos++] = (struct XY){ start_x, start_y };
1454 while (stack_pos > 0)
1456 struct XY current = stack_buffer[--stack_pos];
1459 field[current.x][current.y] = fill_element;
1461 for (i = 0; i < 4; i++)
1463 int x = current.x + check[i].x;
1464 int y = current.y + check[i].y;
1466 // check for stack buffer overflow (should not happen)
1467 if (stack_pos >= MAX_LEV_FIELDX * MAX_LEV_FIELDY)
1468 Fail("Stack buffer overflow in 'FloodFillLevelExt()'. Please debug.");
1470 if (IN_FIELD(x, y, max_fieldx, max_fieldy) && field[x][y] == old_element)
1471 stack_buffer[stack_pos++] = (struct XY){ x, y };
1476 void FloodFillLevel(int from_x, int from_y, int fill_element,
1477 short field[MAX_LEV_FIELDX][MAX_LEV_FIELDY],
1478 int max_fieldx, int max_fieldy)
1480 FloodFillLevelExt(from_x, from_y, fill_element,
1481 MAX_LEV_FIELDX, MAX_LEV_FIELDY, field,
1482 max_fieldx, max_fieldy);
1485 void SetRandomAnimationValue(int x, int y)
1487 gfx.anim_random_frame = GfxRandom[x][y];
1490 int getGraphicAnimationFrame(int graphic, int sync_frame)
1492 // animation synchronized with global frame counter, not move position
1493 if (graphic_info[graphic].anim_global_sync || sync_frame < 0)
1494 sync_frame = FrameCounter;
1495 else if (graphic_info[graphic].anim_global_anim_sync)
1496 sync_frame = getGlobalAnimSyncFrame();
1498 return getAnimationFrame(graphic_info[graphic].anim_frames,
1499 graphic_info[graphic].anim_delay,
1500 graphic_info[graphic].anim_mode,
1501 graphic_info[graphic].anim_start_frame,
1505 int getGraphicAnimationFrameXY(int graphic, int lx, int ly)
1507 if (graphic_info[graphic].anim_mode & ANIM_TILED)
1509 struct GraphicInfo *g = &graphic_info[graphic];
1510 int xsize = MAX(1, g->anim_frames_per_line);
1511 int ysize = MAX(1, g->anim_frames / xsize);
1512 int xoffset = g->anim_start_frame % xsize;
1513 int yoffset = g->anim_start_frame % ysize;
1514 // may be needed if screen field is significantly larger than playfield
1515 int x = (lx + xoffset + SCR_FIELDX * xsize) % xsize;
1516 int y = (ly + yoffset + SCR_FIELDY * ysize) % ysize;
1517 int sync_frame = y * xsize + x;
1519 return sync_frame % g->anim_frames;
1521 else if (graphic_info[graphic].anim_mode & ANIM_RANDOM_STATIC)
1523 struct GraphicInfo *g = &graphic_info[graphic];
1524 // may be needed if screen field is significantly larger than playfield
1525 int x = (lx + SCR_FIELDX * lev_fieldx) % lev_fieldx;
1526 int y = (ly + SCR_FIELDY * lev_fieldy) % lev_fieldy;
1527 int sync_frame = GfxRandomStatic[x][y];
1529 return sync_frame % g->anim_frames;
1533 int sync_frame = (IN_LEV_FIELD(lx, ly) ? GfxFrame[lx][ly] : -1);
1535 return getGraphicAnimationFrame(graphic, sync_frame);
1539 void getGraphicSourceBitmap(int graphic, int tilesize, Bitmap **bitmap)
1541 struct GraphicInfo *g = &graphic_info[graphic];
1542 int tilesize_capped = MIN(MAX(1, tilesize), TILESIZE);
1544 if (tilesize == gfx.standard_tile_size)
1545 *bitmap = g->bitmaps[IMG_BITMAP_STANDARD];
1546 else if (tilesize == game.tile_size)
1547 *bitmap = g->bitmaps[IMG_BITMAP_PTR_GAME];
1549 *bitmap = g->bitmaps[IMG_BITMAP_1x1 - log_2(tilesize_capped)];
1552 void getGraphicSourceXY(int graphic, int frame, int *x, int *y,
1553 boolean get_backside)
1555 struct GraphicInfo *g = &graphic_info[graphic];
1556 int src_x = g->src_x + (get_backside ? g->offset2_x : 0);
1557 int src_y = g->src_y + (get_backside ? g->offset2_y : 0);
1559 if (g->offset_y == 0) // frames are ordered horizontally
1561 int max_width = g->anim_frames_per_line * g->width;
1562 int pos = (src_y / g->height) * max_width + src_x + frame * g->offset_x;
1564 *x = pos % max_width;
1565 *y = src_y % g->height + pos / max_width * g->height;
1567 else if (g->offset_x == 0) // frames are ordered vertically
1569 int max_height = g->anim_frames_per_line * g->height;
1570 int pos = (src_x / g->width) * max_height + src_y + frame * g->offset_y;
1572 *x = src_x % g->width + pos / max_height * g->width;
1573 *y = pos % max_height;
1575 else // frames are ordered diagonally
1577 *x = src_x + frame * g->offset_x;
1578 *y = src_y + frame * g->offset_y;
1582 void getSizedGraphicSourceExt(int graphic, int frame, int tilesize,
1583 Bitmap **bitmap, int *x, int *y,
1584 boolean get_backside)
1586 struct GraphicInfo *g = &graphic_info[graphic];
1588 // if no graphics defined at all, use fallback graphics
1589 if (g->bitmaps == NULL)
1590 *g = graphic_info[IMG_CHAR_EXCLAM];
1592 // if no in-game graphics defined, always use standard graphic size
1593 if (g->bitmaps[IMG_BITMAP_PTR_GAME] == NULL)
1594 tilesize = TILESIZE;
1596 getGraphicSourceBitmap(graphic, tilesize, bitmap);
1597 getGraphicSourceXY(graphic, frame, x, y, get_backside);
1599 *x = *x * tilesize / g->tile_size;
1600 *y = *y * tilesize / g->tile_size;
1603 void getSizedGraphicSource(int graphic, int frame, int tilesize,
1604 Bitmap **bitmap, int *x, int *y)
1606 getSizedGraphicSourceExt(graphic, frame, tilesize, bitmap, x, y, FALSE);
1609 void getFixedGraphicSource(int graphic, int frame,
1610 Bitmap **bitmap, int *x, int *y)
1612 getSizedGraphicSourceExt(graphic, frame, TILESIZE, bitmap, x, y, FALSE);
1615 void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
1617 getSizedGraphicSource(graphic, 0, MINI_TILESIZE, bitmap, x, y);
1620 void getGlobalAnimGraphicSource(int graphic, int frame,
1621 Bitmap **bitmap, int *x, int *y)
1623 struct GraphicInfo *g = &graphic_info[graphic];
1625 // if no graphics defined at all, use fallback graphics
1626 if (g->bitmaps == NULL)
1627 *g = graphic_info[IMG_CHAR_EXCLAM];
1629 // use original size graphics, if existing, else use standard size graphics
1630 if (g->bitmaps[IMG_BITMAP_PTR_ORIGINAL])
1631 *bitmap = g->bitmaps[IMG_BITMAP_PTR_ORIGINAL];
1633 *bitmap = g->bitmaps[IMG_BITMAP_STANDARD];
1635 getGraphicSourceXY(graphic, frame, x, y, FALSE);
1638 static void getGraphicSourceExt(int graphic, int frame, Bitmap **bitmap,
1639 int *x, int *y, boolean get_backside)
1641 getSizedGraphicSourceExt(graphic, frame, TILESIZE_VAR, bitmap, x, y,
1645 void getGraphicSource(int graphic, int frame, Bitmap **bitmap, int *x, int *y)
1647 getGraphicSourceExt(graphic, frame, bitmap, x, y, FALSE);
1650 void DrawGraphic(int x, int y, int graphic, int frame)
1653 if (!IN_SCR_FIELD(x, y))
1655 Debug("draw:DrawGraphic", "x = %d, y = %d, graphic = %d", x, y, graphic);
1656 Debug("draw:DrawGraphic", "This should never happen!");
1662 DrawGraphicExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR, graphic,
1665 MarkTileDirty(x, y);
1668 void DrawFixedGraphic(int x, int y, int graphic, int frame)
1671 if (!IN_SCR_FIELD(x, y))
1673 Debug("draw:DrawFixedGraphic", "x = %d, y = %d, graphic = %d",
1675 Debug("draw:DrawFixedGraphic", "This should never happen!");
1681 DrawFixedGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic,
1683 MarkTileDirty(x, y);
1686 void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1692 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1694 BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX_VAR, TILEY_VAR, x, y);
1697 void DrawFixedGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1703 getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1704 BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
1707 void DrawGraphicThruMask(int x, int y, int graphic, int frame)
1710 if (!IN_SCR_FIELD(x, y))
1712 Debug("draw:DrawGraphicThruMask", "x = %d,y = %d, graphic = %d",
1714 Debug("draw:DrawGraphicThruMask", "This should never happen!");
1720 DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
1723 MarkTileDirty(x, y);
1726 void DrawFixedGraphicThruMask(int x, int y, int graphic, int frame)
1729 if (!IN_SCR_FIELD(x, y))
1731 Debug("draw:DrawFixedGraphicThruMask", "x = %d,y = %d, graphic = %d",
1733 Debug("draw:DrawFixedGraphicThruMask", "This should never happen!");
1739 DrawFixedGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
1741 MarkTileDirty(x, y);
1744 void DrawGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y, int graphic,
1750 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1752 BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX_VAR, TILEY_VAR,
1756 void DrawFixedGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y,
1757 int graphic, int frame)
1762 getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1764 BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY,
1768 void DrawSizedGraphic(int x, int y, int graphic, int frame, int tilesize)
1770 DrawSizedGraphicExt(drawto, SX + x * tilesize, SY + y * tilesize, graphic,
1772 MarkTileDirty(x / tilesize, y / tilesize);
1775 void DrawSizedGraphicThruMask(int x, int y, int graphic, int frame,
1778 DrawSizedGraphicThruMaskExt(drawto, SX + x * tilesize, SY + y * tilesize,
1779 graphic, frame, tilesize);
1780 MarkTileDirty(x / tilesize, y / tilesize);
1783 void DrawSizedGraphicExt(DrawBuffer *d, int x, int y, int graphic, int frame,
1789 getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1790 BlitBitmap(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1793 void DrawSizedGraphicThruMaskExt(DrawBuffer *d, int x, int y, int graphic,
1794 int frame, int tilesize)
1799 getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1800 BlitBitmapMasked(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1803 void DrawMiniGraphic(int x, int y, int graphic)
1805 DrawMiniGraphicExt(drawto, SX + x * MINI_TILEX,SY + y * MINI_TILEY, graphic);
1806 MarkTileDirty(x / 2, y / 2);
1809 void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
1814 getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
1815 BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
1818 static void DrawGraphicShiftedNormal(int x, int y, int dx, int dy,
1819 int graphic, int frame,
1820 int cut_mode, int mask_mode)
1825 int width = TILEX, height = TILEY;
1828 if (dx || dy) // shifted graphic
1830 if (x < BX1) // object enters playfield from the left
1837 else if (x > BX2) // object enters playfield from the right
1843 else if (x == BX1 && dx < 0) // object leaves playfield to the left
1849 else if (x == BX2 && dx > 0) // object leaves playfield to the right
1851 else if (dx) // general horizontal movement
1852 MarkTileDirty(x + SIGN(dx), y);
1854 if (y < BY1) // object enters playfield from the top
1856 if (cut_mode == CUT_BELOW) // object completely above top border
1864 else if (y > BY2) // object enters playfield from the bottom
1870 else if (y == BY1 && dy < 0) // object leaves playfield to the top
1876 else if (dy > 0 && cut_mode == CUT_ABOVE)
1878 if (y == BY2) // object completely above bottom border
1884 MarkTileDirty(x, y + 1);
1885 } // object leaves playfield to the bottom
1886 else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
1888 else if (dy) // general vertical movement
1889 MarkTileDirty(x, y + SIGN(dy));
1893 if (!IN_SCR_FIELD(x, y))
1895 Debug("draw:DrawGraphicShiftedNormal", "x = %d, y = %d, graphic = %d",
1897 Debug("draw:DrawGraphicShiftedNormal", "This should never happen!");
1903 width = width * TILESIZE_VAR / TILESIZE;
1904 height = height * TILESIZE_VAR / TILESIZE;
1905 cx = cx * TILESIZE_VAR / TILESIZE;
1906 cy = cy * TILESIZE_VAR / TILESIZE;
1907 dx = dx * TILESIZE_VAR / TILESIZE;
1908 dy = dy * TILESIZE_VAR / TILESIZE;
1910 if (width > 0 && height > 0)
1912 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1917 dst_x = FX + x * TILEX_VAR + dx;
1918 dst_y = FY + y * TILEY_VAR + dy;
1920 if (mask_mode == USE_MASKING)
1921 BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1924 BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1927 MarkTileDirty(x, y);
1931 static void DrawGraphicShiftedDouble(int x, int y, int dx, int dy,
1932 int graphic, int frame,
1933 int cut_mode, int mask_mode)
1938 int width = TILEX_VAR, height = TILEY_VAR;
1941 int x2 = x + SIGN(dx);
1942 int y2 = y + SIGN(dy);
1944 // movement with two-tile animations must be sync'ed with movement position,
1945 // not with current GfxFrame (which can be higher when using slow movement)
1946 int anim_pos = (dx ? ABS(dx) : ABS(dy));
1947 int anim_frames = graphic_info[graphic].anim_frames;
1949 // (we also need anim_delay here for movement animations with less frames)
1950 int anim_delay = graphic_info[graphic].anim_delay;
1951 int sync_frame = anim_pos * anim_frames * anim_delay / TILESIZE;
1953 boolean draw_start_tile = (cut_mode != CUT_ABOVE); // only for falling!
1954 boolean draw_end_tile = (cut_mode != CUT_BELOW); // only for falling!
1956 // re-calculate animation frame for two-tile movement animation
1957 frame = getGraphicAnimationFrame(graphic, sync_frame);
1959 // check if movement start graphic inside screen area and should be drawn
1960 if (draw_start_tile && IN_SCR_FIELD(x1, y1))
1962 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, TRUE);
1964 dst_x = FX + x1 * TILEX_VAR;
1965 dst_y = FY + y1 * TILEY_VAR;
1967 if (mask_mode == USE_MASKING)
1968 BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1971 BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1974 MarkTileDirty(x1, y1);
1977 // check if movement end graphic inside screen area and should be drawn
1978 if (draw_end_tile && IN_SCR_FIELD(x2, y2))
1980 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
1982 dst_x = FX + x2 * TILEX_VAR;
1983 dst_y = FY + y2 * TILEY_VAR;
1985 if (mask_mode == USE_MASKING)
1986 BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1989 BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1992 MarkTileDirty(x2, y2);
1996 static void DrawGraphicShifted(int x, int y, int dx, int dy,
1997 int graphic, int frame,
1998 int cut_mode, int mask_mode)
2002 DrawGraphic(x, y, graphic, frame);
2007 if (graphic_info[graphic].double_movement) // EM style movement images
2008 DrawGraphicShiftedDouble(x, y, dx, dy, graphic, frame, cut_mode,mask_mode);
2010 DrawGraphicShiftedNormal(x, y, dx, dy, graphic, frame, cut_mode,mask_mode);
2013 static void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy,
2014 int graphic, int frame, int cut_mode)
2016 DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, USE_MASKING);
2019 void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
2020 int cut_mode, int mask_mode)
2022 int lx = LEVELX(x), ly = LEVELY(y);
2026 if (IN_LEV_FIELD(lx, ly))
2028 if (element == EL_EMPTY)
2029 element = GfxElementEmpty[lx][ly];
2031 SetRandomAnimationValue(lx, ly);
2033 graphic = el_act_dir2img(element, GfxAction[lx][ly], GfxDir[lx][ly]);
2034 frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2036 // do not use double (EM style) movement graphic when not moving
2037 if (graphic_info[graphic].double_movement && !dx && !dy)
2039 graphic = el_act_dir2img(element, ACTION_DEFAULT, GfxDir[lx][ly]);
2040 frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2043 if (game.use_masked_elements && (dx || dy))
2044 mask_mode = USE_MASKING;
2046 else // border element
2048 graphic = el2img(element);
2049 frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2052 if (element == EL_EXPANDABLE_WALL)
2054 boolean left_stopped = FALSE, right_stopped = FALSE;
2056 if (!IN_LEV_FIELD(lx - 1, ly) || IS_WALL(Tile[lx - 1][ly]))
2057 left_stopped = TRUE;
2058 if (!IN_LEV_FIELD(lx + 1, ly) || IS_WALL(Tile[lx + 1][ly]))
2059 right_stopped = TRUE;
2061 if (left_stopped && right_stopped)
2063 else if (left_stopped)
2065 graphic = IMG_EXPANDABLE_WALL_GROWING_RIGHT;
2066 frame = graphic_info[graphic].anim_frames - 1;
2068 else if (right_stopped)
2070 graphic = IMG_EXPANDABLE_WALL_GROWING_LEFT;
2071 frame = graphic_info[graphic].anim_frames - 1;
2076 DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
2077 else if (mask_mode == USE_MASKING)
2078 DrawGraphicThruMask(x, y, graphic, frame);
2080 DrawGraphic(x, y, graphic, frame);
2083 void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
2084 int cut_mode, int mask_mode)
2086 if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2087 DrawScreenElementExt(SCREENX(x), SCREENY(y), dx, dy, element,
2088 cut_mode, mask_mode);
2091 void DrawScreenElementShifted(int x, int y, int dx, int dy, int element,
2094 DrawScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
2097 void DrawLevelElementShifted(int x, int y, int dx, int dy, int element,
2100 DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
2103 void DrawLevelElementThruMask(int x, int y, int element)
2105 DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
2108 void DrawLevelFieldThruMask(int x, int y)
2110 DrawLevelElementExt(x, y, 0, 0, Tile[x][y], NO_CUTTING, USE_MASKING);
2113 // !!! implementation of quicksand is totally broken !!!
2114 #define IS_CRUMBLED_TILE(x, y, e) \
2115 (GFX_CRUMBLED(e) && (!IN_LEV_FIELD(x, y) || \
2116 !IS_MOVING(x, y) || \
2117 (e) == EL_QUICKSAND_EMPTYING || \
2118 (e) == EL_QUICKSAND_FAST_EMPTYING))
2120 static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy,
2125 int width, height, cx, cy;
2126 int sx = SCREENX(x), sy = SCREENY(y);
2127 int crumbled_border_size = graphic_info[graphic].border_size;
2128 int crumbled_tile_size = graphic_info[graphic].tile_size;
2129 int crumbled_border_size_var =
2130 crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
2133 getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2135 for (i = 1; i < 4; i++)
2137 int dxx = (i & 1 ? dx : 0);
2138 int dyy = (i & 2 ? dy : 0);
2141 int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2144 // check if neighbour field is of same crumble type
2145 boolean same = (IS_CRUMBLED_TILE(xx, yy, element) &&
2146 graphic_info[graphic].class ==
2147 graphic_info[el_act2crm(element, ACTION_DEFAULT)].class);
2149 // return if check prevents inner corner
2150 if (same == (dxx == dx && dyy == dy))
2154 // if we reach this point, we have an inner corner
2156 getGraphicSource(graphic, 1, &src_bitmap, &src_x, &src_y);
2158 width = crumbled_border_size_var;
2159 height = crumbled_border_size_var;
2160 cx = (dx > 0 ? TILESIZE_VAR - width : 0);
2161 cy = (dy > 0 ? TILESIZE_VAR - height : 0);
2163 if (game.use_masked_elements)
2165 int graphic0 = el2img(EL_EMPTY);
2166 int frame0 = getGraphicAnimationFrameXY(graphic0, x, y);
2167 Bitmap *src_bitmap0;
2170 getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
2172 BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
2174 FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2176 BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2178 FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2181 BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2183 FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2186 static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
2191 int width, height, bx, by, cx, cy;
2192 int sx = SCREENX(x), sy = SCREENY(y);
2193 int crumbled_border_size = graphic_info[graphic].border_size;
2194 int crumbled_tile_size = graphic_info[graphic].tile_size;
2195 int crumbled_border_size_var =
2196 crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
2197 int crumbled_border_pos_var = TILESIZE_VAR - crumbled_border_size_var;
2200 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2202 // only needed when using masked elements
2203 int graphic0 = el2img(EL_EMPTY);
2204 int frame0 = getGraphicAnimationFrameXY(graphic0, x, y);
2205 Bitmap *src_bitmap0;
2208 if (game.use_masked_elements)
2209 getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
2211 // draw simple, sloppy, non-corner-accurate crumbled border
2213 width = (dir == 1 || dir == 2 ? crumbled_border_size_var : TILESIZE_VAR);
2214 height = (dir == 0 || dir == 3 ? crumbled_border_size_var : TILESIZE_VAR);
2215 cx = (dir == 2 ? crumbled_border_pos_var : 0);
2216 cy = (dir == 3 ? crumbled_border_pos_var : 0);
2218 if (game.use_masked_elements)
2220 BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
2222 FX + sx * TILEX_VAR + cx,
2223 FY + sy * TILEY_VAR + cy);
2225 BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2227 FX + sx * TILEX_VAR + cx,
2228 FY + sy * TILEY_VAR + cy);
2231 BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2233 FX + sx * TILEX_VAR + cx,
2234 FY + sy * TILEY_VAR + cy);
2236 // (remaining middle border part must be at least as big as corner part)
2237 if (!(graphic_info[graphic].style & STYLE_ACCURATE_BORDERS) ||
2238 crumbled_border_size_var >= TILESIZE_VAR / 3)
2241 // correct corners of crumbled border, if needed
2243 for (i = -1; i <= 1; i += 2)
2245 int xx = x + (dir == 0 || dir == 3 ? i : 0);
2246 int yy = y + (dir == 1 || dir == 2 ? i : 0);
2247 int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2250 // check if neighbour field is of same crumble type
2251 if (IS_CRUMBLED_TILE(xx, yy, element) &&
2252 graphic_info[graphic].class ==
2253 graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2255 // no crumbled corner, but continued crumbled border
2257 int c1 = (dir == 2 || dir == 3 ? crumbled_border_pos_var : 0);
2258 int c2 = (i == 1 ? crumbled_border_pos_var : 0);
2259 int b1 = (i == 1 ? crumbled_border_size_var :
2260 TILESIZE_VAR - 2 * crumbled_border_size_var);
2262 width = crumbled_border_size_var;
2263 height = crumbled_border_size_var;
2265 if (dir == 1 || dir == 2)
2280 if (game.use_masked_elements)
2282 BlitBitmap(src_bitmap0, drawto_field, src_x0 + bx, src_y0 + by,
2284 FX + sx * TILEX_VAR + cx,
2285 FY + sy * TILEY_VAR + cy);
2287 BlitBitmapMasked(src_bitmap, drawto_field, src_x + bx, src_y + by,
2289 FX + sx * TILEX_VAR + cx,
2290 FY + sy * TILEY_VAR + cy);
2293 BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
2295 FX + sx * TILEX_VAR + cx,
2296 FY + sy * TILEY_VAR + cy);
2301 static void DrawLevelFieldCrumbledExt(int x, int y, int graphic, int frame)
2303 int sx = SCREENX(x), sy = SCREENY(y);
2306 struct XY *xy = xy_topdown;
2308 if (!IN_LEV_FIELD(x, y))
2311 element = TILE_GFX_ELEMENT(x, y);
2313 if (IS_CRUMBLED_TILE(x, y, element)) // crumble field itself
2315 if (!IN_SCR_FIELD(sx, sy))
2318 // crumble field borders towards direct neighbour fields
2319 for (i = 0; i < 4; i++)
2321 int xx = x + xy[i].x;
2322 int yy = y + xy[i].y;
2324 element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2327 // check if neighbour field is of same crumble type
2328 if (IS_CRUMBLED_TILE(xx, yy, element) &&
2329 graphic_info[graphic].class ==
2330 graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2333 DrawLevelFieldCrumbledBorders(x, y, graphic, frame, i);
2336 // crumble inner field corners towards corner neighbour fields
2337 if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2338 graphic_info[graphic].anim_frames == 2)
2340 for (i = 0; i < 4; i++)
2342 int dx = (i & 1 ? +1 : -1);
2343 int dy = (i & 2 ? +1 : -1);
2345 DrawLevelFieldCrumbledInnerCorners(x, y, dx, dy, graphic);
2349 MarkTileDirty(sx, sy);
2351 else // center field is not crumbled -- crumble neighbour fields
2353 // crumble field borders of direct neighbour fields
2354 for (i = 0; i < 4; i++)
2356 int xx = x + xy[i].x;
2357 int yy = y + xy[i].y;
2358 int sxx = sx + xy[i].x;
2359 int syy = sy + xy[i].y;
2361 if (!IN_LEV_FIELD(xx, yy) ||
2362 !IN_SCR_FIELD(sxx, syy))
2365 // do not crumble fields that are being digged or snapped
2366 if (Tile[xx][yy] == EL_EMPTY ||
2367 Tile[xx][yy] == EL_ELEMENT_SNAPPING)
2370 element = TILE_GFX_ELEMENT(xx, yy);
2372 if (!IS_CRUMBLED_TILE(xx, yy, element))
2375 graphic = el_act2crm(element, ACTION_DEFAULT);
2377 DrawLevelFieldCrumbledBorders(xx, yy, graphic, 0, 3 - i);
2379 MarkTileDirty(sxx, syy);
2382 // crumble inner field corners of corner neighbour fields
2383 for (i = 0; i < 4; i++)
2385 int dx = (i & 1 ? +1 : -1);
2386 int dy = (i & 2 ? +1 : -1);
2392 if (!IN_LEV_FIELD(xx, yy) ||
2393 !IN_SCR_FIELD(sxx, syy))
2396 if (Tile[xx][yy] == EL_ELEMENT_SNAPPING)
2399 element = TILE_GFX_ELEMENT(xx, yy);
2401 if (!IS_CRUMBLED_TILE(xx, yy, element))
2404 graphic = el_act2crm(element, ACTION_DEFAULT);
2406 if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2407 graphic_info[graphic].anim_frames == 2)
2408 DrawLevelFieldCrumbledInnerCorners(xx, yy, -dx, -dy, graphic);
2410 MarkTileDirty(sxx, syy);
2415 void DrawLevelFieldCrumbled(int x, int y)
2419 if (!IN_LEV_FIELD(x, y))
2422 if (Tile[x][y] == EL_ELEMENT_SNAPPING &&
2423 GfxElement[x][y] != EL_UNDEFINED &&
2424 GFX_CRUMBLED(GfxElement[x][y]))
2426 DrawLevelFieldCrumbledDigging(x, y, GfxDir[x][y], GfxFrame[x][y]);
2431 graphic = el_act2crm(TILE_GFX_ELEMENT(x, y), ACTION_DEFAULT);
2433 DrawLevelFieldCrumbledExt(x, y, graphic, 0);
2436 void DrawLevelFieldCrumbledDigging(int x, int y, int direction,
2439 int graphic1 = el_act_dir2img(GfxElement[x][y], ACTION_DIGGING, direction);
2440 int graphic2 = el_act_dir2crm(GfxElement[x][y], ACTION_DIGGING, direction);
2441 int frame1 = getGraphicAnimationFrame(graphic1, step_frame);
2442 int frame2 = getGraphicAnimationFrame(graphic2, step_frame);
2443 int sx = SCREENX(x), sy = SCREENY(y);
2445 DrawScreenGraphic(sx, sy, graphic1, frame1);
2446 DrawLevelFieldCrumbledExt(x, y, graphic2, frame2);
2449 void DrawLevelFieldCrumbledNeighbours(int x, int y)
2451 int sx = SCREENX(x), sy = SCREENY(y);
2452 struct XY *xy = xy_topdown;
2455 // crumble direct neighbour fields (required for field borders)
2456 for (i = 0; i < 4; i++)
2458 int xx = x + xy[i].x;
2459 int yy = y + xy[i].y;
2460 int sxx = sx + xy[i].x;
2461 int syy = sy + xy[i].y;
2463 if (!IN_LEV_FIELD(xx, yy) ||
2464 !IN_SCR_FIELD(sxx, syy) ||
2465 !GFX_CRUMBLED(Tile[xx][yy]) ||
2469 DrawLevelField(xx, yy);
2472 // crumble corner neighbour fields (required for inner field corners)
2473 for (i = 0; i < 4; i++)
2475 int dx = (i & 1 ? +1 : -1);
2476 int dy = (i & 2 ? +1 : -1);
2482 if (!IN_LEV_FIELD(xx, yy) ||
2483 !IN_SCR_FIELD(sxx, syy) ||
2484 !GFX_CRUMBLED(Tile[xx][yy]) ||
2488 int element = TILE_GFX_ELEMENT(xx, yy);
2489 int graphic = el_act2crm(element, ACTION_DEFAULT);
2491 if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2492 graphic_info[graphic].anim_frames == 2)
2493 DrawLevelField(xx, yy);
2497 static int getBorderElement(int x, int y)
2501 { EL_STEELWALL_TOPLEFT, EL_INVISIBLE_STEELWALL_TOPLEFT },
2502 { EL_STEELWALL_TOPRIGHT, EL_INVISIBLE_STEELWALL_TOPRIGHT },
2503 { EL_STEELWALL_BOTTOMLEFT, EL_INVISIBLE_STEELWALL_BOTTOMLEFT },
2504 { EL_STEELWALL_BOTTOMRIGHT, EL_INVISIBLE_STEELWALL_BOTTOMRIGHT },
2505 { EL_STEELWALL_VERTICAL, EL_INVISIBLE_STEELWALL_VERTICAL },
2506 { EL_STEELWALL_HORIZONTAL, EL_INVISIBLE_STEELWALL_HORIZONTAL },
2507 { EL_STEELWALL, EL_INVISIBLE_STEELWALL }
2509 int steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
2510 int steel_position = (x == -1 && y == -1 ? 0 :
2511 x == lev_fieldx && y == -1 ? 1 :
2512 x == -1 && y == lev_fieldy ? 2 :
2513 x == lev_fieldx && y == lev_fieldy ? 3 :
2514 x == -1 || x == lev_fieldx ? 4 :
2515 y == -1 || y == lev_fieldy ? 5 : 6);
2517 return border[steel_position][steel_type];
2520 void DrawScreenGraphic(int x, int y, int graphic, int frame)
2522 if (game.use_masked_elements)
2524 if (graphic != el2img(EL_EMPTY))
2525 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
2527 DrawGraphicThruMask(x, y, graphic, frame);
2531 DrawGraphic(x, y, graphic, frame);
2535 void DrawLevelGraphic(int x, int y, int graphic, int frame)
2537 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
2540 void DrawScreenElement(int x, int y, int element)
2542 int mask_mode = NO_MASKING;
2544 if (game.use_masked_elements)
2546 int lx = LEVELX(x), ly = LEVELY(y);
2548 if (IN_LEV_FIELD(lx, ly) && element != EL_EMPTY)
2550 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
2552 mask_mode = USE_MASKING;
2556 DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, mask_mode);
2557 DrawLevelFieldCrumbled(LEVELX(x), LEVELY(y));
2560 void DrawLevelElement(int x, int y, int element)
2562 if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2563 DrawScreenElement(SCREENX(x), SCREENY(y), element);
2566 void DrawScreenField(int x, int y)
2568 int lx = LEVELX(x), ly = LEVELY(y);
2569 int element, content;
2571 if (!IN_LEV_FIELD(lx, ly))
2573 if (lx < -1 || lx > lev_fieldx || ly < -1 || ly > lev_fieldy)
2576 element = getBorderElement(lx, ly);
2578 DrawScreenElement(x, y, element);
2583 element = Tile[lx][ly];
2584 content = Store[lx][ly];
2586 if (IS_MOVING(lx, ly))
2588 int horiz_move = (MovDir[lx][ly] == MV_LEFT || MovDir[lx][ly] == MV_RIGHT);
2589 boolean cut_mode = NO_CUTTING;
2591 if (element == EL_QUICKSAND_EMPTYING ||
2592 element == EL_QUICKSAND_FAST_EMPTYING ||
2593 element == EL_MAGIC_WALL_EMPTYING ||
2594 element == EL_BD_MAGIC_WALL_EMPTYING ||
2595 element == EL_DC_MAGIC_WALL_EMPTYING ||
2596 element == EL_AMOEBA_DROPPING)
2597 cut_mode = CUT_ABOVE;
2598 else if (element == EL_QUICKSAND_FILLING ||
2599 element == EL_QUICKSAND_FAST_FILLING ||
2600 element == EL_MAGIC_WALL_FILLING ||
2601 element == EL_BD_MAGIC_WALL_FILLING ||
2602 element == EL_DC_MAGIC_WALL_FILLING)
2603 cut_mode = CUT_BELOW;
2605 if (cut_mode == CUT_ABOVE)
2606 DrawScreenElement(x, y, element);
2608 DrawScreenElement(x, y, EL_EMPTY);
2610 if (cut_mode != CUT_BELOW && game.use_masked_elements)
2612 int dir = MovDir[lx][ly];
2613 int newx = x + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2614 int newy = y + (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
2616 if (IN_SCR_FIELD(newx, newy))
2617 DrawScreenElement(newx, newy, EL_EMPTY);
2621 DrawScreenElementShifted(x, y, MovPos[lx][ly], 0, element, NO_CUTTING);
2622 else if (cut_mode == NO_CUTTING)
2623 DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
2626 DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
2628 if (cut_mode == CUT_BELOW &&
2629 IN_LEV_FIELD(lx, ly + 1) && IN_SCR_FIELD(x, y + 1))
2630 DrawLevelElement(lx, ly + 1, element);
2633 if (content == EL_ACID)
2635 int dir = MovDir[lx][ly];
2636 int newlx = lx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2637 int newly = ly + (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
2639 DrawLevelElementThruMask(newlx, newly, EL_ACID);
2641 // prevent target field from being drawn again (but without masking)
2642 // (this would happen if target field is scanned after moving element)
2643 Stop[newlx][newly] = TRUE;
2646 else if (IS_BLOCKED(lx, ly))
2651 boolean cut_mode = NO_CUTTING;
2652 int element_old, content_old;
2654 Blocked2Moving(lx, ly, &oldx, &oldy);
2657 horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
2658 MovDir[oldx][oldy] == MV_RIGHT);
2660 element_old = Tile[oldx][oldy];
2661 content_old = Store[oldx][oldy];
2663 if (element_old == EL_QUICKSAND_EMPTYING ||
2664 element_old == EL_QUICKSAND_FAST_EMPTYING ||
2665 element_old == EL_MAGIC_WALL_EMPTYING ||
2666 element_old == EL_BD_MAGIC_WALL_EMPTYING ||
2667 element_old == EL_DC_MAGIC_WALL_EMPTYING ||
2668 element_old == EL_AMOEBA_DROPPING)
2669 cut_mode = CUT_ABOVE;
2671 DrawScreenElement(x, y, EL_EMPTY);
2674 DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
2676 else if (cut_mode == NO_CUTTING)
2677 DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old,
2680 DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old,
2683 else if (IS_DRAWABLE(element))
2684 DrawScreenElement(x, y, element);
2686 DrawScreenElement(x, y, EL_EMPTY);
2689 void DrawLevelField(int x, int y)
2691 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2692 DrawScreenField(SCREENX(x), SCREENY(y));
2693 else if (IS_MOVING(x, y))
2697 Moving2Blocked(x, y, &newx, &newy);
2698 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
2699 DrawScreenField(SCREENX(newx), SCREENY(newy));
2701 else if (IS_BLOCKED(x, y))
2705 Blocked2Moving(x, y, &oldx, &oldy);
2706 if (IN_SCR_FIELD(SCREENX(oldx), SCREENY(oldy)))
2707 DrawScreenField(SCREENX(oldx), SCREENY(oldy));
2711 static void DrawSizedWallExt_MM(int dst_x, int dst_y, int element, int tilesize,
2712 int (*el2img_function)(int), boolean masked,
2713 int element_bits_draw)
2715 int element_base = map_mm_wall_element(element);
2716 int element_bits = (IS_DF_WALL(element) ?
2717 element - EL_DF_WALL_START :
2718 IS_MM_WALL(element) ?
2719 element - EL_MM_WALL_START : EL_EMPTY) & 0x000f;
2720 int graphic = el2img_function(element_base);
2721 int tilesize_draw = tilesize / 2;
2726 getSizedGraphicSource(graphic, 0, tilesize_draw, &src_bitmap, &src_x, &src_y);
2728 for (i = 0; i < 4; i++)
2730 int dst_draw_x = dst_x + (i % 2) * tilesize_draw;
2731 int dst_draw_y = dst_y + (i / 2) * tilesize_draw;
2733 if (!(element_bits_draw & (1 << i)))
2736 if (element_bits & (1 << i))
2739 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y,
2740 tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2742 BlitBitmap(src_bitmap, drawto, src_x, src_y,
2743 tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2748 ClearRectangle(drawto, dst_draw_x, dst_draw_y,
2749 tilesize_draw, tilesize_draw);
2754 void DrawSizedWallParts_MM(int x, int y, int element, int tilesize,
2755 boolean masked, int element_bits_draw)
2757 DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2758 element, tilesize, el2edimg, masked, element_bits_draw);
2761 static void DrawSizedWall_MM(int dst_x, int dst_y, int element, int tilesize,
2762 int (*el2img_function)(int))
2764 DrawSizedWallExt_MM(dst_x, dst_y, element, tilesize, el2img_function, FALSE,
2768 static void DrawSizedElementExt(int x, int y, int element, int tilesize,
2771 if (IS_MM_WALL(element))
2773 DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2774 element, tilesize, el2edimg, masked, 0x000f);
2778 int graphic = el2edimg(element);
2781 DrawSizedGraphicThruMask(x, y, graphic, 0, tilesize);
2783 DrawSizedGraphic(x, y, graphic, 0, tilesize);
2787 void DrawSizedElement(int x, int y, int element, int tilesize)
2789 DrawSizedElementExt(x, y, element, tilesize, FALSE);
2792 void DrawSizedElementThruMask(int x, int y, int element, int tilesize)
2794 DrawSizedElementExt(x, y, element, tilesize, TRUE);
2797 void DrawMiniElement(int x, int y, int element)
2801 graphic = el2edimg(element);
2802 DrawMiniGraphic(x, y, graphic);
2805 void DrawSizedElementOrWall(int sx, int sy, int scroll_x, int scroll_y,
2808 int x = sx + scroll_x, y = sy + scroll_y;
2810 if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2811 DrawSizedElement(sx, sy, EL_EMPTY, tilesize);
2812 else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2813 DrawSizedElement(sx, sy, Tile[x][y], tilesize);
2815 DrawSizedGraphic(sx, sy, el2edimg(getBorderElement(x, y)), 0, tilesize);
2818 void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
2820 int x = sx + scroll_x, y = sy + scroll_y;
2822 if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2823 DrawMiniElement(sx, sy, EL_EMPTY);
2824 else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2825 DrawMiniElement(sx, sy, Tile[x][y]);
2827 DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
2830 static void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
2831 int x, int y, int xsize, int ysize,
2832 int tile_width, int tile_height)
2836 int dst_x = startx + x * tile_width;
2837 int dst_y = starty + y * tile_height;
2838 int width = graphic_info[graphic].width;
2839 int height = graphic_info[graphic].height;
2840 int inner_width_raw = MAX(width - 2 * tile_width, tile_width);
2841 int inner_height_raw = MAX(height - 2 * tile_height, tile_height);
2842 int inner_width = inner_width_raw - (inner_width_raw % tile_width);
2843 int inner_height = inner_height_raw - (inner_height_raw % tile_height);
2844 int inner_sx = (width >= 3 * tile_width ? tile_width : 0);
2845 int inner_sy = (height >= 3 * tile_height ? tile_height : 0);
2846 boolean draw_masked = graphic_info[graphic].draw_masked;
2848 getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2850 if (src_bitmap == NULL || width < tile_width || height < tile_height)
2852 ClearRectangle(drawto, dst_x, dst_y, tile_width, tile_height);
2856 src_x += (x == 0 ? 0 : x == xsize - 1 ? width - tile_width :
2857 inner_sx + (x - 1) * tile_width % inner_width);
2858 src_y += (y == 0 ? 0 : y == ysize - 1 ? height - tile_height :
2859 inner_sy + (y - 1) * tile_height % inner_height);
2862 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2865 BlitBitmap(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2869 static void DrawEnvelopeBackground(int graphic, int startx, int starty,
2870 int x, int y, int xsize, int ysize,
2873 int font_width = getFontWidth(font_nr);
2874 int font_height = getFontHeight(font_nr);
2876 DrawEnvelopeBackgroundTiles(graphic, startx, starty, x, y, xsize, ysize,
2877 font_width, font_height);
2880 static void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
2882 int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2883 Bitmap *src_bitmap = graphic_info[graphic].bitmap;
2884 int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
2885 boolean ffwd_delay = (tape.playing && tape.fast_forward);
2886 boolean no_delay = (tape.warp_forward);
2887 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2888 int anim_delay_value = MAX(1, (no_delay ? 0 : frame_delay_value) / 2);
2889 DelayCounter anim_delay = { anim_delay_value };
2890 int font_nr = FONT_ENVELOPE_1 + envelope_nr;
2891 int font_width = getFontWidth(font_nr);
2892 int font_height = getFontHeight(font_nr);
2893 int max_xsize = level.envelope[envelope_nr].xsize;
2894 int max_ysize = level.envelope[envelope_nr].ysize;
2895 int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize : 0);
2896 int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize : 0);
2897 int xend = max_xsize;
2898 int yend = (anim_mode != ANIM_DEFAULT ? max_ysize : 0);
2899 int xstep = (xstart < xend ? 1 : 0);
2900 int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
2902 int end = MAX(xend - xstart, yend - ystart);
2905 for (i = start; i <= end; i++)
2907 int last_frame = end; // last frame of this "for" loop
2908 int x = xstart + i * xstep;
2909 int y = ystart + i * ystep;
2910 int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
2911 int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
2912 int sx = SX + (SXSIZE - xsize * font_width) / 2;
2913 int sy = SY + (SYSIZE - ysize * font_height) / 2;
2916 SetDrawtoField(DRAW_TO_FIELDBUFFER);
2918 BlitScreenToBitmap(backbuffer);
2920 SetDrawtoField(DRAW_TO_BACKBUFFER);
2922 for (yy = 0; yy < ysize; yy++)
2923 for (xx = 0; xx < xsize; xx++)
2924 DrawEnvelopeBackground(graphic, sx, sy, xx, yy, xsize, ysize, font_nr);
2926 DrawTextArea(sx + font_width, sy + font_height,
2927 level.envelope[envelope_nr].text, font_nr, max_xsize,
2928 xsize - 2, ysize - 2, 0, mask_mode,
2929 level.envelope[envelope_nr].autowrap,
2930 level.envelope[envelope_nr].centered, FALSE);
2932 redraw_mask |= REDRAW_FIELD;
2935 SkipUntilDelayReached(&anim_delay, &i, last_frame);
2938 ClearAutoRepeatKeyEvents();
2941 void ShowEnvelope(int envelope_nr)
2943 int element = EL_ENVELOPE_1 + envelope_nr;
2944 int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2945 int sound_opening = element_info[element].sound[ACTION_OPENING];
2946 int sound_closing = element_info[element].sound[ACTION_CLOSING];
2947 boolean ffwd_delay = (tape.playing && tape.fast_forward);
2948 boolean no_delay = (tape.warp_forward);
2949 int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
2950 int wait_delay_value = (no_delay ? 0 : normal_delay_value);
2951 int anim_mode = graphic_info[graphic].anim_mode;
2952 int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
2953 anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
2954 boolean overlay_enabled = GetOverlayEnabled();
2956 game.envelope_active = TRUE; // needed for RedrawPlayfield() events
2958 SetOverlayEnabled(FALSE);
2961 PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
2963 if (anim_mode == ANIM_DEFAULT)
2964 AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
2966 AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
2969 Delay_WithScreenUpdates(wait_delay_value);
2971 WaitForEventToContinue();
2974 SetOverlayEnabled(overlay_enabled);
2976 PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
2978 if (anim_mode != ANIM_NONE)
2979 AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
2981 if (anim_mode == ANIM_DEFAULT)
2982 AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
2984 game.envelope_active = FALSE;
2986 SetDrawtoField(DRAW_TO_FIELDBUFFER);
2988 redraw_mask |= REDRAW_FIELD;
2992 static void PrepareEnvelopeRequestToScreen(Bitmap *bitmap, int sx, int sy,
2993 int xsize, int ysize)
2995 if (!global.use_envelope_request ||
2996 request.sort_priority <= 0)
2999 if (request.bitmap == NULL ||
3000 xsize > request.xsize ||
3001 ysize > request.ysize)
3003 if (request.bitmap != NULL)
3004 FreeBitmap(request.bitmap);
3006 request.bitmap = CreateBitmap(xsize, ysize, DEFAULT_DEPTH);
3008 SDL_Surface *surface = request.bitmap->surface;
3010 if ((request.bitmap->surface_masked = SDLGetNativeSurface(surface)) == NULL)
3011 Fail("SDLGetNativeSurface() failed");
3014 BlitBitmap(bitmap, request.bitmap, sx, sy, xsize, ysize, 0, 0);
3016 SDLFreeBitmapTextures(request.bitmap);
3017 SDLCreateBitmapTextures(request.bitmap);
3019 // set envelope request run-time values
3022 request.xsize = xsize;
3023 request.ysize = ysize;
3026 void DrawEnvelopeRequestToScreen(int drawing_target, int drawing_stage)
3028 if (global.use_envelope_request &&
3029 game.request_active_or_moving &&
3030 request.sort_priority > 0 &&
3031 drawing_target == DRAW_TO_SCREEN &&
3032 drawing_stage == DRAW_GLOBAL_ANIM_STAGE_2)
3034 BlitToScreen(request.bitmap, 0, 0, request.xsize, request.ysize,
3035 request.sx, request.sy);
3039 static void setRequestBasePosition(int *x, int *y)
3041 int sx_base, sy_base;
3043 if (request.x != -1)
3044 sx_base = request.x;
3045 else if (request.align == ALIGN_LEFT)
3047 else if (request.align == ALIGN_RIGHT)
3048 sx_base = SX + SXSIZE;
3050 sx_base = SX + SXSIZE / 2;
3052 if (request.y != -1)
3053 sy_base = request.y;
3054 else if (request.valign == VALIGN_TOP)
3056 else if (request.valign == VALIGN_BOTTOM)
3057 sy_base = SY + SYSIZE;
3059 sy_base = SY + SYSIZE / 2;
3065 static void setRequestPositionExt(int *x, int *y, int width, int height,
3066 boolean add_border_size)
3068 int border_size = request.border_size;
3069 int sx_base, sy_base;
3072 setRequestBasePosition(&sx_base, &sy_base);
3074 if (request.align == ALIGN_LEFT)
3076 else if (request.align == ALIGN_RIGHT)
3077 sx = sx_base - width;
3079 sx = sx_base - width / 2;
3081 if (request.valign == VALIGN_TOP)
3083 else if (request.valign == VALIGN_BOTTOM)
3084 sy = sy_base - height;
3086 sy = sy_base - height / 2;
3088 sx = MAX(0, MIN(sx, WIN_XSIZE - width));
3089 sy = MAX(0, MIN(sy, WIN_YSIZE - height));
3091 if (add_border_size)
3101 static void setRequestPosition(int *x, int *y, boolean add_border_size)
3103 setRequestPositionExt(x, y, request.width, request.height, add_border_size);
3106 static void DrawEnvelopeRequest(char *text)
3108 char *text_final = text;
3109 char *text_door_style = NULL;
3110 int graphic = IMG_BACKGROUND_REQUEST;
3111 Bitmap *src_bitmap = graphic_info[graphic].bitmap;
3112 int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
3113 int font_nr = FONT_REQUEST;
3114 int font_width = getFontWidth(font_nr);
3115 int font_height = getFontHeight(font_nr);
3116 int border_size = request.border_size;
3117 int line_spacing = request.line_spacing;
3118 int line_height = font_height + line_spacing;
3119 int max_text_width = request.width - 2 * border_size;
3120 int max_text_height = request.height - 2 * border_size;
3121 int line_length = max_text_width / font_width;
3122 int max_lines = max_text_height / line_height;
3123 int text_width = line_length * font_width;
3124 int width = request.width;
3125 int height = request.height;
3126 int tile_size = MAX(request.step_offset, 1);
3127 int x_steps = width / tile_size;
3128 int y_steps = height / tile_size;
3129 int sx_offset = border_size;
3130 int sy_offset = border_size;
3134 if (request.centered)
3135 sx_offset = (request.width - text_width) / 2;
3137 if (request.wrap_single_words && !request.autowrap)
3139 char *src_text_ptr, *dst_text_ptr;
3141 text_door_style = checked_malloc(2 * strlen(text) + 1);
3143 src_text_ptr = text;
3144 dst_text_ptr = text_door_style;
3146 while (*src_text_ptr)
3148 if (*src_text_ptr == ' ' ||
3149 *src_text_ptr == '?' ||
3150 *src_text_ptr == '!')
3151 *dst_text_ptr++ = '\n';
3153 if (*src_text_ptr != ' ')
3154 *dst_text_ptr++ = *src_text_ptr;
3159 *dst_text_ptr = '\0';
3161 text_final = text_door_style;
3164 setRequestPosition(&sx, &sy, FALSE);
3166 ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
3168 for (y = 0; y < y_steps; y++)
3169 for (x = 0; x < x_steps; x++)
3170 DrawEnvelopeBackgroundTiles(graphic, sx, sy,
3171 x, y, x_steps, y_steps,
3172 tile_size, tile_size);
3174 // force DOOR font inside door area
3175 SetFontStatus(GAME_MODE_PSEUDO_DOOR);
3177 DrawTextBuffer(sx + sx_offset, sy + sy_offset, text_final, font_nr,
3178 line_length, -1, max_lines, line_spacing, mask_mode,
3179 request.autowrap, request.centered, FALSE);
3183 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
3184 RedrawGadget(tool_gadget[i]);
3186 // store readily prepared envelope request for later use when animating
3187 BlitBitmap(backbuffer, bitmap_db_store_2, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3189 PrepareEnvelopeRequestToScreen(bitmap_db_store_2, sx, sy, width, height);
3191 if (text_door_style)
3192 free(text_door_style);
3195 static void AnimateEnvelopeRequest(int anim_mode, int action)
3197 int graphic = IMG_BACKGROUND_REQUEST;
3198 boolean draw_masked = graphic_info[graphic].draw_masked;
3199 int delay_value_normal = request.step_delay;
3200 int delay_value_fast = delay_value_normal / 2;
3201 boolean ffwd_delay = (tape.playing && tape.fast_forward);
3202 boolean no_delay = (tape.warp_forward);
3203 int delay_value = (ffwd_delay ? delay_value_fast : delay_value_normal);
3204 int anim_delay_value = MAX(1, (no_delay ? 0 : delay_value + 500 * 0) / 2);
3205 DelayCounter anim_delay = { anim_delay_value };
3207 int tile_size = MAX(request.step_offset, 1);
3208 int max_xsize = request.width / tile_size;
3209 int max_ysize = request.height / tile_size;
3210 int max_xsize_inner = max_xsize - 2;
3211 int max_ysize_inner = max_ysize - 2;
3213 int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize_inner : 0);
3214 int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize_inner : 0);
3215 int xend = max_xsize_inner;
3216 int yend = (anim_mode != ANIM_DEFAULT ? max_ysize_inner : 0);
3217 int xstep = (xstart < xend ? 1 : 0);
3218 int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
3220 int end = MAX(xend - xstart, yend - ystart);
3223 if (setup.quick_doors)
3230 for (i = start; i <= end; i++)
3232 int last_frame = end; // last frame of this "for" loop
3233 int x = xstart + i * xstep;
3234 int y = ystart + i * ystep;
3235 int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
3236 int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
3237 int xsize_size_left = (xsize - 1) * tile_size;
3238 int ysize_size_top = (ysize - 1) * tile_size;
3239 int max_xsize_pos = (max_xsize - 1) * tile_size;
3240 int max_ysize_pos = (max_ysize - 1) * tile_size;
3241 int width = xsize * tile_size;
3242 int height = ysize * tile_size;
3247 setRequestPosition(&src_x, &src_y, FALSE);
3248 setRequestPositionExt(&dst_x, &dst_y, width, height, FALSE);
3250 BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3252 for (yy = 0; yy < 2; yy++)
3254 for (xx = 0; xx < 2; xx++)
3256 int src_xx = src_x + xx * max_xsize_pos;
3257 int src_yy = src_y + yy * max_ysize_pos;
3258 int dst_xx = dst_x + xx * xsize_size_left;
3259 int dst_yy = dst_y + yy * ysize_size_top;
3260 int xx_size = (xx ? tile_size : xsize_size_left);
3261 int yy_size = (yy ? tile_size : ysize_size_top);
3264 BlitBitmapMasked(bitmap_db_store_2, backbuffer,
3265 src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
3267 BlitBitmap(bitmap_db_store_2, backbuffer,
3268 src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
3272 PrepareEnvelopeRequestToScreen(backbuffer, dst_x, dst_y, width, height);
3274 redraw_mask |= REDRAW_FIELD;
3278 SkipUntilDelayReached(&anim_delay, &i, last_frame);
3281 ClearAutoRepeatKeyEvents();
3284 static void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
3286 int graphic = IMG_BACKGROUND_REQUEST;
3287 int sound_opening = SND_REQUEST_OPENING;
3288 int sound_closing = SND_REQUEST_CLOSING;
3289 int anim_mode_1 = request.anim_mode; // (higher priority)
3290 int anim_mode_2 = graphic_info[graphic].anim_mode; // (lower priority)
3291 int anim_mode = (anim_mode_1 != ANIM_DEFAULT ? anim_mode_1 : anim_mode_2);
3292 int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
3293 anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
3295 if (game_status == GAME_MODE_PLAYING)
3296 BlitScreenToBitmap(backbuffer);
3298 SetDrawtoField(DRAW_TO_BACKBUFFER);
3300 // SetDrawBackgroundMask(REDRAW_NONE);
3302 if (action == ACTION_OPENING)
3304 BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3306 if (req_state & REQ_ASK)
3308 MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
3309 MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
3310 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_YES]);
3311 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_NO]);
3313 else if (req_state & REQ_CONFIRM)
3315 MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
3316 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_CONFIRM]);
3318 else if (req_state & REQ_PLAYER)
3320 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
3321 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
3322 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
3323 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
3326 DrawEnvelopeRequest(text);
3329 game.envelope_active = TRUE; // needed for RedrawPlayfield() events
3331 if (action == ACTION_OPENING)
3333 PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
3335 if (anim_mode == ANIM_DEFAULT)
3336 AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
3338 AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
3342 PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
3344 if (anim_mode != ANIM_NONE)
3345 AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
3347 if (anim_mode == ANIM_DEFAULT)
3348 AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
3351 game.envelope_active = FALSE;
3353 if (action == ACTION_CLOSING)
3354 BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
3356 // SetDrawBackgroundMask(last_draw_background_mask);
3358 redraw_mask |= REDRAW_FIELD;
3362 if (action == ACTION_CLOSING &&
3363 game_status == GAME_MODE_PLAYING &&
3364 level.game_engine_type == GAME_ENGINE_TYPE_RND)
3365 SetDrawtoField(DRAW_TO_FIELDBUFFER);
3368 static void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
3370 if (IS_MM_WALL(element))
3372 DrawSizedWall_MM(dst_x, dst_y, element, tilesize, el2preimg);
3378 int graphic = el2preimg(element);
3380 getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
3381 BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize,
3386 void DrawLevel(int draw_background_mask)
3390 SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
3391 SetDrawBackgroundMask(draw_background_mask);
3395 for (x = BX1; x <= BX2; x++)
3396 for (y = BY1; y <= BY2; y++)
3397 DrawScreenField(x, y);
3399 redraw_mask |= REDRAW_FIELD;
3402 void DrawSizedLevel(int size_x, int size_y, int scroll_x, int scroll_y,
3407 for (x = 0; x < size_x; x++)
3408 for (y = 0; y < size_y; y++)
3409 DrawSizedElementOrWall(x, y, scroll_x, scroll_y, tilesize);
3411 redraw_mask |= REDRAW_FIELD;
3414 void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
3418 for (x = 0; x < size_x; x++)
3419 for (y = 0; y < size_y; y++)
3420 DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
3422 redraw_mask |= REDRAW_FIELD;
3425 static void DrawPreviewLevelPlayfield(int from_x, int from_y)
3427 boolean show_level_border = (BorderElement != EL_EMPTY);
3428 int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3429 int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3430 int tile_size = preview.tile_size;
3431 int preview_width = preview.xsize * tile_size;
3432 int preview_height = preview.ysize * tile_size;
3433 int real_preview_xsize = MIN(level_xsize, preview.xsize);
3434 int real_preview_ysize = MIN(level_ysize, preview.ysize);
3435 int real_preview_width = real_preview_xsize * tile_size;
3436 int real_preview_height = real_preview_ysize * tile_size;
3437 int dst_x = SX + ALIGNED_XPOS(preview.x, preview_width, preview.align);
3438 int dst_y = SY + ALIGNED_YPOS(preview.y, preview_height, preview.valign);
3441 if (!IN_GFX_FIELD_FULL(dst_x, dst_y + preview_height - 1))
3444 DrawBackground(dst_x, dst_y, preview_width, preview_height);
3446 dst_x += (preview_width - real_preview_width) / 2;
3447 dst_y += (preview_height - real_preview_height) / 2;
3449 for (x = 0; x < real_preview_xsize; x++)
3451 for (y = 0; y < real_preview_ysize; y++)
3453 int lx = from_x + x + (show_level_border ? -1 : 0);
3454 int ly = from_y + y + (show_level_border ? -1 : 0);
3455 int element = (IN_LEV_FIELD(lx, ly) ? level.field[lx][ly] :
3456 getBorderElement(lx, ly));
3458 DrawPreviewElement(dst_x + x * tile_size, dst_y + y * tile_size,
3459 element, tile_size);
3463 redraw_mask |= REDRAW_FIELD;
3466 #define MICROLABEL_EMPTY 0
3467 #define MICROLABEL_LEVEL_NAME 1
3468 #define MICROLABEL_LEVEL_AUTHOR_HEAD 2
3469 #define MICROLABEL_LEVEL_AUTHOR 3
3470 #define MICROLABEL_IMPORTED_FROM_HEAD 4
3471 #define MICROLABEL_IMPORTED_FROM 5
3472 #define MICROLABEL_IMPORTED_BY_HEAD 6
3473 #define MICROLABEL_IMPORTED_BY 7
3475 static int getMaxTextLength(struct TextPosInfo *pos, int font_nr)
3477 int max_text_width = SXSIZE;
3478 int font_width = getFontWidth(font_nr);
3480 if (pos->align == ALIGN_CENTER)
3481 max_text_width = (pos->x < SXSIZE / 2 ? pos->x * 2 : (SXSIZE - pos->x) * 2);
3482 else if (pos->align == ALIGN_RIGHT)
3483 max_text_width = pos->x;
3485 max_text_width = SXSIZE - pos->x;
3487 return max_text_width / font_width;
3490 static void DrawPreviewLevelLabelExt(int mode, struct TextPosInfo *pos)
3492 char label_text[MAX_OUTPUT_LINESIZE + 1];
3493 int max_len_label_text;
3494 int font_nr = pos->font;
3497 if (!IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3500 if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
3501 mode == MICROLABEL_IMPORTED_FROM_HEAD ||
3502 mode == MICROLABEL_IMPORTED_BY_HEAD)
3503 font_nr = pos->font_alt;
3505 max_len_label_text = getMaxTextLength(pos, font_nr);
3507 if (pos->size != -1)
3508 max_len_label_text = pos->size;
3510 for (i = 0; i < max_len_label_text; i++)
3511 label_text[i] = ' ';
3512 label_text[max_len_label_text] = '\0';
3514 if (strlen(label_text) > 0)
3515 DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3518 (mode == MICROLABEL_LEVEL_NAME ? level.name :
3519 mode == MICROLABEL_LEVEL_AUTHOR_HEAD ? "created by" :
3520 mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
3521 mode == MICROLABEL_IMPORTED_FROM_HEAD ? "imported from" :
3522 mode == MICROLABEL_IMPORTED_FROM ? leveldir_current->imported_from :
3523 mode == MICROLABEL_IMPORTED_BY_HEAD ? "imported by" :
3524 mode == MICROLABEL_IMPORTED_BY ? leveldir_current->imported_by :""),
3525 max_len_label_text);
3526 label_text[max_len_label_text] = '\0';
3528 if (strlen(label_text) > 0)
3529 DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3531 redraw_mask |= REDRAW_FIELD;
3534 static void DrawPreviewLevelLabel(int mode)
3536 DrawPreviewLevelLabelExt(mode, &menu.main.text.level_info_2);
3539 static void DrawPreviewLevelInfo(int mode)
3541 if (mode == MICROLABEL_LEVEL_NAME)
3542 DrawPreviewLevelLabelExt(mode, &menu.main.text.level_name);
3543 else if (mode == MICROLABEL_LEVEL_AUTHOR)
3544 DrawPreviewLevelLabelExt(mode, &menu.main.text.level_author);
3547 static void DrawPreviewLevelExt(boolean restart)
3549 static DelayCounter scroll_delay = { 0 };
3550 static DelayCounter label_delay = { 0 };
3551 static int from_x, from_y, scroll_direction;
3552 static int label_state, label_counter;
3553 boolean show_level_border = (BorderElement != EL_EMPTY);
3554 int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3555 int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3557 scroll_delay.value = preview.step_delay;
3558 label_delay.value = MICROLEVEL_LABEL_DELAY;
3565 if (preview.anim_mode == ANIM_CENTERED)
3567 if (level_xsize > preview.xsize)
3568 from_x = (level_xsize - preview.xsize) / 2;
3569 if (level_ysize > preview.ysize)
3570 from_y = (level_ysize - preview.ysize) / 2;
3573 from_x += preview.xoffset;
3574 from_y += preview.yoffset;
3576 scroll_direction = MV_RIGHT;
3580 DrawPreviewLevelPlayfield(from_x, from_y);
3581 DrawPreviewLevelLabel(label_state);
3583 DrawPreviewLevelInfo(MICROLABEL_LEVEL_NAME);
3584 DrawPreviewLevelInfo(MICROLABEL_LEVEL_AUTHOR);
3586 // initialize delay counters
3587 ResetDelayCounter(&scroll_delay);
3588 ResetDelayCounter(&label_delay);
3590 if (leveldir_current->name)
3592 struct TextPosInfo *pos = &menu.main.text.level_info_1;
3593 char label_text[MAX_OUTPUT_LINESIZE + 1];
3594 int font_nr = pos->font;
3595 int max_len_label_text = getMaxTextLength(pos, font_nr);
3597 if (pos->size != -1)
3598 max_len_label_text = pos->size;
3600 strncpy(label_text, leveldir_current->name, max_len_label_text);
3601 label_text[max_len_label_text] = '\0';
3603 if (IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3604 DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3610 // scroll preview level, if needed
3611 if (preview.anim_mode != ANIM_NONE &&
3612 (level_xsize > preview.xsize || level_ysize > preview.ysize) &&
3613 DelayReached(&scroll_delay))
3615 switch (scroll_direction)
3620 from_x -= preview.step_offset;
3621 from_x = (from_x < 0 ? 0 : from_x);
3624 scroll_direction = MV_UP;
3628 if (from_x < level_xsize - preview.xsize)
3630 from_x += preview.step_offset;
3631 from_x = (from_x > level_xsize - preview.xsize ?
3632 level_xsize - preview.xsize : from_x);
3635 scroll_direction = MV_DOWN;
3641 from_y -= preview.step_offset;
3642 from_y = (from_y < 0 ? 0 : from_y);
3645 scroll_direction = MV_RIGHT;
3649 if (from_y < level_ysize - preview.ysize)
3651 from_y += preview.step_offset;
3652 from_y = (from_y > level_ysize - preview.ysize ?
3653 level_ysize - preview.ysize : from_y);
3656 scroll_direction = MV_LEFT;
3663 DrawPreviewLevelPlayfield(from_x, from_y);
3666 // !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!!
3667 // redraw micro level label, if needed
3668 if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
3669 !strEqual(level.author, ANONYMOUS_NAME) &&
3670 !strEqual(level.author, leveldir_current->name) &&
3671 DelayReached(&label_delay))
3673 int max_label_counter = 23;
3675 if (leveldir_current->imported_from != NULL &&
3676 strlen(leveldir_current->imported_from) > 0)
3677 max_label_counter += 14;
3678 if (leveldir_current->imported_by != NULL &&
3679 strlen(leveldir_current->imported_by) > 0)
3680 max_label_counter += 14;
3682 label_counter = (label_counter + 1) % max_label_counter;
3683 label_state = (label_counter >= 0 && label_counter <= 7 ?
3684 MICROLABEL_LEVEL_NAME :
3685 label_counter >= 9 && label_counter <= 12 ?
3686 MICROLABEL_LEVEL_AUTHOR_HEAD :
3687 label_counter >= 14 && label_counter <= 21 ?
3688 MICROLABEL_LEVEL_AUTHOR :
3689 label_counter >= 23 && label_counter <= 26 ?
3690 MICROLABEL_IMPORTED_FROM_HEAD :
3691 label_counter >= 28 && label_counter <= 35 ?
3692 MICROLABEL_IMPORTED_FROM :
3693 label_counter >= 37 && label_counter <= 40 ?
3694 MICROLABEL_IMPORTED_BY_HEAD :
3695 label_counter >= 42 && label_counter <= 49 ?
3696 MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
3698 if (leveldir_current->imported_from == NULL &&
3699 (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
3700 label_state == MICROLABEL_IMPORTED_FROM))
3701 label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
3702 MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
3704 DrawPreviewLevelLabel(label_state);
3708 void DrawPreviewPlayers(void)
3710 if (game_status != GAME_MODE_MAIN)
3713 // do not draw preview players if level preview redefined, but players aren't
3714 if (preview.redefined && !menu.main.preview_players.redefined)
3717 boolean player_found[MAX_PLAYERS];
3718 int num_players = 0;
3721 for (i = 0; i < MAX_PLAYERS; i++)
3722 player_found[i] = FALSE;
3724 // check which players can be found in the level (simple approach)
3725 for (x = 0; x < lev_fieldx; x++)
3727 for (y = 0; y < lev_fieldy; y++)
3729 int element = level.field[x][y];
3731 if (IS_PLAYER_ELEMENT(element))
3733 int player_nr = GET_PLAYER_NR(element);
3735 player_nr = MIN(MAX(0, player_nr), MAX_PLAYERS - 1);
3737 if (!player_found[player_nr])
3740 player_found[player_nr] = TRUE;
3745 struct TextPosInfo *pos = &menu.main.preview_players;
3746 int tile_size = pos->tile_size;
3747 int border_size = pos->border_size;
3748 int player_xoffset_raw = (pos->vertical ? 0 : tile_size + border_size);
3749 int player_yoffset_raw = (pos->vertical ? tile_size + border_size : 0);
3750 int player_xoffset = (pos->xoffset != -1 ? pos->xoffset : player_xoffset_raw);
3751 int player_yoffset = (pos->yoffset != -1 ? pos->yoffset : player_yoffset_raw);
3752 int max_players_width = (MAX_PLAYERS - 1) * player_xoffset + tile_size;
3753 int max_players_height = (MAX_PLAYERS - 1) * player_yoffset + tile_size;
3754 int all_players_width = (num_players - 1) * player_xoffset + tile_size;
3755 int all_players_height = (num_players - 1) * player_yoffset + tile_size;
3756 int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width, pos->align);
3757 int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
3758 int xpos = SX + ALIGNED_XPOS(pos->x, all_players_width, pos->align);
3759 int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
3761 // clear area in which the players will be drawn
3762 ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
3763 max_players_width, max_players_height);
3765 if (!network.enabled && !setup.team_mode)
3768 // only draw players if level is suited for team mode
3769 if (num_players < 2)
3772 // draw all players that were found in the level
3773 for (i = 0; i < MAX_PLAYERS; i++)
3775 if (player_found[i])
3777 int graphic = el2img(EL_PLAYER_1 + i);
3779 DrawSizedGraphicThruMaskExt(drawto, xpos, ypos, graphic, 0, tile_size);
3781 xpos += player_xoffset;
3782 ypos += player_yoffset;
3787 void DrawPreviewLevelInitial(void)
3789 DrawPreviewLevelExt(TRUE);
3790 DrawPreviewPlayers();
3793 void DrawPreviewLevelAnimation(void)
3795 DrawPreviewLevelExt(FALSE);
3798 static void DrawNetworkPlayer(int x, int y, int player_nr, int tile_size,
3799 int border_size, int font_nr)
3801 int graphic = el2img(EL_PLAYER_1 + player_nr);
3802 int font_height = getFontHeight(font_nr);
3803 int player_height = MAX(tile_size, font_height);
3804 int xoffset_text = tile_size + border_size;
3805 int yoffset_text = (player_height - font_height) / 2;
3806 int yoffset_graphic = (player_height - tile_size) / 2;
3807 char *player_name = getNetworkPlayerName(player_nr + 1);
3809 DrawSizedGraphicThruMaskExt(drawto, x, y + yoffset_graphic, graphic, 0,
3811 DrawText(x + xoffset_text, y + yoffset_text, player_name, font_nr);
3814 static void DrawNetworkPlayersExt(boolean force)
3816 if (game_status != GAME_MODE_MAIN)
3819 if (!network.connected && !force)
3822 // do not draw network players if level preview redefined, but players aren't
3823 if (preview.redefined && !menu.main.network_players.redefined)
3826 int num_players = 0;
3829 for (i = 0; i < MAX_PLAYERS; i++)
3830 if (stored_player[i].connected_network)
3833 struct TextPosInfo *pos = &menu.main.network_players;
3834 int tile_size = pos->tile_size;
3835 int border_size = pos->border_size;
3836 int xoffset_text = tile_size + border_size;
3837 int font_nr = pos->font;
3838 int font_width = getFontWidth(font_nr);
3839 int font_height = getFontHeight(font_nr);
3840 int player_height = MAX(tile_size, font_height);
3841 int player_yoffset = player_height + border_size;
3842 int max_players_width = xoffset_text + MAX_PLAYER_NAME_LEN * font_width;
3843 int max_players_height = MAX_PLAYERS * player_yoffset - border_size;
3844 int all_players_height = num_players * player_yoffset - border_size;
3845 int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width, pos->align);
3846 int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
3847 int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
3849 ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
3850 max_players_width, max_players_height);
3852 // first draw local network player ...
3853 for (i = 0; i < MAX_PLAYERS; i++)
3855 if (stored_player[i].connected_network &&
3856 stored_player[i].connected_locally)
3858 char *player_name = getNetworkPlayerName(i + 1);
3859 int player_width = xoffset_text + getTextWidth(player_name, font_nr);
3860 int xpos = SX + ALIGNED_XPOS(pos->x, player_width, pos->align);
3862 DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
3864 ypos += player_yoffset;
3868 // ... then draw all other network players
3869 for (i = 0; i < MAX_PLAYERS; i++)
3871 if (stored_player[i].connected_network &&
3872 !stored_player[i].connected_locally)
3874 char *player_name = getNetworkPlayerName(i + 1);
3875 int player_width = xoffset_text + getTextWidth(player_name, font_nr);
3876 int xpos = SX + ALIGNED_XPOS(pos->x, player_width, pos->align);
3878 DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
3880 ypos += player_yoffset;
3885 void DrawNetworkPlayers(void)
3887 DrawNetworkPlayersExt(FALSE);
3890 void ClearNetworkPlayers(void)
3892 DrawNetworkPlayersExt(TRUE);
3895 static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3896 int graphic, int lx, int ly,
3899 int frame = getGraphicAnimationFrameXY(graphic, lx, ly);
3901 if (mask_mode == USE_MASKING)
3902 DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3904 DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
3907 void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3908 int graphic, int sync_frame, int mask_mode)
3910 int frame = getGraphicAnimationFrame(graphic, sync_frame);
3912 if (mask_mode == USE_MASKING)
3913 DrawFixedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3915 DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame);
3918 static void DrawGraphicAnimation(int x, int y, int graphic)
3920 int lx = LEVELX(x), ly = LEVELY(y);
3921 int mask_mode = NO_MASKING;
3923 if (!IN_SCR_FIELD(x, y))
3926 if (game.use_masked_elements)
3928 if (Tile[lx][ly] != EL_EMPTY)
3930 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
3932 mask_mode = USE_MASKING;
3936 DrawGraphicAnimationExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
3937 graphic, lx, ly, mask_mode);
3939 MarkTileDirty(x, y);
3942 void DrawFixedGraphicAnimation(int x, int y, int graphic)
3944 int lx = LEVELX(x), ly = LEVELY(y);
3945 int mask_mode = NO_MASKING;
3947 if (!IN_SCR_FIELD(x, y))
3950 if (game.use_masked_elements)
3952 if (Tile[lx][ly] != EL_EMPTY)
3954 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
3956 mask_mode = USE_MASKING;
3960 DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
3961 graphic, lx, ly, mask_mode);
3963 MarkTileDirty(x, y);
3966 void DrawLevelGraphicAnimation(int x, int y, int graphic)
3968 DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3971 void DrawLevelElementAnimation(int x, int y, int element)
3973 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
3975 DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
3978 void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
3980 int sx = SCREENX(x), sy = SCREENY(y);
3982 if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
3985 if (Tile[x][y] == EL_EMPTY)
3986 graphic = el2img(GfxElementEmpty[x][y]);
3988 if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
3991 if (ANIM_MODE(graphic) & (ANIM_TILED | ANIM_RANDOM_STATIC))
3994 DrawGraphicAnimation(sx, sy, graphic);
3997 if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
3998 DrawLevelFieldCrumbled(x, y);
4000 if (GFX_CRUMBLED(Tile[x][y]))
4001 DrawLevelFieldCrumbled(x, y);
4005 void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
4007 int sx = SCREENX(x), sy = SCREENY(y);
4010 if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
4013 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
4015 if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
4018 DrawGraphicAnimation(sx, sy, graphic);
4020 if (GFX_CRUMBLED(element))
4021 DrawLevelFieldCrumbled(x, y);
4024 static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
4026 if (player->use_murphy)
4028 // this works only because currently only one player can be "murphy" ...
4029 static int last_horizontal_dir = MV_LEFT;
4030 int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
4032 if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
4033 last_horizontal_dir = move_dir;
4035 if (graphic == IMG_SP_MURPHY) // undefined => use special graphic
4037 int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
4039 graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
4045 return el_act_dir2img(player->artwork_element, player->GfxAction,move_dir);
4048 static boolean equalGraphics(int graphic1, int graphic2)
4050 struct GraphicInfo *g1 = &graphic_info[graphic1];
4051 struct GraphicInfo *g2 = &graphic_info[graphic2];
4053 return (g1->bitmap == g2->bitmap &&
4054 g1->src_x == g2->src_x &&
4055 g1->src_y == g2->src_y &&
4056 g1->anim_frames == g2->anim_frames &&
4057 g1->anim_delay == g2->anim_delay &&
4058 g1->anim_mode == g2->anim_mode);
4061 #define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
4065 DRAW_PLAYER_STAGE_INIT = 0,
4066 DRAW_PLAYER_STAGE_LAST_FIELD,
4067 DRAW_PLAYER_STAGE_FIELD_UNDER_PLAYER,
4068 #if DRAW_PLAYER_OVER_PUSHED_ELEMENT
4069 DRAW_PLAYER_STAGE_ELEMENT_PUSHED,
4070 DRAW_PLAYER_STAGE_PLAYER,
4072 DRAW_PLAYER_STAGE_PLAYER,
4073 DRAW_PLAYER_STAGE_ELEMENT_PUSHED,
4075 DRAW_PLAYER_STAGE_ELEMENT_OVER_PLAYER,
4076 DRAW_PLAYER_STAGE_FIELD_OVER_PLAYER,
4078 NUM_DRAW_PLAYER_STAGES
4081 static void DrawPlayerExt(struct PlayerInfo *player, int drawing_stage)
4083 static int static_last_player_graphic[MAX_PLAYERS];
4084 static int static_last_player_frame[MAX_PLAYERS];
4085 static boolean static_player_is_opaque[MAX_PLAYERS];
4086 static boolean draw_player[MAX_PLAYERS];
4087 int pnr = player->index_nr;
4089 if (drawing_stage == DRAW_PLAYER_STAGE_INIT)
4091 static_last_player_graphic[pnr] = getPlayerGraphic(player, player->MovDir);
4092 static_last_player_frame[pnr] = player->Frame;
4093 static_player_is_opaque[pnr] = FALSE;
4095 draw_player[pnr] = TRUE;
4098 if (!draw_player[pnr])
4102 if (!IN_LEV_FIELD(player->jx, player->jy))
4104 Debug("draw:DrawPlayerExt", "x = %d, y = %d", player->jx, player->jy);
4105 Debug("draw:DrawPlayerExt", "This should never happen!");
4107 draw_player[pnr] = FALSE;
4113 int last_player_graphic = static_last_player_graphic[pnr];
4114 int last_player_frame = static_last_player_frame[pnr];
4115 boolean player_is_opaque = static_player_is_opaque[pnr];
4117 int jx = player->jx;
4118 int jy = player->jy;
4119 int move_dir = (player->is_waiting ? player->dir_waiting : player->MovDir);
4120 int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
4121 int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? +1 : 0);
4122 int last_jx = (player->is_moving ? jx - dx : jx);
4123 int last_jy = (player->is_moving ? jy - dy : jy);
4124 int next_jx = jx + dx;
4125 int next_jy = jy + dy;
4126 boolean player_is_moving = (player->MovPos != 0 ? TRUE : FALSE);
4127 int sx = SCREENX(jx);
4128 int sy = SCREENY(jy);
4129 int sxx = (move_dir == MV_LEFT || move_dir == MV_RIGHT ? player->GfxPos : 0);
4130 int syy = (move_dir == MV_UP || move_dir == MV_DOWN ? player->GfxPos : 0);
4131 int element = Tile[jx][jy];
4132 int last_element = Tile[last_jx][last_jy];
4133 int action = (player->is_pushing ? ACTION_PUSHING :
4134 player->is_digging ? ACTION_DIGGING :
4135 player->is_collecting ? ACTION_COLLECTING :
4136 player->is_moving ? ACTION_MOVING :
4137 player->is_snapping ? ACTION_SNAPPING :
4138 player->is_dropping ? ACTION_DROPPING :
4139 player->is_waiting ? player->action_waiting :
4142 if (drawing_stage == DRAW_PLAYER_STAGE_INIT)
4144 // ------------------------------------------------------------------------
4145 // initialize drawing the player
4146 // ------------------------------------------------------------------------
4148 draw_player[pnr] = FALSE;
4150 // GfxElement[][] is set to the element the player is digging or collecting;
4151 // remove also for off-screen player if the player is not moving anymore
4152 if (IN_LEV_FIELD(jx, jy) && !player_is_moving)
4153 GfxElement[jx][jy] = EL_UNDEFINED;
4155 if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
4158 if (element == EL_EXPLOSION)
4161 InitPlayerGfxAnimation(player, action, move_dir);
4163 draw_player[pnr] = TRUE;
4165 else if (drawing_stage == DRAW_PLAYER_STAGE_LAST_FIELD)
4167 // ------------------------------------------------------------------------
4168 // draw things in the field the player is leaving, if needed
4169 // ------------------------------------------------------------------------
4171 if (!IN_SCR_FIELD(sx, sy))
4172 draw_player[pnr] = FALSE;
4174 if (!player->is_moving)
4177 if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
4179 DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
4181 if (last_element == EL_DYNAMITE_ACTIVE ||
4182 last_element == EL_EM_DYNAMITE_ACTIVE ||
4183 last_element == EL_SP_DISK_RED_ACTIVE)
4184 DrawDynamite(last_jx, last_jy);
4186 DrawLevelFieldThruMask(last_jx, last_jy);
4188 else if (last_element == EL_DYNAMITE_ACTIVE ||
4189 last_element == EL_EM_DYNAMITE_ACTIVE ||
4190 last_element == EL_SP_DISK_RED_ACTIVE)
4191 DrawDynamite(last_jx, last_jy);
4193 DrawLevelField(last_jx, last_jy);
4195 else if (drawing_stage == DRAW_PLAYER_STAGE_FIELD_UNDER_PLAYER)
4197 // ------------------------------------------------------------------------
4198 // draw things behind the player, if needed
4199 // ------------------------------------------------------------------------
4203 DrawLevelElement(jx, jy, Back[jx][jy]);
4208 if (IS_ACTIVE_BOMB(element))
4210 DrawLevelElement(jx, jy, EL_EMPTY);
4215 if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
4217 int old_element = GfxElement[jx][jy];
4218 int old_graphic = el_act_dir2img(old_element, action, move_dir);
4219 int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
4221 if (GFX_CRUMBLED(old_element))
4222 DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
4224 DrawScreenGraphic(sx, sy, old_graphic, frame);
4226 if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
4227 static_player_is_opaque[pnr] = TRUE;
4231 GfxElement[jx][jy] = EL_UNDEFINED;
4233 // make sure that pushed elements are drawn with correct frame rate
4234 int graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
4236 if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
4237 GfxFrame[jx][jy] = player->StepFrame;
4239 DrawLevelField(jx, jy);
4242 else if (drawing_stage == DRAW_PLAYER_STAGE_ELEMENT_PUSHED)
4244 // ------------------------------------------------------------------------
4245 // draw things the player is pushing, if needed
4246 // ------------------------------------------------------------------------
4248 if (!player->is_pushing || !player->is_moving)
4251 int gfx_frame = GfxFrame[jx][jy];
4253 if (!IS_MOVING(jx, jy)) // push movement already finished
4255 element = Tile[next_jx][next_jy];
4256 gfx_frame = GfxFrame[next_jx][next_jy];
4259 int graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
4260 int sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
4261 int frame = getGraphicAnimationFrame(graphic, sync_frame);
4263 // draw background element under pushed element (like the Sokoban field)
4264 if (game.use_masked_pushing && IS_MOVING(jx, jy))
4266 // this allows transparent pushing animation over non-black background
4269 DrawLevelElement(jx, jy, Back[jx][jy]);
4271 DrawLevelElement(jx, jy, EL_EMPTY);
4274 if (Back[next_jx][next_jy])
4275 DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
4277 DrawLevelElement(next_jx, next_jy, EL_EMPTY);
4279 int px = SCREENX(jx), py = SCREENY(jy);
4280 int pxx = (TILEX - ABS(sxx)) * dx;
4281 int pyy = (TILEY - ABS(syy)) * dy;
4284 // do not draw (EM style) pushing animation when pushing is finished
4285 // (two-tile animations usually do not contain start and end frame)
4286 if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
4287 DrawLevelElement(next_jx, next_jy, Tile[next_jx][next_jy]);
4289 DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4291 // masked drawing is needed for EMC style (double) movement graphics
4292 // !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!!
4293 DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4296 else if (drawing_stage == DRAW_PLAYER_STAGE_PLAYER)
4298 // ------------------------------------------------------------------------
4299 // draw player himself
4300 // ------------------------------------------------------------------------
4302 int graphic = getPlayerGraphic(player, move_dir);
4304 // in the case of changed player action or direction, prevent the current
4305 // animation frame from being restarted for identical animations
4306 if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
4307 player->Frame = last_player_frame;
4309 int frame = getGraphicAnimationFrame(graphic, player->Frame);
4311 if (player_is_opaque)
4312 DrawGraphicShifted(sx,sy, sxx,syy, graphic, frame, NO_CUTTING,NO_MASKING);
4314 DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4316 if (SHIELD_ON(player))
4318 graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
4319 IMG_SHIELD_NORMAL_ACTIVE);
4320 frame = getGraphicAnimationFrame(graphic, -1);
4322 DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4325 else if (drawing_stage == DRAW_PLAYER_STAGE_ELEMENT_OVER_PLAYER)
4327 // ------------------------------------------------------------------------
4328 // draw things in front of player (active dynamite or dynabombs)
4329 // ------------------------------------------------------------------------
4331 if (IS_ACTIVE_BOMB(element))
4333 int graphic = el2img(element);
4334 int frame = getGraphicAnimationFrameXY(graphic, jx, jy);
4336 if (game.emulation == EMU_SUPAPLEX)
4337 DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
4339 DrawGraphicThruMask(sx, sy, graphic, frame);
4342 if (player_is_moving && last_element == EL_EXPLOSION)
4344 int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
4345 GfxElement[last_jx][last_jy] : EL_EMPTY);
4346 int graphic = el_act2img(element, ACTION_EXPLODING);
4347 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
4348 int phase = ExplodePhase[last_jx][last_jy] - 1;
4349 int frame = getGraphicAnimationFrame(graphic, phase - delay);
4352 DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
4355 else if (drawing_stage == DRAW_PLAYER_STAGE_FIELD_OVER_PLAYER)
4357 // ------------------------------------------------------------------------
4358 // draw elements the player is just walking/passing through/under
4359 // ------------------------------------------------------------------------
4361 if (player_is_moving)
4363 // handle the field the player is leaving ...
4364 if (IS_ACCESSIBLE_INSIDE(last_element))
4365 DrawLevelField(last_jx, last_jy);
4366 else if (IS_ACCESSIBLE_UNDER(last_element))
4367 DrawLevelFieldThruMask(last_jx, last_jy);
4370 // do not redraw accessible elements if the player is just pushing them
4371 if (!player_is_moving || !player->is_pushing)
4373 // ... and the field the player is entering
4374 if (IS_ACCESSIBLE_INSIDE(element))
4375 DrawLevelField(jx, jy);
4376 else if (IS_ACCESSIBLE_UNDER(element))
4377 DrawLevelFieldThruMask(jx, jy);
4380 MarkTileDirty(sx, sy);
4384 void DrawPlayer(struct PlayerInfo *player)
4388 for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4389 DrawPlayerExt(player, i);
4392 void DrawAllPlayers(void)
4396 for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4397 for (j = 0; j < MAX_PLAYERS; j++)
4398 if (stored_player[j].active)
4399 DrawPlayerExt(&stored_player[j], i);
4402 void DrawPlayerField(int x, int y)
4404 if (!IS_PLAYER(x, y))
4407 DrawPlayer(PLAYERINFO(x, y));
4410 // ----------------------------------------------------------------------------
4412 void WaitForEventToContinue(void)
4414 boolean first_wait = TRUE;
4415 boolean still_wait = TRUE;
4417 if (program.headless)
4420 // simulate releasing mouse button over last gadget, if still pressed
4422 HandleGadgets(-1, -1, 0);
4424 button_status = MB_RELEASED;
4427 ClearPlayerAction();
4433 if (NextValidEvent(&event))
4437 case EVENT_BUTTONPRESS:
4438 case EVENT_FINGERPRESS:
4442 case EVENT_BUTTONRELEASE:
4443 case EVENT_FINGERRELEASE:
4444 still_wait = first_wait;
4447 case EVENT_KEYPRESS:
4448 case SDL_CONTROLLERBUTTONDOWN:
4449 case SDL_JOYBUTTONDOWN:
4454 HandleOtherEvents(&event);
4458 else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4463 if (!PendingEvent())
4468 #define MAX_REQUEST_LINES 13
4469 #define MAX_REQUEST_LINE_FONT1_LEN 7
4470 #define MAX_REQUEST_LINE_FONT2_LEN 10
4472 static int RequestHandleEvents(unsigned int req_state, int draw_buffer_game)
4474 boolean game_just_ended = (game_status == GAME_MODE_PLAYING &&
4476 int draw_buffer_last = GetDrawtoField();
4477 int width = request.width;
4478 int height = request.height;
4482 // when showing request dialog after game ended, deactivate game panel
4483 if (game_just_ended)
4484 game.panel.active = FALSE;
4486 game.request_active = TRUE;
4488 setRequestPosition(&sx, &sy, FALSE);
4490 button_status = MB_RELEASED;
4492 request_gadget_id = -1;
4497 boolean event_handled = FALSE;
4499 if (game_just_ended)
4501 SetDrawtoField(draw_buffer_game);
4503 HandleGameActions();
4505 SetDrawtoField(DRAW_TO_BACKBUFFER);
4507 if (global.use_envelope_request)
4509 // copy current state of request area to middle of playfield area
4510 BlitBitmap(bitmap_db_store_2, drawto, sx, sy, width, height, sx, sy);
4518 while (NextValidEvent(&event))
4520 event_handled = TRUE;
4524 case EVENT_BUTTONPRESS:
4525 case EVENT_BUTTONRELEASE:
4526 case EVENT_MOTIONNOTIFY:
4530 if (event.type == EVENT_MOTIONNOTIFY)
4535 motion_status = TRUE;
4536 mx = ((MotionEvent *) &event)->x;
4537 my = ((MotionEvent *) &event)->y;
4541 motion_status = FALSE;
4542 mx = ((ButtonEvent *) &event)->x;
4543 my = ((ButtonEvent *) &event)->y;
4544 if (event.type == EVENT_BUTTONPRESS)
4545 button_status = ((ButtonEvent *) &event)->button;
4547 button_status = MB_RELEASED;
4550 // this sets 'request_gadget_id'
4551 HandleGadgets(mx, my, button_status);
4553 switch (request_gadget_id)
4555 case TOOL_CTRL_ID_YES:
4556 case TOOL_CTRL_ID_TOUCH_YES:
4559 case TOOL_CTRL_ID_NO:
4560 case TOOL_CTRL_ID_TOUCH_NO:
4563 case TOOL_CTRL_ID_CONFIRM:
4564 case TOOL_CTRL_ID_TOUCH_CONFIRM:
4565 result = TRUE | FALSE;
4568 case TOOL_CTRL_ID_PLAYER_1:
4571 case TOOL_CTRL_ID_PLAYER_2:
4574 case TOOL_CTRL_ID_PLAYER_3:
4577 case TOOL_CTRL_ID_PLAYER_4:
4582 // only check clickable animations if no request gadget clicked
4583 HandleGlobalAnimClicks(mx, my, button_status, FALSE);
4590 case SDL_WINDOWEVENT:
4591 HandleWindowEvent((WindowEvent *) &event);
4594 case SDL_APP_WILLENTERBACKGROUND:
4595 case SDL_APP_DIDENTERBACKGROUND:
4596 case SDL_APP_WILLENTERFOREGROUND:
4597 case SDL_APP_DIDENTERFOREGROUND:
4598 HandlePauseResumeEvent((PauseResumeEvent *) &event);
4601 case EVENT_KEYPRESS:
4603 Key key = GetEventKey((KeyEvent *)&event);
4608 if (req_state & REQ_CONFIRM)
4617 #if defined(KSYM_Rewind)
4618 case KSYM_Rewind: // for Amazon Fire TV remote
4627 #if defined(KSYM_FastForward)
4628 case KSYM_FastForward: // for Amazon Fire TV remote
4634 HandleKeysDebug(key, KEY_PRESSED);
4638 if (req_state & REQ_PLAYER)
4640 int old_player_nr = setup.network_player_nr;
4643 result = old_player_nr + 1;
4648 result = old_player_nr + 1;
4679 case EVENT_FINGERRELEASE:
4680 case EVENT_KEYRELEASE:
4681 ClearPlayerAction();
4684 case SDL_CONTROLLERBUTTONDOWN:
4685 switch (event.cbutton.button)
4687 case SDL_CONTROLLER_BUTTON_A:
4688 case SDL_CONTROLLER_BUTTON_X:
4689 case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
4690 case SDL_CONTROLLER_BUTTON_LEFTSTICK:
4694 case SDL_CONTROLLER_BUTTON_B:
4695 case SDL_CONTROLLER_BUTTON_Y:
4696 case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
4697 case SDL_CONTROLLER_BUTTON_RIGHTSTICK:
4698 case SDL_CONTROLLER_BUTTON_BACK:
4703 if (req_state & REQ_PLAYER)
4705 int old_player_nr = setup.network_player_nr;
4708 result = old_player_nr + 1;
4710 switch (event.cbutton.button)
4712 case SDL_CONTROLLER_BUTTON_DPAD_UP:
4713 case SDL_CONTROLLER_BUTTON_Y:
4717 case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
4718 case SDL_CONTROLLER_BUTTON_B:
4722 case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
4723 case SDL_CONTROLLER_BUTTON_A:
4727 case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
4728 case SDL_CONTROLLER_BUTTON_X:
4739 case SDL_CONTROLLERBUTTONUP:
4740 HandleJoystickEvent(&event);
4741 ClearPlayerAction();
4745 HandleOtherEvents(&event);
4750 else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4752 int joy = AnyJoystick();
4754 if (joy & JOY_BUTTON_1)
4756 else if (joy & JOY_BUTTON_2)
4759 else if (AnyJoystick())
4761 int joy = AnyJoystick();
4763 if (req_state & REQ_PLAYER)
4767 else if (joy & JOY_RIGHT)
4769 else if (joy & JOY_DOWN)
4771 else if (joy & JOY_LEFT)
4778 if (game_just_ended)
4780 if (global.use_envelope_request)
4782 // copy back current state of pressed buttons inside request area
4783 BlitBitmap(drawto, bitmap_db_store_2, sx, sy, width, height, sx, sy);
4787 PrepareEnvelopeRequestToScreen(drawto, sx, sy, width, height);
4793 SetDrawtoField(draw_buffer_last);
4795 game.request_active = FALSE;
4800 static boolean RequestDoor(char *text, unsigned int req_state)
4802 int draw_buffer_last = GetDrawtoField();
4803 unsigned int old_door_state;
4804 int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN;
4805 int font_nr = FONT_TEXT_2;
4810 if (maxWordLengthInRequestString(text) > MAX_REQUEST_LINE_FONT1_LEN)
4812 max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
4813 font_nr = FONT_TEXT_1;
4816 if (game_status == GAME_MODE_PLAYING)
4817 BlitScreenToBitmap(backbuffer);
4819 // disable deactivated drawing when quick-loading level tape recording
4820 if (tape.playing && tape.deactivate_display)
4821 TapeDeactivateDisplayOff(TRUE);
4823 SetMouseCursor(CURSOR_DEFAULT);
4825 // pause network game while waiting for request to answer
4826 if (network.enabled &&
4827 game_status == GAME_MODE_PLAYING &&
4828 !game.all_players_gone &&
4829 req_state & REQUEST_WAIT_FOR_INPUT)
4830 SendToServer_PausePlaying();
4832 old_door_state = GetDoorState();
4834 // simulate releasing mouse button over last gadget, if still pressed
4836 HandleGadgets(-1, -1, 0);
4840 // draw released gadget before proceeding
4843 if (old_door_state & DOOR_OPEN_1)
4845 CloseDoor(DOOR_CLOSE_1);
4847 // save old door content
4848 BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
4849 0 * DXSIZE, 0, DXSIZE, DYSIZE, 1 * DXSIZE, 0);
4852 SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
4853 SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4855 // clear door drawing field
4856 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4858 // force DOOR font inside door area
4859 SetFontStatus(GAME_MODE_PSEUDO_DOOR);
4861 // write text for request
4862 for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
4864 char text_line[max_request_line_len + 1];
4870 for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
4872 tc = *(text_ptr + tx);
4873 // if (!tc || tc == ' ')
4874 if (!tc || tc == ' ' || tc == '?' || tc == '!')
4878 if ((tc == '?' || tc == '!') && tl == 0)
4888 strncpy(text_line, text_ptr, tl);
4891 DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
4892 DY + 8 + ty * (getFontHeight(font_nr) + 2),
4893 text_line, font_nr);
4895 text_ptr += tl + (tc == ' ' ? 1 : 0);
4896 // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
4901 if (req_state & REQ_ASK)
4903 MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
4904 MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
4905 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_YES]);
4906 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_NO]);
4908 else if (req_state & REQ_CONFIRM)
4910 MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
4911 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_CONFIRM]);
4913 else if (req_state & REQ_PLAYER)
4915 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
4916 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
4917 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
4918 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
4921 // copy request gadgets to door backbuffer
4922 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4924 OpenDoor(DOOR_OPEN_1);
4926 if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4928 if (game_status == GAME_MODE_PLAYING)
4930 SetPanelBackground();
4931 SetDrawBackgroundMask(REDRAW_DOOR_1);
4935 SetDrawBackgroundMask(REDRAW_FIELD);
4941 SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4943 // ---------- handle request buttons ----------
4944 result = RequestHandleEvents(req_state, draw_buffer_last);
4948 if (!(req_state & REQ_STAY_OPEN))
4950 CloseDoor(DOOR_CLOSE_1);
4952 if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
4953 (req_state & REQ_REOPEN))
4954 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
4959 if (game_status == GAME_MODE_PLAYING)
4961 SetPanelBackground();
4962 SetDrawBackgroundMask(REDRAW_DOOR_1);
4966 SetDrawBackgroundMask(REDRAW_FIELD);
4969 // continue network game after request
4970 if (network.enabled &&
4971 game_status == GAME_MODE_PLAYING &&
4972 !game.all_players_gone &&
4973 req_state & REQUEST_WAIT_FOR_INPUT)
4974 SendToServer_ContinuePlaying();
4976 // restore deactivated drawing when quick-loading level tape recording
4977 if (tape.playing && tape.deactivate_display)
4978 TapeDeactivateDisplayOn();
4983 static boolean RequestEnvelope(char *text, unsigned int req_state)
4985 int draw_buffer_last = GetDrawtoField();
4988 if (game_status == GAME_MODE_PLAYING)
4989 BlitScreenToBitmap(backbuffer);
4991 // disable deactivated drawing when quick-loading level tape recording
4992 if (tape.playing && tape.deactivate_display)
4993 TapeDeactivateDisplayOff(TRUE);
4995 SetMouseCursor(CURSOR_DEFAULT);
4997 // pause network game while waiting for request to answer
4998 if (network.enabled &&
4999 game_status == GAME_MODE_PLAYING &&
5000 !game.all_players_gone &&
5001 req_state & REQUEST_WAIT_FOR_INPUT)
5002 SendToServer_PausePlaying();
5004 // simulate releasing mouse button over last gadget, if still pressed
5006 HandleGadgets(-1, -1, 0);
5010 // (replace with setting corresponding request background)
5011 // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
5012 // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
5014 // clear door drawing field
5015 // DrawBackground(DX, DY, DXSIZE, DYSIZE);
5017 ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
5019 if (!(req_state & REQUEST_WAIT_FOR_INPUT))
5021 if (game_status == GAME_MODE_PLAYING)
5023 SetPanelBackground();
5024 SetDrawBackgroundMask(REDRAW_DOOR_1);
5028 SetDrawBackgroundMask(REDRAW_FIELD);
5034 SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
5036 // ---------- handle request buttons ----------
5037 result = RequestHandleEvents(req_state, draw_buffer_last);
5041 ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
5045 if (game_status == GAME_MODE_PLAYING)
5047 SetPanelBackground();
5048 SetDrawBackgroundMask(REDRAW_DOOR_1);
5052 SetDrawBackgroundMask(REDRAW_FIELD);
5055 // continue network game after request
5056 if (network.enabled &&
5057 game_status == GAME_MODE_PLAYING &&
5058 !game.all_players_gone &&
5059 req_state & REQUEST_WAIT_FOR_INPUT)
5060 SendToServer_ContinuePlaying();
5062 // restore deactivated drawing when quick-loading level tape recording
5063 if (tape.playing && tape.deactivate_display)
5064 TapeDeactivateDisplayOn();
5069 boolean Request(char *text, unsigned int req_state)
5071 boolean overlay_enabled = GetOverlayEnabled();
5074 game.request_active_or_moving = TRUE;
5076 SetOverlayEnabled(FALSE);
5078 if (global.use_envelope_request)
5079 result = RequestEnvelope(text, req_state);
5081 result = RequestDoor(text, req_state);
5083 SetOverlayEnabled(overlay_enabled);
5085 game.request_active_or_moving = FALSE;
5090 static int compareDoorPartOrderInfo(const void *object1, const void *object2)
5092 const struct DoorPartOrderInfo *dpo1 = (struct DoorPartOrderInfo *)object1;
5093 const struct DoorPartOrderInfo *dpo2 = (struct DoorPartOrderInfo *)object2;
5096 if (dpo1->sort_priority != dpo2->sort_priority)
5097 compare_result = dpo1->sort_priority - dpo2->sort_priority;
5099 compare_result = dpo1->nr - dpo2->nr;
5101 return compare_result;
5104 void InitGraphicCompatibilityInfo_Doors(void)
5110 struct DoorInfo *door;
5114 { DOOR_1, IMG_GFX_DOOR_1_PART_1, IMG_GFX_DOOR_1_PART_8, &door_1 },
5115 { DOOR_2, IMG_GFX_DOOR_2_PART_1, IMG_GFX_DOOR_2_PART_8, &door_2 },
5117 { -1, -1, -1, NULL }
5119 struct Rect door_rect_list[] =
5121 { DX, DY, DXSIZE, DYSIZE },
5122 { VX, VY, VXSIZE, VYSIZE }
5126 for (i = 0; doors[i].door_token != -1; i++)
5128 int door_token = doors[i].door_token;
5129 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5130 int part_1 = doors[i].part_1;
5131 int part_8 = doors[i].part_8;
5132 int part_2 = part_1 + 1;
5133 int part_3 = part_1 + 2;
5134 struct DoorInfo *door = doors[i].door;
5135 struct Rect *door_rect = &door_rect_list[door_index];
5136 boolean door_gfx_redefined = FALSE;
5138 // check if any door part graphic definitions have been redefined
5140 for (j = 0; door_part_controls[j].door_token != -1; j++)
5142 struct DoorPartControlInfo *dpc = &door_part_controls[j];
5143 struct FileInfo *fi = getImageListEntryFromImageID(dpc->graphic);
5145 if (dpc->door_token == door_token && fi->redefined)
5146 door_gfx_redefined = TRUE;
5149 // check for old-style door graphic/animation modifications
5151 if (!door_gfx_redefined)
5153 if (door->anim_mode & ANIM_STATIC_PANEL)
5155 door->panel.step_xoffset = 0;
5156 door->panel.step_yoffset = 0;
5159 if (door->anim_mode & (ANIM_HORIZONTAL | ANIM_VERTICAL))
5161 struct GraphicInfo *g_part_1 = &graphic_info[part_1];
5162 struct GraphicInfo *g_part_2 = &graphic_info[part_2];
5163 int num_door_steps, num_panel_steps;
5165 // remove door part graphics other than the two default wings
5167 for (j = 0; door_part_controls[j].door_token != -1; j++)
5169 struct DoorPartControlInfo *dpc = &door_part_controls[j];
5170 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5172 if (dpc->graphic >= part_3 &&
5173 dpc->graphic <= part_8)
5177 // set graphics and screen positions of the default wings
5179 g_part_1->width = door_rect->width;
5180 g_part_1->height = door_rect->height;
5181 g_part_2->width = door_rect->width;
5182 g_part_2->height = door_rect->height;
5183 g_part_2->src_x = door_rect->width;
5184 g_part_2->src_y = g_part_1->src_y;
5186 door->part_2.x = door->part_1.x;
5187 door->part_2.y = door->part_1.y;
5189 if (door->width != -1)
5191 g_part_1->width = door->width;
5192 g_part_2->width = door->width;
5194 // special treatment for graphics and screen position of right wing
5195 g_part_2->src_x += door_rect->width - door->width;
5196 door->part_2.x += door_rect->width - door->width;
5199 if (door->height != -1)
5201 g_part_1->height = door->height;
5202 g_part_2->height = door->height;
5204 // special treatment for graphics and screen position of bottom wing
5205 g_part_2->src_y += door_rect->height - door->height;
5206 door->part_2.y += door_rect->height - door->height;
5209 // set animation delays for the default wings and panels
5211 door->part_1.step_delay = door->step_delay;
5212 door->part_2.step_delay = door->step_delay;
5213 door->panel.step_delay = door->step_delay;
5215 // set animation draw order for the default wings
5217 door->part_1.sort_priority = 2; // draw left wing over ...
5218 door->part_2.sort_priority = 1; // ... right wing
5220 // set animation draw offset for the default wings
5222 if (door->anim_mode & ANIM_HORIZONTAL)
5224 door->part_1.step_xoffset = door->step_offset;
5225 door->part_1.step_yoffset = 0;
5226 door->part_2.step_xoffset = door->step_offset * -1;
5227 door->part_2.step_yoffset = 0;
5229 num_door_steps = g_part_1->width / door->step_offset;
5231 else // ANIM_VERTICAL
5233 door->part_1.step_xoffset = 0;
5234 door->part_1.step_yoffset = door->step_offset;
5235 door->part_2.step_xoffset = 0;
5236 door->part_2.step_yoffset = door->step_offset * -1;
5238 num_door_steps = g_part_1->height / door->step_offset;
5241 // set animation draw offset for the default panels
5243 if (door->step_offset > 1)
5245 num_panel_steps = 2 * door_rect->height / door->step_offset;
5246 door->panel.start_step = num_panel_steps - num_door_steps;
5247 door->panel.start_step_closing = door->panel.start_step;
5251 num_panel_steps = door_rect->height / door->step_offset;
5252 door->panel.start_step = num_panel_steps - num_door_steps / 2;
5253 door->panel.start_step_closing = door->panel.start_step;
5254 door->panel.step_delay *= 2;
5261 void InitDoors(void)
5265 for (i = 0; door_part_controls[i].door_token != -1; i++)
5267 struct DoorPartControlInfo *dpc = &door_part_controls[i];
5268 struct DoorPartOrderInfo *dpo = &door_part_order[i];
5270 // initialize "start_step_opening" and "start_step_closing", if needed
5271 if (dpc->pos->start_step_opening == 0 &&
5272 dpc->pos->start_step_closing == 0)
5274 // dpc->pos->start_step_opening = dpc->pos->start_step;
5275 dpc->pos->start_step_closing = dpc->pos->start_step;
5278 // fill structure for door part draw order (sorted below)
5280 dpo->sort_priority = dpc->pos->sort_priority;
5283 // sort door part controls according to sort_priority and graphic number
5284 qsort(door_part_order, MAX_DOOR_PARTS,
5285 sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
5288 unsigned int OpenDoor(unsigned int door_state)
5290 if (door_state & DOOR_COPY_BACK)
5292 if (door_state & DOOR_OPEN_1)
5293 BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
5294 1 * DXSIZE, 0, DXSIZE, DYSIZE, 0 * DXSIZE, 0);
5296 if (door_state & DOOR_OPEN_2)
5297 BlitBitmap(bitmap_db_door_2, bitmap_db_door_2,
5298 1 * VXSIZE, 0, VXSIZE, VYSIZE, 0 * VXSIZE, 0);
5300 door_state &= ~DOOR_COPY_BACK;
5303 return MoveDoor(door_state);
5306 unsigned int CloseDoor(unsigned int door_state)
5308 unsigned int old_door_state = GetDoorState();
5310 if (!(door_state & DOOR_NO_COPY_BACK))
5312 if (old_door_state & DOOR_OPEN_1)
5313 BlitBitmap(backbuffer, bitmap_db_door_1,
5314 DX, DY, DXSIZE, DYSIZE, 0, 0);
5316 if (old_door_state & DOOR_OPEN_2)
5317 BlitBitmap(backbuffer, bitmap_db_door_2,
5318 VX, VY, VXSIZE, VYSIZE, 0, 0);
5320 door_state &= ~DOOR_NO_COPY_BACK;
5323 return MoveDoor(door_state);
5326 unsigned int GetDoorState(void)
5328 return MoveDoor(DOOR_GET_STATE);
5331 unsigned int SetDoorState(unsigned int door_state)
5333 return MoveDoor(door_state | DOOR_SET_STATE);
5336 static int euclid(int a, int b)
5338 return (b ? euclid(b, a % b) : a);
5341 unsigned int MoveDoor(unsigned int door_state)
5343 struct Rect door_rect_list[] =
5345 { DX, DY, DXSIZE, DYSIZE },
5346 { VX, VY, VXSIZE, VYSIZE }
5348 static int door1 = DOOR_CLOSE_1;
5349 static int door2 = DOOR_CLOSE_2;
5350 DelayCounter door_delay = { 0 };
5353 if (door_state == DOOR_GET_STATE)
5354 return (door1 | door2);
5356 if (door_state & DOOR_SET_STATE)
5358 if (door_state & DOOR_ACTION_1)
5359 door1 = door_state & DOOR_ACTION_1;
5360 if (door_state & DOOR_ACTION_2)
5361 door2 = door_state & DOOR_ACTION_2;
5363 return (door1 | door2);
5366 if (!(door_state & DOOR_FORCE_REDRAW))
5368 if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
5369 door_state &= ~DOOR_OPEN_1;
5370 else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
5371 door_state &= ~DOOR_CLOSE_1;
5372 if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
5373 door_state &= ~DOOR_OPEN_2;
5374 else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
5375 door_state &= ~DOOR_CLOSE_2;
5378 if (global.autoplay_leveldir)
5380 door_state |= DOOR_NO_DELAY;
5381 door_state &= ~DOOR_CLOSE_ALL;
5384 if (game_status == GAME_MODE_EDITOR && !(door_state & DOOR_FORCE_ANIM))
5385 door_state |= DOOR_NO_DELAY;
5387 if (door_state & DOOR_ACTION)
5389 boolean door_panel_drawn[NUM_DOORS];
5390 boolean panel_has_doors[NUM_DOORS];
5391 boolean door_part_skip[MAX_DOOR_PARTS];
5392 boolean door_part_done[MAX_DOOR_PARTS];
5393 boolean door_part_done_all;
5394 int num_steps[MAX_DOOR_PARTS];
5395 int max_move_delay = 0; // delay for complete animations of all doors
5396 int max_step_delay = 0; // delay (ms) between two animation frames
5397 int num_move_steps = 0; // number of animation steps for all doors
5398 int max_move_delay_doors_only = 0; // delay for doors only (no panel)
5399 int num_move_steps_doors_only = 0; // steps for doors only (no panel)
5403 for (i = 0; i < NUM_DOORS; i++)
5404 panel_has_doors[i] = FALSE;
5406 for (i = 0; i < MAX_DOOR_PARTS; i++)
5408 struct DoorPartControlInfo *dpc = &door_part_controls[i];
5409 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5410 int door_token = dpc->door_token;
5412 door_part_done[i] = FALSE;
5413 door_part_skip[i] = (!(door_state & door_token) ||
5417 for (i = 0; i < MAX_DOOR_PARTS; i++)
5419 int nr = door_part_order[i].nr;
5420 struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5421 struct DoorPartPosInfo *pos = dpc->pos;
5422 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5423 int door_token = dpc->door_token;
5424 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5425 boolean is_panel = DOOR_PART_IS_PANEL(nr);
5426 int step_xoffset = ABS(pos->step_xoffset);
5427 int step_yoffset = ABS(pos->step_yoffset);
5428 int step_delay = pos->step_delay;
5429 int current_door_state = door_state & door_token;
5430 boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
5431 boolean door_closing = ((current_door_state & DOOR_CLOSE) != 0);
5432 boolean part_opening = (is_panel ? door_closing : door_opening);
5433 int start_step = (part_opening ? pos->start_step_opening :
5434 pos->start_step_closing);
5435 float move_xsize = (step_xoffset ? g->width : 0);
5436 float move_ysize = (step_yoffset ? g->height : 0);
5437 int move_xsteps = (step_xoffset ? ceil(move_xsize / step_xoffset) : 0);
5438 int move_ysteps = (step_yoffset ? ceil(move_ysize / step_yoffset) : 0);
5439 int move_steps = (move_xsteps && move_ysteps ?
5440 MIN(move_xsteps, move_ysteps) :
5441 move_xsteps ? move_xsteps : move_ysteps) - start_step;
5442 int move_delay = move_steps * step_delay;
5444 if (door_part_skip[nr])
5447 max_move_delay = MAX(max_move_delay, move_delay);
5448 max_step_delay = (max_step_delay == 0 ? step_delay :
5449 euclid(max_step_delay, step_delay));
5450 num_steps[nr] = move_steps;
5454 max_move_delay_doors_only = MAX(max_move_delay_doors_only, move_delay);
5456 panel_has_doors[door_index] = TRUE;
5460 max_step_delay = MAX(1, max_step_delay); // prevent division by zero
5462 num_move_steps = max_move_delay / max_step_delay;
5463 num_move_steps_doors_only = max_move_delay_doors_only / max_step_delay;
5465 door_delay.value = max_step_delay;
5467 if ((door_state & DOOR_NO_DELAY) || setup.quick_doors)
5469 start = num_move_steps - 1;
5473 // opening door sound has priority over simultaneously closing door
5474 if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
5476 PlayMenuSoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
5478 if (door_state & DOOR_OPEN_1)
5479 PlayMenuSoundStereo(SND_DOOR_1_OPENING, SOUND_MIDDLE);
5480 if (door_state & DOOR_OPEN_2)
5481 PlayMenuSoundStereo(SND_DOOR_2_OPENING, SOUND_MIDDLE);
5483 else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
5485 PlayMenuSoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
5487 if (door_state & DOOR_CLOSE_1)
5488 PlayMenuSoundStereo(SND_DOOR_1_CLOSING, SOUND_MIDDLE);
5489 if (door_state & DOOR_CLOSE_2)
5490 PlayMenuSoundStereo(SND_DOOR_2_CLOSING, SOUND_MIDDLE);
5494 for (k = start; k < num_move_steps; k++)
5496 int last_frame = num_move_steps - 1; // last frame of this "for" loop
5498 door_part_done_all = TRUE;
5500 for (i = 0; i < NUM_DOORS; i++)
5501 door_panel_drawn[i] = FALSE;
5503 for (i = 0; i < MAX_DOOR_PARTS; i++)
5505 int nr = door_part_order[i].nr;
5506 struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5507 struct DoorPartPosInfo *pos = dpc->pos;
5508 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5509 int door_token = dpc->door_token;
5510 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5511 boolean is_panel = DOOR_PART_IS_PANEL(nr);
5512 boolean is_panel_and_door_has_closed = FALSE;
5513 struct Rect *door_rect = &door_rect_list[door_index];
5514 Bitmap *bitmap_db_door = (door_token == DOOR_1 ? bitmap_db_door_1 :
5516 Bitmap *bitmap = (is_panel ? bitmap_db_door : g->bitmap);
5517 int current_door_state = door_state & door_token;
5518 boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
5519 boolean door_closing = !door_opening;
5520 boolean part_opening = (is_panel ? door_closing : door_opening);
5521 boolean part_closing = !part_opening;
5522 int start_step = (part_opening ? pos->start_step_opening :
5523 pos->start_step_closing);
5524 int step_delay = pos->step_delay;
5525 int step_factor = step_delay / max_step_delay;
5526 int k1 = (step_factor ? k / step_factor + 1 : k);
5527 int k2 = (part_opening ? k1 + start_step : num_steps[nr] - k1);
5528 int kk = MAX(0, k2);
5531 int src_x, src_y, src_xx, src_yy;
5532 int dst_x, dst_y, dst_xx, dst_yy;
5535 if (door_part_skip[nr])
5538 if (!(door_state & door_token))
5546 int k2_door = (door_opening ? k : num_move_steps_doors_only - k - 1);
5547 int kk_door = MAX(0, k2_door);
5548 int sync_frame = kk_door * door_delay.value;
5549 int frame = getGraphicAnimationFrame(dpc->graphic, sync_frame);
5551 getFixedGraphicSource(dpc->graphic, frame, &bitmap,
5552 &g_src_x, &g_src_y);
5557 if (!door_panel_drawn[door_index])
5559 ClearRectangle(drawto, door_rect->x, door_rect->y,
5560 door_rect->width, door_rect->height);
5562 door_panel_drawn[door_index] = TRUE;
5565 // draw opening or closing door parts
5567 if (pos->step_xoffset < 0) // door part on right side
5570 dst_xx = pos->x + ABS(kk * pos->step_xoffset);
5573 if (dst_xx + width > door_rect->width)
5574 width = door_rect->width - dst_xx;
5576 else // door part on left side
5579 dst_xx = pos->x - kk * pos->step_xoffset;
5583 src_xx = ABS(dst_xx);
5587 width = g->width - src_xx;
5589 if (width > door_rect->width)
5590 width = door_rect->width;
5592 // Debug("tools:MoveDoor", "k == %d [%d]", k, start_step);
5595 if (pos->step_yoffset < 0) // door part on bottom side
5598 dst_yy = pos->y + ABS(kk * pos->step_yoffset);
5601 if (dst_yy + height > door_rect->height)
5602 height = door_rect->height - dst_yy;
5604 else // door part on top side
5607 dst_yy = pos->y - kk * pos->step_yoffset;
5611 src_yy = ABS(dst_yy);
5615 height = g->height - src_yy;
5618 src_x = g_src_x + src_xx;
5619 src_y = g_src_y + src_yy;
5621 dst_x = door_rect->x + dst_xx;
5622 dst_y = door_rect->y + dst_yy;
5624 is_panel_and_door_has_closed =
5627 panel_has_doors[door_index] &&
5628 k >= num_move_steps_doors_only - 1);
5630 if (width >= 0 && width <= g->width &&
5631 height >= 0 && height <= g->height &&
5632 !is_panel_and_door_has_closed)
5634 if (is_panel || !pos->draw_masked)
5635 BlitBitmap(bitmap, drawto, src_x, src_y, width, height,
5638 BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height,
5642 redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
5644 if ((part_opening && (width < 0 || height < 0)) ||
5645 (part_closing && (width >= g->width && height >= g->height)))
5646 door_part_done[nr] = TRUE;
5648 // continue door part animations, but not panel after door has closed
5649 if (!door_part_done[nr] && !is_panel_and_door_has_closed)
5650 door_part_done_all = FALSE;
5653 if (!(door_state & DOOR_NO_DELAY))
5657 SkipUntilDelayReached(&door_delay, &k, last_frame);
5659 // prevent OS (Windows) from complaining about program not responding
5663 if (door_part_done_all)
5667 if (!(door_state & DOOR_NO_DELAY))
5669 // wait for specified door action post delay
5670 if (door_state & DOOR_ACTION_1 && door_state & DOOR_ACTION_2)
5671 door_delay.value = MAX(door_1.post_delay, door_2.post_delay);
5672 else if (door_state & DOOR_ACTION_1)
5673 door_delay.value = door_1.post_delay;
5674 else if (door_state & DOOR_ACTION_2)
5675 door_delay.value = door_2.post_delay;
5677 while (!DelayReached(&door_delay))
5682 if (door_state & DOOR_ACTION_1)
5683 door1 = door_state & DOOR_ACTION_1;
5684 if (door_state & DOOR_ACTION_2)
5685 door2 = door_state & DOOR_ACTION_2;
5687 // draw masked border over door area
5688 DrawMaskedBorder(REDRAW_DOOR_1);
5689 DrawMaskedBorder(REDRAW_DOOR_2);
5691 ClearAutoRepeatKeyEvents();
5693 return (door1 | door2);
5696 static boolean useSpecialEditorDoor(void)
5698 int graphic = IMG_GLOBAL_BORDER_EDITOR;
5699 boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
5701 // do not draw special editor door if editor border defined or redefined
5702 if (graphic_info[graphic].bitmap != NULL || redefined)
5705 // do not draw special editor door if global border defined to be empty
5706 if (graphic_info[IMG_GLOBAL_BORDER].bitmap == NULL)
5709 // do not draw special editor door if viewport definitions do not match
5713 EY + EYSIZE != VY + VYSIZE)
5719 void DrawSpecialEditorDoor(void)
5721 struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5722 int top_border_width = gfx1->width;
5723 int top_border_height = gfx1->height;
5724 int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5725 int ex = EX - outer_border;
5726 int ey = EY - outer_border;
5727 int vy = VY - outer_border;
5728 int exsize = EXSIZE + 2 * outer_border;
5730 if (!useSpecialEditorDoor())
5733 // draw bigger level editor toolbox window
5734 BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
5735 top_border_width, top_border_height, ex, ey - top_border_height);
5736 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
5737 exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
5739 redraw_mask |= REDRAW_ALL;
5742 void UndrawSpecialEditorDoor(void)
5744 struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5745 int top_border_width = gfx1->width;
5746 int top_border_height = gfx1->height;
5747 int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5748 int ex = EX - outer_border;
5749 int ey = EY - outer_border;
5750 int ey_top = ey - top_border_height;
5751 int exsize = EXSIZE + 2 * outer_border;
5752 int eysize = EYSIZE + 2 * outer_border;
5754 if (!useSpecialEditorDoor())
5757 // draw normal tape recorder window
5758 if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
5760 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5761 ex, ey_top, top_border_width, top_border_height,
5763 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5764 ex, ey, exsize, eysize, ex, ey);
5768 // if screen background is set to "[NONE]", clear editor toolbox window
5769 ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
5770 ClearRectangle(drawto, ex, ey, exsize, eysize);
5773 redraw_mask |= REDRAW_ALL;
5777 // ---------- new tool button stuff -------------------------------------------
5782 struct TextPosInfo *pos;
5784 boolean is_touch_button;
5786 } toolbutton_info[NUM_TOOL_BUTTONS] =
5789 IMG_GFX_REQUEST_BUTTON_YES, &request.button.yes,
5790 TOOL_CTRL_ID_YES, FALSE, "yes"
5793 IMG_GFX_REQUEST_BUTTON_NO, &request.button.no,
5794 TOOL_CTRL_ID_NO, FALSE, "no"
5797 IMG_GFX_REQUEST_BUTTON_CONFIRM, &request.button.confirm,
5798 TOOL_CTRL_ID_CONFIRM, FALSE, "confirm"
5801 IMG_GFX_REQUEST_BUTTON_PLAYER_1, &request.button.player_1,
5802 TOOL_CTRL_ID_PLAYER_1, FALSE, "player 1"
5805 IMG_GFX_REQUEST_BUTTON_PLAYER_2, &request.button.player_2,
5806 TOOL_CTRL_ID_PLAYER_2, FALSE, "player 2"
5809 IMG_GFX_REQUEST_BUTTON_PLAYER_3, &request.button.player_3,
5810 TOOL_CTRL_ID_PLAYER_3, FALSE, "player 3"
5813 IMG_GFX_REQUEST_BUTTON_PLAYER_4, &request.button.player_4,
5814 TOOL_CTRL_ID_PLAYER_4, FALSE, "player 4"
5817 IMG_GFX_REQUEST_BUTTON_TOUCH_YES, &request.button.touch_yes,
5818 TOOL_CTRL_ID_TOUCH_YES, TRUE, "yes"
5821 IMG_GFX_REQUEST_BUTTON_TOUCH_NO, &request.button.touch_no,
5822 TOOL_CTRL_ID_TOUCH_NO, TRUE, "no"
5825 IMG_GFX_REQUEST_BUTTON_TOUCH_CONFIRM, &request.button.touch_confirm,
5826 TOOL_CTRL_ID_TOUCH_CONFIRM, TRUE, "confirm"
5830 void CreateToolButtons(void)
5834 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5836 int graphic = toolbutton_info[i].graphic;
5837 struct GraphicInfo *gfx = &graphic_info[graphic];
5838 struct TextPosInfo *pos = toolbutton_info[i].pos;
5839 struct GadgetInfo *gi;
5840 Bitmap *deco_bitmap = None;
5841 int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
5842 unsigned int event_mask = GD_EVENT_RELEASED;
5843 boolean is_touch_button = toolbutton_info[i].is_touch_button;
5844 int base_x = (is_touch_button ? 0 : DX);
5845 int base_y = (is_touch_button ? 0 : DY);
5846 int gd_x = gfx->src_x;
5847 int gd_y = gfx->src_y;
5848 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
5849 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
5854 // do not use touch buttons if overlay touch buttons are disabled
5855 if (is_touch_button && !setup.touch.overlay_buttons)
5858 if (global.use_envelope_request && !is_touch_button)
5860 setRequestPosition(&base_x, &base_y, TRUE);
5862 // check if request buttons are outside of envelope and fix, if needed
5863 if (x < 0 || x + gfx->width > request.width ||
5864 y < 0 || y + gfx->height > request.height)
5866 if (id == TOOL_CTRL_ID_YES)
5869 y = request.height - 2 * request.border_size - gfx->height;
5871 else if (id == TOOL_CTRL_ID_NO)
5873 x = request.width - 2 * request.border_size - gfx->width;
5874 y = request.height - 2 * request.border_size - gfx->height;
5876 else if (id == TOOL_CTRL_ID_CONFIRM)
5878 x = (request.width - 2 * request.border_size - gfx->width) / 2;
5879 y = request.height - 2 * request.border_size - gfx->height;
5881 else if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
5883 int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5885 x = (request.width - 2 * request.border_size - gfx->width) / 2;
5886 y = request.height - 2 * request.border_size - gfx->height * 2;
5888 x += (player_nr == 3 ? -1 : player_nr == 1 ? +1 : 0) * gfx->width;
5889 y += (player_nr == 0 ? -1 : player_nr == 2 ? +1 : 0) * gfx->height;
5894 if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4 &&
5897 int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5899 getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
5900 pos->size, &deco_bitmap, &deco_x, &deco_y);
5901 deco_xpos = (gfx->width - pos->size) / 2;
5902 deco_ypos = (gfx->height - pos->size) / 2;
5905 gi = CreateGadget(GDI_CUSTOM_ID, id,
5906 GDI_IMAGE_ID, graphic,
5907 GDI_INFO_TEXT, toolbutton_info[i].infotext,
5910 GDI_WIDTH, gfx->width,
5911 GDI_HEIGHT, gfx->height,
5912 GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
5913 GDI_STATE, GD_BUTTON_UNPRESSED,
5914 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
5915 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
5916 GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
5917 GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
5918 GDI_DECORATION_SIZE, pos->size, pos->size,
5919 GDI_DECORATION_SHIFTING, 1, 1,
5920 GDI_DIRECT_DRAW, FALSE,
5921 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
5922 GDI_EVENT_MASK, event_mask,
5923 GDI_CALLBACK_ACTION, HandleToolButtons,
5927 Fail("cannot create gadget");
5929 tool_gadget[id] = gi;
5933 void FreeToolButtons(void)
5937 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5938 FreeGadget(tool_gadget[i]);
5941 static void UnmapToolButtons(void)
5945 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5946 UnmapGadget(tool_gadget[i]);
5949 static void HandleToolButtons(struct GadgetInfo *gi)
5951 request_gadget_id = gi->custom_id;
5954 static struct Mapping_EM_to_RND_object
5957 boolean is_rnd_to_em_mapping; // unique mapping EM <-> RND
5958 boolean is_backside; // backside of moving element
5964 em_object_mapping_list[GAME_TILE_MAX + 1] =
5967 Zborder, FALSE, FALSE,
5971 Zplayer, FALSE, FALSE,
5980 Ztank, FALSE, FALSE,
5984 Zeater, FALSE, FALSE,
5988 Zdynamite, FALSE, FALSE,
5992 Zboom, FALSE, FALSE,
5997 Xchain, FALSE, FALSE,
5998 EL_DEFAULT, ACTION_EXPLODING, -1
6001 Xboom_bug, FALSE, FALSE,
6002 EL_BUG, ACTION_EXPLODING, -1
6005 Xboom_tank, FALSE, FALSE,
6006 EL_SPACESHIP, ACTION_EXPLODING, -1
6009 Xboom_android, FALSE, FALSE,
6010 EL_EMC_ANDROID, ACTION_OTHER, -1
6013 Xboom_1, FALSE, FALSE,
6014 EL_DEFAULT, ACTION_EXPLODING, -1
6017 Xboom_2, FALSE, FALSE,
6018 EL_DEFAULT, ACTION_EXPLODING, -1
6022 Xblank, TRUE, FALSE,
6027 Xsplash_e, FALSE, FALSE,
6028 EL_ACID_SPLASH_RIGHT, -1, -1
6031 Xsplash_w, FALSE, FALSE,
6032 EL_ACID_SPLASH_LEFT, -1, -1
6036 Xplant, TRUE, FALSE,
6037 EL_EMC_PLANT, -1, -1
6040 Yplant, FALSE, FALSE,
6041 EL_EMC_PLANT, -1, -1
6045 Xacid_1, TRUE, FALSE,
6049 Xacid_2, FALSE, FALSE,
6053 Xacid_3, FALSE, FALSE,
6057 Xacid_4, FALSE, FALSE,
6061 Xacid_5, FALSE, FALSE,
6065 Xacid_6, FALSE, FALSE,
6069 Xacid_7, FALSE, FALSE,
6073 Xacid_8, FALSE, FALSE,
6078 Xfake_acid_1, TRUE, FALSE,
6079 EL_EMC_FAKE_ACID, -1, -1
6082 Xfake_acid_2, FALSE, FALSE,
6083 EL_EMC_FAKE_ACID, -1, -1
6086 Xfake_acid_3, FALSE, FALSE,
6087 EL_EMC_FAKE_ACID, -1, -1
6090 Xfake_acid_4, FALSE, FALSE,
6091 EL_EMC_FAKE_ACID, -1, -1
6094 Xfake_acid_5, FALSE, FALSE,
6095 EL_EMC_FAKE_ACID, -1, -1
6098 Xfake_acid_6, FALSE, FALSE,
6099 EL_EMC_FAKE_ACID, -1, -1
6102 Xfake_acid_7, FALSE, FALSE,
6103 EL_EMC_FAKE_ACID, -1, -1
6106 Xfake_acid_8, FALSE, FALSE,
6107 EL_EMC_FAKE_ACID, -1, -1
6111 Xfake_acid_1_player, FALSE, FALSE,
6112 EL_EMC_FAKE_ACID, -1, -1
6115 Xfake_acid_2_player, FALSE, FALSE,
6116 EL_EMC_FAKE_ACID, -1, -1
6119 Xfake_acid_3_player, FALSE, FALSE,
6120 EL_EMC_FAKE_ACID, -1, -1
6123 Xfake_acid_4_player, FALSE, FALSE,
6124 EL_EMC_FAKE_ACID, -1, -1
6127 Xfake_acid_5_player, FALSE, FALSE,
6128 EL_EMC_FAKE_ACID, -1, -1
6131 Xfake_acid_6_player, FALSE, FALSE,
6132 EL_EMC_FAKE_ACID, -1, -1
6135 Xfake_acid_7_player, FALSE, FALSE,
6136 EL_EMC_FAKE_ACID, -1, -1
6139 Xfake_acid_8_player, FALSE, FALSE,
6140 EL_EMC_FAKE_ACID, -1, -1
6144 Xgrass, TRUE, FALSE,
6145 EL_EMC_GRASS, -1, -1
6148 Ygrass_nB, FALSE, FALSE,
6149 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_UP
6152 Ygrass_eB, FALSE, FALSE,
6153 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_RIGHT
6156 Ygrass_sB, FALSE, FALSE,
6157 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_DOWN
6160 Ygrass_wB, FALSE, FALSE,
6161 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_LEFT
6169 Ydirt_nB, FALSE, FALSE,
6170 EL_SAND, ACTION_DIGGING, MV_BIT_UP
6173 Ydirt_eB, FALSE, FALSE,
6174 EL_SAND, ACTION_DIGGING, MV_BIT_RIGHT
6177 Ydirt_sB, FALSE, FALSE,
6178 EL_SAND, ACTION_DIGGING, MV_BIT_DOWN
6181 Ydirt_wB, FALSE, FALSE,
6182 EL_SAND, ACTION_DIGGING, MV_BIT_LEFT
6186 Xandroid, TRUE, FALSE,
6187 EL_EMC_ANDROID, ACTION_ACTIVE, -1
6190 Xandroid_1_n, FALSE, FALSE,
6191 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
6194 Xandroid_2_n, FALSE, FALSE,
6195 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
6198 Xandroid_1_e, FALSE, FALSE,
6199 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
6202 Xandroid_2_e, FALSE, FALSE,
6203 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
6206 Xandroid_1_w, FALSE, FALSE,
6207 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
6210 Xandroid_2_w, FALSE, FALSE,
6211 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
6214 Xandroid_1_s, FALSE, FALSE,
6215 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
6218 Xandroid_2_s, FALSE, FALSE,
6219 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
6222 Yandroid_n, FALSE, FALSE,
6223 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
6226 Yandroid_nB, FALSE, TRUE,
6227 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
6230 Yandroid_ne, FALSE, FALSE,
6231 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPRIGHT
6234 Yandroid_neB, FALSE, TRUE,
6235 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPRIGHT
6238 Yandroid_e, FALSE, FALSE,
6239 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
6242 Yandroid_eB, FALSE, TRUE,
6243 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
6246 Yandroid_se, FALSE, FALSE,
6247 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNRIGHT
6250 Yandroid_seB, FALSE, TRUE,
6251 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNRIGHT
6254 Yandroid_s, FALSE, FALSE,
6255 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
6258 Yandroid_sB, FALSE, TRUE,
6259 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
6262 Yandroid_sw, FALSE, FALSE,
6263 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNLEFT
6266 Yandroid_swB, FALSE, TRUE,
6267 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNLEFT
6270 Yandroid_w, FALSE, FALSE,
6271 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
6274 Yandroid_wB, FALSE, TRUE,
6275 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
6278 Yandroid_nw, FALSE, FALSE,
6279 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPLEFT
6282 Yandroid_nwB, FALSE, TRUE,
6283 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPLEFT
6287 Xeater_n, TRUE, FALSE,
6288 EL_YAMYAM_UP, -1, -1
6291 Xeater_e, TRUE, FALSE,
6292 EL_YAMYAM_RIGHT, -1, -1
6295 Xeater_w, TRUE, FALSE,
6296 EL_YAMYAM_LEFT, -1, -1
6299 Xeater_s, TRUE, FALSE,
6300 EL_YAMYAM_DOWN, -1, -1
6303 Yeater_n, FALSE, FALSE,
6304 EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
6307 Yeater_nB, FALSE, TRUE,
6308 EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
6311 Yeater_e, FALSE, FALSE,
6312 EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
6315 Yeater_eB, FALSE, TRUE,
6316 EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
6319 Yeater_s, FALSE, FALSE,
6320 EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
6323 Yeater_sB, FALSE, TRUE,
6324 EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
6327 Yeater_w, FALSE, FALSE,
6328 EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
6331 Yeater_wB, FALSE, TRUE,
6332 EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
6335 Yeater_stone, FALSE, FALSE,
6336 EL_YAMYAM, ACTION_SMASHED_BY_ROCK, -1
6339 Yeater_spring, FALSE, FALSE,
6340 EL_YAMYAM, ACTION_SMASHED_BY_SPRING, -1
6344 Xalien, TRUE, FALSE,
6348 Xalien_pause, FALSE, FALSE,
6352 Yalien_n, FALSE, FALSE,
6353 EL_ROBOT, ACTION_MOVING, MV_BIT_UP
6356 Yalien_nB, FALSE, TRUE,
6357 EL_ROBOT, ACTION_MOVING, MV_BIT_UP
6360 Yalien_e, FALSE, FALSE,
6361 EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
6364 Yalien_eB, FALSE, TRUE,
6365 EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
6368 Yalien_s, FALSE, FALSE,
6369 EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
6372 Yalien_sB, FALSE, TRUE,
6373 EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
6376 Yalien_w, FALSE, FALSE,
6377 EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
6380 Yalien_wB, FALSE, TRUE,
6381 EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
6384 Yalien_stone, FALSE, FALSE,
6385 EL_ROBOT, ACTION_SMASHED_BY_ROCK, -1
6388 Yalien_spring, FALSE, FALSE,
6389 EL_ROBOT, ACTION_SMASHED_BY_SPRING, -1
6393 Xbug_1_n, TRUE, FALSE,
6397 Xbug_1_e, TRUE, FALSE,
6398 EL_BUG_RIGHT, -1, -1
6401 Xbug_1_s, TRUE, FALSE,
6405 Xbug_1_w, TRUE, FALSE,
6409 Xbug_2_n, FALSE, FALSE,
6413 Xbug_2_e, FALSE, FALSE,
6414 EL_BUG_RIGHT, -1, -1
6417 Xbug_2_s, FALSE, FALSE,
6421 Xbug_2_w, FALSE, FALSE,
6425 Ybug_n, FALSE, FALSE,
6426 EL_BUG, ACTION_MOVING, MV_BIT_UP
6429 Ybug_nB, FALSE, TRUE,
6430 EL_BUG, ACTION_MOVING, MV_BIT_UP
6433 Ybug_e, FALSE, FALSE,
6434 EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
6437 Ybug_eB, FALSE, TRUE,
6438 EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
6441 Ybug_s, FALSE, FALSE,
6442 EL_BUG, ACTION_MOVING, MV_BIT_DOWN
6445 Ybug_sB, FALSE, TRUE,
6446 EL_BUG, ACTION_MOVING, MV_BIT_DOWN
6449 Ybug_w, FALSE, FALSE,
6450 EL_BUG, ACTION_MOVING, MV_BIT_LEFT
6453 Ybug_wB, FALSE, TRUE,
6454 EL_BUG, ACTION_MOVING, MV_BIT_LEFT
6457 Ybug_w_n, FALSE, FALSE,
6458 EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
6461 Ybug_n_e, FALSE, FALSE,
6462 EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
6465 Ybug_e_s, FALSE, FALSE,
6466 EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
6469 Ybug_s_w, FALSE, FALSE,
6470 EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
6473 Ybug_e_n, FALSE, FALSE,
6474 EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
6477 Ybug_s_e, FALSE, FALSE,
6478 EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
6481 Ybug_w_s, FALSE, FALSE,
6482 EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
6485 Ybug_n_w, FALSE, FALSE,
6486 EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
6489 Ybug_stone, FALSE, FALSE,
6490 EL_BUG, ACTION_SMASHED_BY_ROCK, -1
6493 Ybug_spring, FALSE, FALSE,
6494 EL_BUG, ACTION_SMASHED_BY_SPRING, -1
6498 Xtank_1_n, TRUE, FALSE,
6499 EL_SPACESHIP_UP, -1, -1
6502 Xtank_1_e, TRUE, FALSE,
6503 EL_SPACESHIP_RIGHT, -1, -1
6506 Xtank_1_s, TRUE, FALSE,
6507 EL_SPACESHIP_DOWN, -1, -1
6510 Xtank_1_w, TRUE, FALSE,
6511 EL_SPACESHIP_LEFT, -1, -1
6514 Xtank_2_n, FALSE, FALSE,
6515 EL_SPACESHIP_UP, -1, -1
6518 Xtank_2_e, FALSE, FALSE,
6519 EL_SPACESHIP_RIGHT, -1, -1
6522 Xtank_2_s, FALSE, FALSE,
6523 EL_SPACESHIP_DOWN, -1, -1
6526 Xtank_2_w, FALSE, FALSE,
6527 EL_SPACESHIP_LEFT, -1, -1
6530 Ytank_n, FALSE, FALSE,
6531 EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
6534 Ytank_nB, FALSE, TRUE,
6535 EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
6538 Ytank_e, FALSE, FALSE,
6539 EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
6542 Ytank_eB, FALSE, TRUE,
6543 EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
6546 Ytank_s, FALSE, FALSE,
6547 EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
6550 Ytank_sB, FALSE, TRUE,
6551 EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
6554 Ytank_w, FALSE, FALSE,
6555 EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
6558 Ytank_wB, FALSE, TRUE,
6559 EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
6562 Ytank_w_n, FALSE, FALSE,
6563 EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
6566 Ytank_n_e, FALSE, FALSE,
6567 EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
6570 Ytank_e_s, FALSE, FALSE,
6571 EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
6574 Ytank_s_w, FALSE, FALSE,
6575 EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
6578 Ytank_e_n, FALSE, FALSE,
6579 EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
6582 Ytank_s_e, FALSE, FALSE,
6583 EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
6586 Ytank_w_s, FALSE, FALSE,
6587 EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
6590 Ytank_n_w, FALSE, FALSE,
6591 EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
6594 Ytank_stone, FALSE, FALSE,
6595 EL_SPACESHIP, ACTION_SMASHED_BY_ROCK, -1
6598 Ytank_spring, FALSE, FALSE,
6599 EL_SPACESHIP, ACTION_SMASHED_BY_SPRING, -1
6603 Xemerald, TRUE, FALSE,
6607 Xemerald_pause, FALSE, FALSE,
6611 Xemerald_fall, FALSE, FALSE,
6615 Xemerald_shine, FALSE, FALSE,
6616 EL_EMERALD, ACTION_TWINKLING, -1
6619 Yemerald_s, FALSE, FALSE,
6620 EL_EMERALD, ACTION_FALLING, -1
6623 Yemerald_sB, FALSE, TRUE,
6624 EL_EMERALD, ACTION_FALLING, -1
6627 Yemerald_e, FALSE, FALSE,
6628 EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
6631 Yemerald_eB, FALSE, TRUE,
6632 EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
6635 Yemerald_w, FALSE, FALSE,
6636 EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
6639 Yemerald_wB, FALSE, TRUE,
6640 EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
6643 Yemerald_blank, FALSE, FALSE,
6644 EL_EMERALD, ACTION_COLLECTING, -1
6648 Xdiamond, TRUE, FALSE,
6652 Xdiamond_pause, FALSE, FALSE,
6656 Xdiamond_fall, FALSE, FALSE,
6660 Xdiamond_shine, FALSE, FALSE,
6661 EL_DIAMOND, ACTION_TWINKLING, -1
6664 Ydiamond_s, FALSE, FALSE,
6665 EL_DIAMOND, ACTION_FALLING, -1
6668 Ydiamond_sB, FALSE, TRUE,
6669 EL_DIAMOND, ACTION_FALLING, -1
6672 Ydiamond_e, FALSE, FALSE,
6673 EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
6676 Ydiamond_eB, FALSE, TRUE,
6677 EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
6680 Ydiamond_w, FALSE, FALSE,
6681 EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
6684 Ydiamond_wB, FALSE, TRUE,
6685 EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
6688 Ydiamond_blank, FALSE, FALSE,
6689 EL_DIAMOND, ACTION_COLLECTING, -1
6692 Ydiamond_stone, FALSE, FALSE,
6693 EL_DIAMOND, ACTION_SMASHED_BY_ROCK, -1
6697 Xstone, TRUE, FALSE,
6701 Xstone_pause, FALSE, FALSE,
6705 Xstone_fall, FALSE, FALSE,
6709 Ystone_s, FALSE, FALSE,
6710 EL_ROCK, ACTION_FALLING, -1
6713 Ystone_sB, FALSE, TRUE,
6714 EL_ROCK, ACTION_FALLING, -1
6717 Ystone_e, FALSE, FALSE,
6718 EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
6721 Ystone_eB, FALSE, TRUE,
6722 EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
6725 Ystone_w, FALSE, FALSE,
6726 EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
6729 Ystone_wB, FALSE, TRUE,
6730 EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
6738 Xbomb_pause, FALSE, FALSE,
6742 Xbomb_fall, FALSE, FALSE,
6746 Ybomb_s, FALSE, FALSE,
6747 EL_BOMB, ACTION_FALLING, -1
6750 Ybomb_sB, FALSE, TRUE,
6751 EL_BOMB, ACTION_FALLING, -1
6754 Ybomb_e, FALSE, FALSE,
6755 EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
6758 Ybomb_eB, FALSE, TRUE,
6759 EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
6762 Ybomb_w, FALSE, FALSE,
6763 EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
6766 Ybomb_wB, FALSE, TRUE,
6767 EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
6770 Ybomb_blank, FALSE, FALSE,
6771 EL_BOMB, ACTION_ACTIVATING, -1
6779 Xnut_pause, FALSE, FALSE,
6783 Xnut_fall, FALSE, FALSE,
6787 Ynut_s, FALSE, FALSE,
6788 EL_NUT, ACTION_FALLING, -1
6791 Ynut_sB, FALSE, TRUE,
6792 EL_NUT, ACTION_FALLING, -1
6795 Ynut_e, FALSE, FALSE,
6796 EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
6799 Ynut_eB, FALSE, TRUE,
6800 EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
6803 Ynut_w, FALSE, FALSE,
6804 EL_NUT, ACTION_MOVING, MV_BIT_LEFT
6807 Ynut_wB, FALSE, TRUE,
6808 EL_NUT, ACTION_MOVING, MV_BIT_LEFT
6811 Ynut_stone, FALSE, FALSE,
6812 EL_NUT, ACTION_BREAKING, -1
6816 Xspring, TRUE, FALSE,
6820 Xspring_pause, FALSE, FALSE,
6824 Xspring_e, TRUE, FALSE,
6825 EL_SPRING_RIGHT, -1, -1
6828 Xspring_w, TRUE, FALSE,
6829 EL_SPRING_LEFT, -1, -1
6832 Xspring_fall, FALSE, FALSE,
6836 Yspring_s, FALSE, FALSE,
6837 EL_SPRING, ACTION_FALLING, -1
6840 Yspring_sB, FALSE, TRUE,
6841 EL_SPRING, ACTION_FALLING, -1
6844 Yspring_e, FALSE, FALSE,
6845 EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
6848 Yspring_eB, FALSE, TRUE,
6849 EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
6852 Yspring_w, FALSE, FALSE,
6853 EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
6856 Yspring_wB, FALSE, TRUE,
6857 EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
6860 Yspring_alien_e, FALSE, FALSE,
6861 EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
6864 Yspring_alien_eB, FALSE, TRUE,
6865 EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
6868 Yspring_alien_w, FALSE, FALSE,
6869 EL_SPRING, ACTION_EATING, MV_BIT_LEFT
6872 Yspring_alien_wB, FALSE, TRUE,
6873 EL_SPRING, ACTION_EATING, MV_BIT_LEFT
6877 Xpush_emerald_e, FALSE, FALSE,
6878 EL_EMERALD, -1, MV_BIT_RIGHT
6881 Xpush_emerald_w, FALSE, FALSE,
6882 EL_EMERALD, -1, MV_BIT_LEFT
6885 Xpush_diamond_e, FALSE, FALSE,
6886 EL_DIAMOND, -1, MV_BIT_RIGHT
6889 Xpush_diamond_w, FALSE, FALSE,
6890 EL_DIAMOND, -1, MV_BIT_LEFT
6893 Xpush_stone_e, FALSE, FALSE,
6894 EL_ROCK, -1, MV_BIT_RIGHT
6897 Xpush_stone_w, FALSE, FALSE,
6898 EL_ROCK, -1, MV_BIT_LEFT
6901 Xpush_bomb_e, FALSE, FALSE,
6902 EL_BOMB, -1, MV_BIT_RIGHT
6905 Xpush_bomb_w, FALSE, FALSE,
6906 EL_BOMB, -1, MV_BIT_LEFT
6909 Xpush_nut_e, FALSE, FALSE,
6910 EL_NUT, -1, MV_BIT_RIGHT
6913 Xpush_nut_w, FALSE, FALSE,
6914 EL_NUT, -1, MV_BIT_LEFT
6917 Xpush_spring_e, FALSE, FALSE,
6918 EL_SPRING_RIGHT, -1, MV_BIT_RIGHT
6921 Xpush_spring_w, FALSE, FALSE,
6922 EL_SPRING_LEFT, -1, MV_BIT_LEFT
6926 Xdynamite, TRUE, FALSE,
6927 EL_EM_DYNAMITE, -1, -1
6930 Ydynamite_blank, FALSE, FALSE,
6931 EL_EM_DYNAMITE, ACTION_COLLECTING, -1
6934 Xdynamite_1, TRUE, FALSE,
6935 EL_EM_DYNAMITE_ACTIVE, -1, -1
6938 Xdynamite_2, FALSE, FALSE,
6939 EL_EM_DYNAMITE_ACTIVE, -1, -1
6942 Xdynamite_3, FALSE, FALSE,
6943 EL_EM_DYNAMITE_ACTIVE, -1, -1
6946 Xdynamite_4, FALSE, FALSE,
6947 EL_EM_DYNAMITE_ACTIVE, -1, -1
6951 Xkey_1, TRUE, FALSE,
6955 Xkey_2, TRUE, FALSE,
6959 Xkey_3, TRUE, FALSE,
6963 Xkey_4, TRUE, FALSE,
6967 Xkey_5, TRUE, FALSE,
6968 EL_EMC_KEY_5, -1, -1
6971 Xkey_6, TRUE, FALSE,
6972 EL_EMC_KEY_6, -1, -1
6975 Xkey_7, TRUE, FALSE,
6976 EL_EMC_KEY_7, -1, -1
6979 Xkey_8, TRUE, FALSE,
6980 EL_EMC_KEY_8, -1, -1
6984 Xdoor_1, TRUE, FALSE,
6985 EL_EM_GATE_1, -1, -1
6988 Xdoor_2, TRUE, FALSE,
6989 EL_EM_GATE_2, -1, -1
6992 Xdoor_3, TRUE, FALSE,
6993 EL_EM_GATE_3, -1, -1
6996 Xdoor_4, TRUE, FALSE,
6997 EL_EM_GATE_4, -1, -1
7000 Xdoor_5, TRUE, FALSE,
7001 EL_EMC_GATE_5, -1, -1
7004 Xdoor_6, TRUE, FALSE,
7005 EL_EMC_GATE_6, -1, -1
7008 Xdoor_7, TRUE, FALSE,
7009 EL_EMC_GATE_7, -1, -1
7012 Xdoor_8, TRUE, FALSE,
7013 EL_EMC_GATE_8, -1, -1
7017 Xfake_door_1, TRUE, FALSE,
7018 EL_EM_GATE_1_GRAY, -1, -1
7021 Xfake_door_2, TRUE, FALSE,
7022 EL_EM_GATE_2_GRAY, -1, -1
7025 Xfake_door_3, TRUE, FALSE,
7026 EL_EM_GATE_3_GRAY, -1, -1
7029 Xfake_door_4, TRUE, FALSE,
7030 EL_EM_GATE_4_GRAY, -1, -1
7033 Xfake_door_5, TRUE, FALSE,
7034 EL_EMC_GATE_5_GRAY, -1, -1
7037 Xfake_door_6, TRUE, FALSE,
7038 EL_EMC_GATE_6_GRAY, -1, -1
7041 Xfake_door_7, TRUE, FALSE,
7042 EL_EMC_GATE_7_GRAY, -1, -1
7045 Xfake_door_8, TRUE, FALSE,
7046 EL_EMC_GATE_8_GRAY, -1, -1
7050 Xballoon, TRUE, FALSE,
7054 Yballoon_n, FALSE, FALSE,
7055 EL_BALLOON, ACTION_MOVING, MV_BIT_UP
7058 Yballoon_nB, FALSE, TRUE,
7059 EL_BALLOON, ACTION_MOVING, MV_BIT_UP
7062 Yballoon_e, FALSE, FALSE,
7063 EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
7066 Yballoon_eB, FALSE, TRUE,
7067 EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
7070 Yballoon_s, FALSE, FALSE,
7071 EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
7074 Yballoon_sB, FALSE, TRUE,
7075 EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
7078 Yballoon_w, FALSE, FALSE,
7079 EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
7082 Yballoon_wB, FALSE, TRUE,
7083 EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
7087 Xball_1, TRUE, FALSE,
7088 EL_EMC_MAGIC_BALL, -1, -1
7091 Yball_1, FALSE, FALSE,
7092 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
7095 Xball_2, FALSE, FALSE,
7096 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
7099 Yball_2, FALSE, FALSE,
7100 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
7103 Yball_blank, FALSE, FALSE,
7104 EL_EMC_MAGIC_BALL, ACTION_DROPPING, -1
7108 Xamoeba_1, TRUE, FALSE,
7109 EL_AMOEBA_DRY, ACTION_OTHER, -1
7112 Xamoeba_2, FALSE, FALSE,
7113 EL_AMOEBA_DRY, ACTION_OTHER, -1
7116 Xamoeba_3, FALSE, FALSE,
7117 EL_AMOEBA_DRY, ACTION_OTHER, -1
7120 Xamoeba_4, FALSE, FALSE,
7121 EL_AMOEBA_DRY, ACTION_OTHER, -1
7124 Xamoeba_5, TRUE, FALSE,
7125 EL_AMOEBA_WET, ACTION_OTHER, -1
7128 Xamoeba_6, FALSE, FALSE,
7129 EL_AMOEBA_WET, ACTION_OTHER, -1
7132 Xamoeba_7, FALSE, FALSE,
7133 EL_AMOEBA_WET, ACTION_OTHER, -1
7136 Xamoeba_8, FALSE, FALSE,
7137 EL_AMOEBA_WET, ACTION_OTHER, -1
7142 EL_AMOEBA_DROP, ACTION_GROWING, -1
7145 Xdrip_fall, FALSE, FALSE,
7146 EL_AMOEBA_DROP, -1, -1
7149 Xdrip_stretch, FALSE, FALSE,
7150 EL_AMOEBA_DROP, ACTION_FALLING, -1
7153 Xdrip_stretchB, FALSE, TRUE,
7154 EL_AMOEBA_DROP, ACTION_FALLING, -1
7157 Ydrip_1_s, FALSE, FALSE,
7158 EL_AMOEBA_DROP, ACTION_FALLING, -1
7161 Ydrip_1_sB, FALSE, TRUE,
7162 EL_AMOEBA_DROP, ACTION_FALLING, -1
7165 Ydrip_2_s, FALSE, FALSE,
7166 EL_AMOEBA_DROP, ACTION_FALLING, -1
7169 Ydrip_2_sB, FALSE, TRUE,
7170 EL_AMOEBA_DROP, ACTION_FALLING, -1
7174 Xwonderwall, TRUE, FALSE,
7175 EL_MAGIC_WALL, -1, -1
7178 Ywonderwall, FALSE, FALSE,
7179 EL_MAGIC_WALL, ACTION_ACTIVE, -1
7183 Xwheel, TRUE, FALSE,
7184 EL_ROBOT_WHEEL, -1, -1
7187 Ywheel, FALSE, FALSE,
7188 EL_ROBOT_WHEEL, ACTION_ACTIVE, -1
7192 Xswitch, TRUE, FALSE,
7193 EL_EMC_MAGIC_BALL_SWITCH, -1, -1
7196 Yswitch, FALSE, FALSE,
7197 EL_EMC_MAGIC_BALL_SWITCH, ACTION_ACTIVE, -1
7201 Xbumper, TRUE, FALSE,
7202 EL_EMC_SPRING_BUMPER, -1, -1
7205 Ybumper, FALSE, FALSE,
7206 EL_EMC_SPRING_BUMPER, ACTION_ACTIVE, -1
7210 Xacid_nw, TRUE, FALSE,
7211 EL_ACID_POOL_TOPLEFT, -1, -1
7214 Xacid_ne, TRUE, FALSE,
7215 EL_ACID_POOL_TOPRIGHT, -1, -1
7218 Xacid_sw, TRUE, FALSE,
7219 EL_ACID_POOL_BOTTOMLEFT, -1, -1
7222 Xacid_s, TRUE, FALSE,
7223 EL_ACID_POOL_BOTTOM, -1, -1
7226 Xacid_se, TRUE, FALSE,
7227 EL_ACID_POOL_BOTTOMRIGHT, -1, -1
7231 Xfake_blank, TRUE, FALSE,
7232 EL_INVISIBLE_WALL, -1, -1
7235 Yfake_blank, FALSE, FALSE,
7236 EL_INVISIBLE_WALL, ACTION_ACTIVE, -1
7240 Xfake_grass, TRUE, FALSE,
7241 EL_EMC_FAKE_GRASS, -1, -1
7244 Yfake_grass, FALSE, FALSE,
7245 EL_EMC_FAKE_GRASS, ACTION_ACTIVE, -1
7249 Xfake_amoeba, TRUE, FALSE,
7250 EL_EMC_DRIPPER, -1, -1
7253 Yfake_amoeba, FALSE, FALSE,
7254 EL_EMC_DRIPPER, ACTION_ACTIVE, -1
7258 Xlenses, TRUE, FALSE,
7259 EL_EMC_LENSES, -1, -1
7263 Xmagnify, TRUE, FALSE,
7264 EL_EMC_MAGNIFIER, -1, -1
7269 EL_QUICKSAND_EMPTY, -1, -1
7272 Xsand_stone, TRUE, FALSE,
7273 EL_QUICKSAND_FULL, -1, -1
7276 Xsand_stonein_1, FALSE, TRUE,
7277 EL_ROCK, ACTION_FILLING, -1
7280 Xsand_stonein_2, FALSE, TRUE,
7281 EL_ROCK, ACTION_FILLING, -1
7284 Xsand_stonein_3, FALSE, TRUE,
7285 EL_ROCK, ACTION_FILLING, -1
7288 Xsand_stonein_4, FALSE, TRUE,
7289 EL_ROCK, ACTION_FILLING, -1
7292 Xsand_sandstone_1, FALSE, FALSE,
7293 EL_QUICKSAND_FILLING, -1, -1
7296 Xsand_sandstone_2, FALSE, FALSE,
7297 EL_QUICKSAND_FILLING, -1, -1
7300 Xsand_sandstone_3, FALSE, FALSE,
7301 EL_QUICKSAND_FILLING, -1, -1
7304 Xsand_sandstone_4, FALSE, FALSE,
7305 EL_QUICKSAND_FILLING, -1, -1
7308 Xsand_stonesand_1, FALSE, FALSE,
7309 EL_QUICKSAND_EMPTYING, -1, -1
7312 Xsand_stonesand_2, FALSE, FALSE,
7313 EL_QUICKSAND_EMPTYING, -1, -1
7316 Xsand_stonesand_3, FALSE, FALSE,
7317 EL_QUICKSAND_EMPTYING, -1, -1
7320 Xsand_stonesand_4, FALSE, FALSE,
7321 EL_QUICKSAND_EMPTYING, -1, -1
7324 Xsand_stoneout_1, FALSE, FALSE,
7325 EL_ROCK, ACTION_EMPTYING, -1
7328 Xsand_stoneout_2, FALSE, FALSE,
7329 EL_ROCK, ACTION_EMPTYING, -1
7332 Xsand_stonesand_quickout_1, FALSE, FALSE,
7333 EL_QUICKSAND_EMPTYING, -1, -1
7336 Xsand_stonesand_quickout_2, FALSE, FALSE,
7337 EL_QUICKSAND_EMPTYING, -1, -1
7341 Xslide_ns, TRUE, FALSE,
7342 EL_EXPANDABLE_WALL_VERTICAL, -1, -1
7345 Yslide_ns_blank, FALSE, FALSE,
7346 EL_EXPANDABLE_WALL_VERTICAL, ACTION_GROWING, -1
7349 Xslide_ew, TRUE, FALSE,
7350 EL_EXPANDABLE_WALL_HORIZONTAL, -1, -1
7353 Yslide_ew_blank, FALSE, FALSE,
7354 EL_EXPANDABLE_WALL_HORIZONTAL, ACTION_GROWING, -1
7358 Xwind_n, TRUE, FALSE,
7359 EL_BALLOON_SWITCH_UP, -1, -1
7362 Xwind_e, TRUE, FALSE,
7363 EL_BALLOON_SWITCH_RIGHT, -1, -1
7366 Xwind_s, TRUE, FALSE,
7367 EL_BALLOON_SWITCH_DOWN, -1, -1
7370 Xwind_w, TRUE, FALSE,
7371 EL_BALLOON_SWITCH_LEFT, -1, -1
7374 Xwind_any, TRUE, FALSE,
7375 EL_BALLOON_SWITCH_ANY, -1, -1
7378 Xwind_stop, TRUE, FALSE,
7379 EL_BALLOON_SWITCH_NONE, -1, -1
7384 EL_EM_EXIT_CLOSED, -1, -1
7387 Xexit_1, TRUE, FALSE,
7388 EL_EM_EXIT_OPEN, -1, -1
7391 Xexit_2, FALSE, FALSE,
7392 EL_EM_EXIT_OPEN, -1, -1
7395 Xexit_3, FALSE, FALSE,
7396 EL_EM_EXIT_OPEN, -1, -1
7400 Xpause, FALSE, FALSE,
7405 Xwall_1, TRUE, FALSE,
7409 Xwall_2, TRUE, FALSE,
7410 EL_EMC_WALL_14, -1, -1
7413 Xwall_3, TRUE, FALSE,
7414 EL_EMC_WALL_15, -1, -1
7417 Xwall_4, TRUE, FALSE,
7418 EL_EMC_WALL_16, -1, -1
7422 Xroundwall_1, TRUE, FALSE,
7423 EL_WALL_SLIPPERY, -1, -1
7426 Xroundwall_2, TRUE, FALSE,
7427 EL_EMC_WALL_SLIPPERY_2, -1, -1
7430 Xroundwall_3, TRUE, FALSE,
7431 EL_EMC_WALL_SLIPPERY_3, -1, -1
7434 Xroundwall_4, TRUE, FALSE,
7435 EL_EMC_WALL_SLIPPERY_4, -1, -1
7439 Xsteel_1, TRUE, FALSE,
7440 EL_STEELWALL, -1, -1
7443 Xsteel_2, TRUE, FALSE,
7444 EL_EMC_STEELWALL_2, -1, -1
7447 Xsteel_3, TRUE, FALSE,
7448 EL_EMC_STEELWALL_3, -1, -1
7451 Xsteel_4, TRUE, FALSE,
7452 EL_EMC_STEELWALL_4, -1, -1
7456 Xdecor_1, TRUE, FALSE,
7457 EL_EMC_WALL_8, -1, -1
7460 Xdecor_2, TRUE, FALSE,
7461 EL_EMC_WALL_6, -1, -1
7464 Xdecor_3, TRUE, FALSE,
7465 EL_EMC_WALL_4, -1, -1
7468 Xdecor_4, TRUE, FALSE,
7469 EL_EMC_WALL_7, -1, -1
7472 Xdecor_5, TRUE, FALSE,
7473 EL_EMC_WALL_5, -1, -1
7476 Xdecor_6, TRUE, FALSE,
7477 EL_EMC_WALL_9, -1, -1
7480 Xdecor_7, TRUE, FALSE,
7481 EL_EMC_WALL_10, -1, -1
7484 Xdecor_8, TRUE, FALSE,
7485 EL_EMC_WALL_1, -1, -1
7488 Xdecor_9, TRUE, FALSE,
7489 EL_EMC_WALL_2, -1, -1
7492 Xdecor_10, TRUE, FALSE,
7493 EL_EMC_WALL_3, -1, -1
7496 Xdecor_11, TRUE, FALSE,
7497 EL_EMC_WALL_11, -1, -1
7500 Xdecor_12, TRUE, FALSE,
7501 EL_EMC_WALL_12, -1, -1
7505 Xalpha_0, TRUE, FALSE,
7506 EL_CHAR('0'), -1, -1
7509 Xalpha_1, TRUE, FALSE,
7510 EL_CHAR('1'), -1, -1
7513 Xalpha_2, TRUE, FALSE,
7514 EL_CHAR('2'), -1, -1
7517 Xalpha_3, TRUE, FALSE,
7518 EL_CHAR('3'), -1, -1
7521 Xalpha_4, TRUE, FALSE,
7522 EL_CHAR('4'), -1, -1
7525 Xalpha_5, TRUE, FALSE,
7526 EL_CHAR('5'), -1, -1
7529 Xalpha_6, TRUE, FALSE,
7530 EL_CHAR('6'), -1, -1
7533 Xalpha_7, TRUE, FALSE,
7534 EL_CHAR('7'), -1, -1
7537 Xalpha_8, TRUE, FALSE,
7538 EL_CHAR('8'), -1, -1
7541 Xalpha_9, TRUE, FALSE,
7542 EL_CHAR('9'), -1, -1
7545 Xalpha_excla, TRUE, FALSE,
7546 EL_CHAR('!'), -1, -1
7549 Xalpha_apost, TRUE, FALSE,
7550 EL_CHAR('\''), -1, -1
7553 Xalpha_comma, TRUE, FALSE,
7554 EL_CHAR(','), -1, -1
7557 Xalpha_minus, TRUE, FALSE,
7558 EL_CHAR('-'), -1, -1
7561 Xalpha_perio, TRUE, FALSE,
7562 EL_CHAR('.'), -1, -1
7565 Xalpha_colon, TRUE, FALSE,
7566 EL_CHAR(':'), -1, -1
7569 Xalpha_quest, TRUE, FALSE,
7570 EL_CHAR('?'), -1, -1
7573 Xalpha_a, TRUE, FALSE,
7574 EL_CHAR('A'), -1, -1
7577 Xalpha_b, TRUE, FALSE,
7578 EL_CHAR('B'), -1, -1
7581 Xalpha_c, TRUE, FALSE,
7582 EL_CHAR('C'), -1, -1
7585 Xalpha_d, TRUE, FALSE,
7586 EL_CHAR('D'), -1, -1
7589 Xalpha_e, TRUE, FALSE,
7590 EL_CHAR('E'), -1, -1
7593 Xalpha_f, TRUE, FALSE,
7594 EL_CHAR('F'), -1, -1
7597 Xalpha_g, TRUE, FALSE,
7598 EL_CHAR('G'), -1, -1
7601 Xalpha_h, TRUE, FALSE,
7602 EL_CHAR('H'), -1, -1
7605 Xalpha_i, TRUE, FALSE,
7606 EL_CHAR('I'), -1, -1
7609 Xalpha_j, TRUE, FALSE,
7610 EL_CHAR('J'), -1, -1
7613 Xalpha_k, TRUE, FALSE,
7614 EL_CHAR('K'), -1, -1
7617 Xalpha_l, TRUE, FALSE,
7618 EL_CHAR('L'), -1, -1
7621 Xalpha_m, TRUE, FALSE,
7622 EL_CHAR('M'), -1, -1
7625 Xalpha_n, TRUE, FALSE,
7626 EL_CHAR('N'), -1, -1
7629 Xalpha_o, TRUE, FALSE,
7630 EL_CHAR('O'), -1, -1
7633 Xalpha_p, TRUE, FALSE,
7634 EL_CHAR('P'), -1, -1
7637 Xalpha_q, TRUE, FALSE,
7638 EL_CHAR('Q'), -1, -1
7641 Xalpha_r, TRUE, FALSE,
7642 EL_CHAR('R'), -1, -1
7645 Xalpha_s, TRUE, FALSE,
7646 EL_CHAR('S'), -1, -1
7649 Xalpha_t, TRUE, FALSE,
7650 EL_CHAR('T'), -1, -1
7653 Xalpha_u, TRUE, FALSE,
7654 EL_CHAR('U'), -1, -1
7657 Xalpha_v, TRUE, FALSE,
7658 EL_CHAR('V'), -1, -1
7661 Xalpha_w, TRUE, FALSE,
7662 EL_CHAR('W'), -1, -1
7665 Xalpha_x, TRUE, FALSE,
7666 EL_CHAR('X'), -1, -1
7669 Xalpha_y, TRUE, FALSE,
7670 EL_CHAR('Y'), -1, -1
7673 Xalpha_z, TRUE, FALSE,
7674 EL_CHAR('Z'), -1, -1
7677 Xalpha_arrow_e, TRUE, FALSE,
7678 EL_CHAR('>'), -1, -1
7681 Xalpha_arrow_w, TRUE, FALSE,
7682 EL_CHAR('<'), -1, -1
7685 Xalpha_copyr, TRUE, FALSE,
7686 EL_CHAR(CHAR_BYTE_COPYRIGHT), -1, -1
7690 Ykey_1_blank, FALSE, FALSE,
7691 EL_EM_KEY_1, ACTION_COLLECTING, -1
7694 Ykey_2_blank, FALSE, FALSE,
7695 EL_EM_KEY_2, ACTION_COLLECTING, -1
7698 Ykey_3_blank, FALSE, FALSE,
7699 EL_EM_KEY_3, ACTION_COLLECTING, -1
7702 Ykey_4_blank, FALSE, FALSE,
7703 EL_EM_KEY_4, ACTION_COLLECTING, -1
7706 Ykey_5_blank, FALSE, FALSE,
7707 EL_EMC_KEY_5, ACTION_COLLECTING, -1
7710 Ykey_6_blank, FALSE, FALSE,
7711 EL_EMC_KEY_6, ACTION_COLLECTING, -1
7714 Ykey_7_blank, FALSE, FALSE,
7715 EL_EMC_KEY_7, ACTION_COLLECTING, -1
7718 Ykey_8_blank, FALSE, FALSE,
7719 EL_EMC_KEY_8, ACTION_COLLECTING, -1
7722 Ylenses_blank, FALSE, FALSE,
7723 EL_EMC_LENSES, ACTION_COLLECTING, -1
7726 Ymagnify_blank, FALSE, FALSE,
7727 EL_EMC_MAGNIFIER, ACTION_COLLECTING, -1
7730 Ygrass_blank, FALSE, FALSE,
7731 EL_EMC_GRASS, ACTION_SNAPPING, -1
7734 Ydirt_blank, FALSE, FALSE,
7735 EL_SAND, ACTION_SNAPPING, -1
7744 static struct Mapping_EM_to_RND_player
7753 em_player_mapping_list[MAX_PLAYERS * PLY_MAX + 1] =
7757 EL_PLAYER_1, ACTION_MOVING, MV_BIT_UP,
7761 EL_PLAYER_1, ACTION_MOVING, MV_BIT_RIGHT,
7765 EL_PLAYER_1, ACTION_MOVING, MV_BIT_DOWN,
7769 EL_PLAYER_1, ACTION_MOVING, MV_BIT_LEFT,
7773 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_UP,
7777 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_RIGHT,
7781 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_DOWN,
7785 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_LEFT,
7789 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_UP,
7793 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_RIGHT,
7797 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_DOWN,
7801 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_LEFT,
7805 EL_PLAYER_2, ACTION_MOVING, MV_BIT_UP,
7809 EL_PLAYER_2, ACTION_MOVING, MV_BIT_RIGHT,
7813 EL_PLAYER_2, ACTION_MOVING, MV_BIT_DOWN,
7817 EL_PLAYER_2, ACTION_MOVING, MV_BIT_LEFT,
7821 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_UP,
7825 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_RIGHT,
7829 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_DOWN,
7833 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_LEFT,
7837 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_UP,
7841 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_RIGHT,
7845 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_DOWN,
7849 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_LEFT,
7853 EL_PLAYER_1, ACTION_DEFAULT, -1,
7857 EL_PLAYER_2, ACTION_DEFAULT, -1,
7861 EL_PLAYER_3, ACTION_MOVING, MV_BIT_UP,
7865 EL_PLAYER_3, ACTION_MOVING, MV_BIT_RIGHT,
7869 EL_PLAYER_3, ACTION_MOVING, MV_BIT_DOWN,
7873 EL_PLAYER_3, ACTION_MOVING, MV_BIT_LEFT,
7877 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_UP,
7881 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_RIGHT,
7885 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_DOWN,
7889 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_LEFT,
7893 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_UP,
7897 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_RIGHT,
7901 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_DOWN,
7905 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_LEFT,
7909 EL_PLAYER_4, ACTION_MOVING, MV_BIT_UP,
7913 EL_PLAYER_4, ACTION_MOVING, MV_BIT_RIGHT,
7917 EL_PLAYER_4, ACTION_MOVING, MV_BIT_DOWN,
7921 EL_PLAYER_4, ACTION_MOVING, MV_BIT_LEFT,
7925 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_UP,
7929 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_RIGHT,
7933 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_DOWN,
7937 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_LEFT,
7941 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_UP,
7945 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_RIGHT,
7949 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_DOWN,
7953 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_LEFT,
7957 EL_PLAYER_3, ACTION_DEFAULT, -1,
7961 EL_PLAYER_4, ACTION_DEFAULT, -1,
7970 int map_element_RND_to_EM_cave(int element_rnd)
7972 static unsigned short mapping_RND_to_EM[NUM_FILE_ELEMENTS];
7973 static boolean mapping_initialized = FALSE;
7975 if (!mapping_initialized)
7979 // return "Xalpha_quest" for all undefined elements in mapping array
7980 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
7981 mapping_RND_to_EM[i] = Xalpha_quest;
7983 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
7984 if (em_object_mapping_list[i].is_rnd_to_em_mapping)
7985 mapping_RND_to_EM[em_object_mapping_list[i].element_rnd] =
7986 em_object_mapping_list[i].element_em;
7988 mapping_initialized = TRUE;
7991 if (element_rnd < 0 || element_rnd >= NUM_FILE_ELEMENTS)
7993 Warn("invalid RND level element %d", element_rnd);
7998 return map_em_element_X_to_C(mapping_RND_to_EM[element_rnd]);
8001 int map_element_EM_to_RND_cave(int element_em_cave)
8003 static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
8004 static boolean mapping_initialized = FALSE;
8006 if (!mapping_initialized)
8010 // return "EL_UNKNOWN" for all undefined elements in mapping array
8011 for (i = 0; i < GAME_TILE_MAX; i++)
8012 mapping_EM_to_RND[i] = EL_UNKNOWN;
8014 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8015 mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
8016 em_object_mapping_list[i].element_rnd;
8018 mapping_initialized = TRUE;
8021 if (element_em_cave < 0 || element_em_cave >= CAVE_TILE_MAX)
8023 Warn("invalid EM cave element %d", element_em_cave);
8028 return mapping_EM_to_RND[map_em_element_C_to_X(element_em_cave)];
8031 int map_element_EM_to_RND_game(int element_em_game)
8033 static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
8034 static boolean mapping_initialized = FALSE;
8036 if (!mapping_initialized)
8040 // return "EL_UNKNOWN" for all undefined elements in mapping array
8041 for (i = 0; i < GAME_TILE_MAX; i++)
8042 mapping_EM_to_RND[i] = EL_UNKNOWN;
8044 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8045 mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
8046 em_object_mapping_list[i].element_rnd;
8048 mapping_initialized = TRUE;
8051 if (element_em_game < 0 || element_em_game >= GAME_TILE_MAX)
8053 Warn("invalid EM game element %d", element_em_game);
8058 return mapping_EM_to_RND[element_em_game];
8061 void map_android_clone_elements_RND_to_EM(struct LevelInfo *level)
8063 struct LevelInfo_EM *level_em = level->native_em_level;
8064 struct CAVE *cav = level_em->cav;
8067 for (i = 0; i < GAME_TILE_MAX; i++)
8068 cav->android_array[i] = Cblank;
8070 for (i = 0; i < level->num_android_clone_elements; i++)
8072 int element_rnd = level->android_clone_element[i];
8073 int element_em_cave = map_element_RND_to_EM_cave(element_rnd);
8075 for (j = 0; em_object_mapping_list[j].element_em != -1; j++)
8076 if (em_object_mapping_list[j].element_rnd == element_rnd)
8077 cav->android_array[em_object_mapping_list[j].element_em] =
8082 void map_android_clone_elements_EM_to_RND(struct LevelInfo *level)
8084 struct LevelInfo_EM *level_em = level->native_em_level;
8085 struct CAVE *cav = level_em->cav;
8088 level->num_android_clone_elements = 0;
8090 for (i = 0; i < GAME_TILE_MAX; i++)
8092 int element_em_cave = cav->android_array[i];
8094 boolean element_found = FALSE;
8096 if (element_em_cave == Cblank)
8099 element_rnd = map_element_EM_to_RND_cave(element_em_cave);
8101 for (j = 0; j < level->num_android_clone_elements; j++)
8102 if (level->android_clone_element[j] == element_rnd)
8103 element_found = TRUE;
8107 level->android_clone_element[level->num_android_clone_elements++] =
8110 if (level->num_android_clone_elements == MAX_ANDROID_ELEMENTS)
8115 if (level->num_android_clone_elements == 0)
8117 level->num_android_clone_elements = 1;
8118 level->android_clone_element[0] = EL_EMPTY;
8122 int map_direction_RND_to_EM(int direction)
8124 return (direction == MV_UP ? 0 :
8125 direction == MV_RIGHT ? 1 :
8126 direction == MV_DOWN ? 2 :
8127 direction == MV_LEFT ? 3 :
8131 int map_direction_EM_to_RND(int direction)
8133 return (direction == 0 ? MV_UP :
8134 direction == 1 ? MV_RIGHT :
8135 direction == 2 ? MV_DOWN :
8136 direction == 3 ? MV_LEFT :
8140 int map_element_RND_to_SP(int element_rnd)
8142 int element_sp = 0x20; // map unknown elements to yellow "hardware"
8144 if (element_rnd >= EL_SP_START &&
8145 element_rnd <= EL_SP_END)
8146 element_sp = element_rnd - EL_SP_START;
8147 else if (element_rnd == EL_EMPTY_SPACE)
8149 else if (element_rnd == EL_INVISIBLE_WALL)
8155 int map_element_SP_to_RND(int element_sp)
8157 int element_rnd = EL_UNKNOWN;
8159 if (element_sp >= 0x00 &&
8161 element_rnd = EL_SP_START + element_sp;
8162 else if (element_sp == 0x28)
8163 element_rnd = EL_INVISIBLE_WALL;
8168 int map_action_SP_to_RND(int action_sp)
8172 case actActive: return ACTION_ACTIVE;
8173 case actImpact: return ACTION_IMPACT;
8174 case actExploding: return ACTION_EXPLODING;
8175 case actDigging: return ACTION_DIGGING;
8176 case actSnapping: return ACTION_SNAPPING;
8177 case actCollecting: return ACTION_COLLECTING;
8178 case actPassing: return ACTION_PASSING;
8179 case actPushing: return ACTION_PUSHING;
8180 case actDropping: return ACTION_DROPPING;
8182 default: return ACTION_DEFAULT;
8186 int map_element_RND_to_MM(int element_rnd)
8188 return (element_rnd >= EL_MM_START_1 &&
8189 element_rnd <= EL_MM_END_1 ?
8190 EL_MM_START_1_NATIVE + element_rnd - EL_MM_START_1 :
8192 element_rnd >= EL_MM_START_2 &&
8193 element_rnd <= EL_MM_END_2 ?
8194 EL_MM_START_2_NATIVE + element_rnd - EL_MM_START_2 :
8196 element_rnd >= EL_CHAR_START &&
8197 element_rnd <= EL_CHAR_END ?
8198 EL_MM_CHAR_START_NATIVE + element_rnd - EL_CHAR_START :
8200 element_rnd >= EL_MM_RUNTIME_START &&
8201 element_rnd <= EL_MM_RUNTIME_END ?
8202 EL_MM_RUNTIME_START_NATIVE + element_rnd - EL_MM_RUNTIME_START :
8204 EL_MM_EMPTY_NATIVE);
8207 int map_element_MM_to_RND(int element_mm)
8209 return (element_mm == EL_MM_EMPTY_NATIVE ||
8210 element_mm == EL_DF_EMPTY_NATIVE ?
8213 element_mm >= EL_MM_START_1_NATIVE &&
8214 element_mm <= EL_MM_END_1_NATIVE ?
8215 EL_MM_START_1 + element_mm - EL_MM_START_1_NATIVE :
8217 element_mm >= EL_MM_START_2_NATIVE &&
8218 element_mm <= EL_MM_END_2_NATIVE ?
8219 EL_MM_START_2 + element_mm - EL_MM_START_2_NATIVE :
8221 element_mm >= EL_MM_CHAR_START_NATIVE &&
8222 element_mm <= EL_MM_CHAR_END_NATIVE ?
8223 EL_CHAR_START + element_mm - EL_MM_CHAR_START_NATIVE :
8225 element_mm >= EL_MM_RUNTIME_START_NATIVE &&
8226 element_mm <= EL_MM_RUNTIME_END_NATIVE ?
8227 EL_MM_RUNTIME_START + element_mm - EL_MM_RUNTIME_START_NATIVE :
8232 int map_action_MM_to_RND(int action_mm)
8234 // all MM actions are defined to exactly match their RND counterparts
8238 int map_sound_MM_to_RND(int sound_mm)
8242 case SND_MM_GAME_LEVELTIME_CHARGING:
8243 return SND_GAME_LEVELTIME_CHARGING;
8245 case SND_MM_GAME_HEALTH_CHARGING:
8246 return SND_GAME_HEALTH_CHARGING;
8249 return SND_UNDEFINED;
8253 int map_mm_wall_element(int element)
8255 return (element >= EL_MM_STEEL_WALL_START &&
8256 element <= EL_MM_STEEL_WALL_END ?
8259 element >= EL_MM_WOODEN_WALL_START &&
8260 element <= EL_MM_WOODEN_WALL_END ?
8263 element >= EL_MM_ICE_WALL_START &&
8264 element <= EL_MM_ICE_WALL_END ?
8267 element >= EL_MM_AMOEBA_WALL_START &&
8268 element <= EL_MM_AMOEBA_WALL_END ?
8271 element >= EL_DF_STEEL_WALL_START &&
8272 element <= EL_DF_STEEL_WALL_END ?
8275 element >= EL_DF_WOODEN_WALL_START &&
8276 element <= EL_DF_WOODEN_WALL_END ?
8282 int map_mm_wall_element_editor(int element)
8286 case EL_MM_STEEL_WALL: return EL_MM_STEEL_WALL_START;
8287 case EL_MM_WOODEN_WALL: return EL_MM_WOODEN_WALL_START;
8288 case EL_MM_ICE_WALL: return EL_MM_ICE_WALL_START;
8289 case EL_MM_AMOEBA_WALL: return EL_MM_AMOEBA_WALL_START;
8290 case EL_DF_STEEL_WALL: return EL_DF_STEEL_WALL_START;
8291 case EL_DF_WOODEN_WALL: return EL_DF_WOODEN_WALL_START;
8293 default: return element;
8297 int get_next_element(int element)
8301 case EL_QUICKSAND_FILLING: return EL_QUICKSAND_FULL;
8302 case EL_QUICKSAND_EMPTYING: return EL_QUICKSAND_EMPTY;
8303 case EL_QUICKSAND_FAST_FILLING: return EL_QUICKSAND_FAST_FULL;
8304 case EL_QUICKSAND_FAST_EMPTYING: return EL_QUICKSAND_FAST_EMPTY;
8305 case EL_MAGIC_WALL_FILLING: return EL_MAGIC_WALL_FULL;
8306 case EL_MAGIC_WALL_EMPTYING: return EL_MAGIC_WALL_ACTIVE;
8307 case EL_BD_MAGIC_WALL_FILLING: return EL_BD_MAGIC_WALL_FULL;
8308 case EL_BD_MAGIC_WALL_EMPTYING: return EL_BD_MAGIC_WALL_ACTIVE;
8309 case EL_DC_MAGIC_WALL_FILLING: return EL_DC_MAGIC_WALL_FULL;
8310 case EL_DC_MAGIC_WALL_EMPTYING: return EL_DC_MAGIC_WALL_ACTIVE;
8311 case EL_AMOEBA_DROPPING: return EL_AMOEBA_WET;
8313 default: return element;
8317 int el2img_mm(int element_mm)
8319 return el2img(map_element_MM_to_RND(element_mm));
8322 int el_act2img_mm(int element_mm, int action)
8324 return el_act2img(map_element_MM_to_RND(element_mm), action);
8327 int el_act_dir2img(int element, int action, int direction)
8329 element = GFX_ELEMENT(element);
8330 direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
8332 // direction_graphic[][] == graphic[] for undefined direction graphics
8333 return element_info[element].direction_graphic[action][direction];
8336 static int el_act_dir2crm(int element, int action, int direction)
8338 element = GFX_ELEMENT(element);
8339 direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
8341 // direction_graphic[][] == graphic[] for undefined direction graphics
8342 return element_info[element].direction_crumbled[action][direction];
8345 int el_act2img(int element, int action)
8347 element = GFX_ELEMENT(element);
8349 return element_info[element].graphic[action];
8352 int el_act2crm(int element, int action)
8354 element = GFX_ELEMENT(element);
8356 return element_info[element].crumbled[action];
8359 int el_dir2img(int element, int direction)
8361 element = GFX_ELEMENT(element);
8363 return el_act_dir2img(element, ACTION_DEFAULT, direction);
8366 int el2baseimg(int element)
8368 return element_info[element].graphic[ACTION_DEFAULT];
8371 int el2img(int element)
8373 element = GFX_ELEMENT(element);
8375 return element_info[element].graphic[ACTION_DEFAULT];
8378 int el2edimg(int element)
8380 element = GFX_ELEMENT(element);
8382 return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
8385 int el2preimg(int element)
8387 element = GFX_ELEMENT(element);
8389 return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
8392 int el2panelimg(int element)
8394 element = GFX_ELEMENT(element);
8396 return element_info[element].special_graphic[GFX_SPECIAL_ARG_PANEL];
8399 int font2baseimg(int font_nr)
8401 return font_info[font_nr].special_graphic[GFX_SPECIAL_ARG_DEFAULT];
8404 int getBeltNrFromBeltElement(int element)
8406 return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
8407 element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
8408 element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
8411 int getBeltNrFromBeltActiveElement(int element)
8413 return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
8414 element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
8415 element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
8418 int getBeltNrFromBeltSwitchElement(int element)
8420 return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
8421 element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
8422 element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
8425 int getBeltDirNrFromBeltElement(int element)
8427 static int belt_base_element[4] =
8429 EL_CONVEYOR_BELT_1_LEFT,
8430 EL_CONVEYOR_BELT_2_LEFT,
8431 EL_CONVEYOR_BELT_3_LEFT,
8432 EL_CONVEYOR_BELT_4_LEFT
8435 int belt_nr = getBeltNrFromBeltElement(element);
8436 int belt_dir_nr = element - belt_base_element[belt_nr];
8438 return (belt_dir_nr % 3);
8441 int getBeltDirNrFromBeltSwitchElement(int element)
8443 static int belt_base_element[4] =
8445 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
8446 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
8447 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
8448 EL_CONVEYOR_BELT_4_SWITCH_LEFT
8451 int belt_nr = getBeltNrFromBeltSwitchElement(element);
8452 int belt_dir_nr = element - belt_base_element[belt_nr];
8454 return (belt_dir_nr % 3);
8457 int getBeltDirFromBeltElement(int element)
8459 static int belt_move_dir[3] =
8466 int belt_dir_nr = getBeltDirNrFromBeltElement(element);
8468 return belt_move_dir[belt_dir_nr];
8471 int getBeltDirFromBeltSwitchElement(int element)
8473 static int belt_move_dir[3] =
8480 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
8482 return belt_move_dir[belt_dir_nr];
8485 int getBeltElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
8487 static int belt_base_element[4] =
8489 EL_CONVEYOR_BELT_1_LEFT,
8490 EL_CONVEYOR_BELT_2_LEFT,
8491 EL_CONVEYOR_BELT_3_LEFT,
8492 EL_CONVEYOR_BELT_4_LEFT
8495 return belt_base_element[belt_nr] + belt_dir_nr;
8498 int getBeltElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
8500 int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
8502 return getBeltElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
8505 int getBeltSwitchElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
8507 static int belt_base_element[4] =
8509 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
8510 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
8511 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
8512 EL_CONVEYOR_BELT_4_SWITCH_LEFT
8515 return belt_base_element[belt_nr] + belt_dir_nr;
8518 int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
8520 int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
8522 return getBeltSwitchElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
8525 boolean swapTiles_EM(boolean is_pre_emc_cave)
8527 return is_pre_emc_cave && leveldir_current->use_emc_tiles;
8530 boolean getTeamMode_EM(void)
8532 return game.team_mode || network_playing;
8535 boolean isActivePlayer_EM(int player_nr)
8537 return stored_player[player_nr].active;
8540 unsigned int InitRND(int seed)
8542 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
8543 return InitEngineRandom_EM(seed);
8544 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
8545 return InitEngineRandom_SP(seed);
8546 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
8547 return InitEngineRandom_MM(seed);
8549 return InitEngineRandom_RND(seed);
8552 static struct Mapping_EM_to_RND_object object_mapping[GAME_TILE_MAX];
8553 static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][PLY_MAX];
8555 static int get_effective_element_EM(int tile, int frame_em)
8557 int element = object_mapping[tile].element_rnd;
8558 int action = object_mapping[tile].action;
8559 boolean is_backside = object_mapping[tile].is_backside;
8560 boolean action_removing = (action == ACTION_DIGGING ||
8561 action == ACTION_SNAPPING ||
8562 action == ACTION_COLLECTING);
8570 return (frame_em > 5 ? EL_EMPTY : element);
8576 else // frame_em == 7
8587 case Ydiamond_stone:
8591 case Xdrip_stretchB:
8607 case Ymagnify_blank:
8610 case Xsand_stonein_1:
8611 case Xsand_stonein_2:
8612 case Xsand_stonein_3:
8613 case Xsand_stonein_4:
8617 return (is_backside || action_removing ? EL_EMPTY : element);
8622 static boolean check_linear_animation_EM(int tile)
8626 case Xsand_stonesand_1:
8627 case Xsand_stonesand_quickout_1:
8628 case Xsand_sandstone_1:
8629 case Xsand_stonein_1:
8630 case Xsand_stoneout_1:
8658 static void set_crumbled_graphics_EM(struct GraphicInfo_EM *g_em,
8659 boolean has_crumbled_graphics,
8660 int crumbled, int sync_frame)
8662 // if element can be crumbled, but certain action graphics are just empty
8663 // space (like instantly snapping sand to empty space in 1 frame), do not
8664 // treat these empty space graphics as crumbled graphics in EMC engine
8665 if (crumbled == IMG_EMPTY_SPACE)
8666 has_crumbled_graphics = FALSE;
8668 if (has_crumbled_graphics)
8670 struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
8671 int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
8672 g_crumbled->anim_delay,
8673 g_crumbled->anim_mode,
8674 g_crumbled->anim_start_frame,
8677 getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
8678 &g_em->crumbled_src_x, &g_em->crumbled_src_y);
8680 g_em->crumbled_border_size = graphic_info[crumbled].border_size;
8681 g_em->crumbled_tile_size = graphic_info[crumbled].tile_size;
8683 g_em->has_crumbled_graphics = TRUE;
8687 g_em->crumbled_bitmap = NULL;
8688 g_em->crumbled_src_x = 0;
8689 g_em->crumbled_src_y = 0;
8690 g_em->crumbled_border_size = 0;
8691 g_em->crumbled_tile_size = 0;
8693 g_em->has_crumbled_graphics = FALSE;
8698 void ResetGfxAnimation_EM(int x, int y, int tile)
8704 void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
8705 int tile, int frame_em, int x, int y)
8707 int action = object_mapping[tile].action;
8708 int direction = object_mapping[tile].direction;
8709 int effective_element = get_effective_element_EM(tile, frame_em);
8710 int graphic = (direction == MV_NONE ?
8711 el_act2img(effective_element, action) :
8712 el_act_dir2img(effective_element, action, direction));
8713 struct GraphicInfo *g = &graphic_info[graphic];
8715 boolean action_removing = (action == ACTION_DIGGING ||
8716 action == ACTION_SNAPPING ||
8717 action == ACTION_COLLECTING);
8718 boolean action_moving = (action == ACTION_FALLING ||
8719 action == ACTION_MOVING ||
8720 action == ACTION_PUSHING ||
8721 action == ACTION_EATING ||
8722 action == ACTION_FILLING ||
8723 action == ACTION_EMPTYING);
8724 boolean action_falling = (action == ACTION_FALLING ||
8725 action == ACTION_FILLING ||
8726 action == ACTION_EMPTYING);
8728 // special case: graphic uses "2nd movement tile" and has defined
8729 // 7 frames for movement animation (or less) => use default graphic
8730 // for last (8th) frame which ends the movement animation
8731 if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
8733 action = ACTION_DEFAULT; // (keep action_* unchanged for now)
8734 graphic = (direction == MV_NONE ?
8735 el_act2img(effective_element, action) :
8736 el_act_dir2img(effective_element, action, direction));
8738 g = &graphic_info[graphic];
8741 if ((action_removing || check_linear_animation_EM(tile)) && frame_em == 0)
8745 else if (action_moving)
8747 boolean is_backside = object_mapping[tile].is_backside;
8751 int direction = object_mapping[tile].direction;
8752 int move_dir = (action_falling ? MV_DOWN : direction);
8757 // !!! TEST !!! NEW !!! DOES NOT WORK RIGHT YET !!!
8758 if (g->double_movement && frame_em == 0)
8762 if (move_dir == MV_LEFT)
8763 GfxFrame[x - 1][y] = GfxFrame[x][y];
8764 else if (move_dir == MV_RIGHT)
8765 GfxFrame[x + 1][y] = GfxFrame[x][y];
8766 else if (move_dir == MV_UP)
8767 GfxFrame[x][y - 1] = GfxFrame[x][y];
8768 else if (move_dir == MV_DOWN)
8769 GfxFrame[x][y + 1] = GfxFrame[x][y];
8776 // special case: animation for Xsand_stonesand_quickout_1/2 twice as fast
8777 if (tile == Xsand_stonesand_quickout_1 ||
8778 tile == Xsand_stonesand_quickout_2)
8782 if (graphic_info[graphic].anim_global_sync)
8783 sync_frame = FrameCounter;
8784 else if (graphic_info[graphic].anim_global_anim_sync)
8785 sync_frame = getGlobalAnimSyncFrame();
8786 else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
8787 sync_frame = GfxFrame[x][y];
8789 sync_frame = 0; // playfield border (pseudo steel)
8791 SetRandomAnimationValue(x, y);
8793 int frame = getAnimationFrame(g->anim_frames,
8796 g->anim_start_frame,
8799 g_em->unique_identifier =
8800 (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
8803 void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
8804 int tile, int frame_em, int x, int y)
8806 int action = object_mapping[tile].action;
8807 int direction = object_mapping[tile].direction;
8808 boolean is_backside = object_mapping[tile].is_backside;
8809 int effective_element = get_effective_element_EM(tile, frame_em);
8810 int effective_action = action;
8811 int graphic = (direction == MV_NONE ?
8812 el_act2img(effective_element, effective_action) :
8813 el_act_dir2img(effective_element, effective_action,
8815 int crumbled = (direction == MV_NONE ?
8816 el_act2crm(effective_element, effective_action) :
8817 el_act_dir2crm(effective_element, effective_action,
8819 int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
8820 int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
8821 boolean has_crumbled_graphics = (base_crumbled != base_graphic);
8822 struct GraphicInfo *g = &graphic_info[graphic];
8825 // special case: graphic uses "2nd movement tile" and has defined
8826 // 7 frames for movement animation (or less) => use default graphic
8827 // for last (8th) frame which ends the movement animation
8828 if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
8830 effective_action = ACTION_DEFAULT;
8831 graphic = (direction == MV_NONE ?
8832 el_act2img(effective_element, effective_action) :
8833 el_act_dir2img(effective_element, effective_action,
8835 crumbled = (direction == MV_NONE ?
8836 el_act2crm(effective_element, effective_action) :
8837 el_act_dir2crm(effective_element, effective_action,
8840 g = &graphic_info[graphic];
8843 if (graphic_info[graphic].anim_global_sync)
8844 sync_frame = FrameCounter;
8845 else if (graphic_info[graphic].anim_global_anim_sync)
8846 sync_frame = getGlobalAnimSyncFrame();
8847 else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
8848 sync_frame = GfxFrame[x][y];
8850 sync_frame = 0; // playfield border (pseudo steel)
8852 SetRandomAnimationValue(x, y);
8854 int frame = getAnimationFrame(g->anim_frames,
8857 g->anim_start_frame,
8860 getGraphicSourceExt(graphic, frame, &g_em->bitmap, &g_em->src_x, &g_em->src_y,
8861 g->double_movement && is_backside);
8863 // (updating the "crumbled" graphic definitions is probably not really needed,
8864 // as animations for crumbled graphics can't be longer than one EMC cycle)
8865 set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
8869 void getGraphicSourcePlayerExt_EM(struct GraphicInfo_EM *g_em,
8870 int player_nr, int anim, int frame_em)
8872 int element = player_mapping[player_nr][anim].element_rnd;
8873 int action = player_mapping[player_nr][anim].action;
8874 int direction = player_mapping[player_nr][anim].direction;
8875 int graphic = (direction == MV_NONE ?
8876 el_act2img(element, action) :
8877 el_act_dir2img(element, action, direction));
8878 struct GraphicInfo *g = &graphic_info[graphic];
8881 InitPlayerGfxAnimation(&stored_player[player_nr], action, direction);
8883 stored_player[player_nr].StepFrame = frame_em;
8885 sync_frame = stored_player[player_nr].Frame;
8887 int frame = getAnimationFrame(g->anim_frames,
8890 g->anim_start_frame,
8893 getGraphicSourceExt(graphic, frame, &g_em->bitmap,
8894 &g_em->src_x, &g_em->src_y, FALSE);
8897 void InitGraphicInfo_EM(void)
8901 // always start with reliable default values
8902 for (i = 0; i < GAME_TILE_MAX; i++)
8904 object_mapping[i].element_rnd = EL_UNKNOWN;
8905 object_mapping[i].is_backside = FALSE;
8906 object_mapping[i].action = ACTION_DEFAULT;
8907 object_mapping[i].direction = MV_NONE;
8910 // always start with reliable default values
8911 for (p = 0; p < MAX_PLAYERS; p++)
8913 for (i = 0; i < PLY_MAX; i++)
8915 player_mapping[p][i].element_rnd = EL_UNKNOWN;
8916 player_mapping[p][i].action = ACTION_DEFAULT;
8917 player_mapping[p][i].direction = MV_NONE;
8921 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8923 int e = em_object_mapping_list[i].element_em;
8925 object_mapping[e].element_rnd = em_object_mapping_list[i].element_rnd;
8926 object_mapping[e].is_backside = em_object_mapping_list[i].is_backside;
8928 if (em_object_mapping_list[i].action != -1)
8929 object_mapping[e].action = em_object_mapping_list[i].action;
8931 if (em_object_mapping_list[i].direction != -1)
8932 object_mapping[e].direction =
8933 MV_DIR_FROM_BIT(em_object_mapping_list[i].direction);
8936 for (i = 0; em_player_mapping_list[i].action_em != -1; i++)
8938 int a = em_player_mapping_list[i].action_em;
8939 int p = em_player_mapping_list[i].player_nr;
8941 player_mapping[p][a].element_rnd = em_player_mapping_list[i].element_rnd;
8943 if (em_player_mapping_list[i].action != -1)
8944 player_mapping[p][a].action = em_player_mapping_list[i].action;
8946 if (em_player_mapping_list[i].direction != -1)
8947 player_mapping[p][a].direction =
8948 MV_DIR_FROM_BIT(em_player_mapping_list[i].direction);
8951 for (i = 0; i < GAME_TILE_MAX; i++)
8953 int element = object_mapping[i].element_rnd;
8954 int action = object_mapping[i].action;
8955 int direction = object_mapping[i].direction;
8956 boolean is_backside = object_mapping[i].is_backside;
8957 boolean action_exploding = ((action == ACTION_EXPLODING ||
8958 action == ACTION_SMASHED_BY_ROCK ||
8959 action == ACTION_SMASHED_BY_SPRING) &&
8960 element != EL_DIAMOND);
8961 boolean action_active = (action == ACTION_ACTIVE);
8962 boolean action_other = (action == ACTION_OTHER);
8964 for (j = 0; j < 8; j++)
8966 int effective_element = get_effective_element_EM(i, j);
8967 int effective_action = (j < 7 ? action :
8968 i == Xdrip_stretch ? action :
8969 i == Xdrip_stretchB ? action :
8970 i == Ydrip_1_s ? action :
8971 i == Ydrip_1_sB ? action :
8972 i == Yball_1 ? action :
8973 i == Xball_2 ? action :
8974 i == Yball_2 ? action :
8975 i == Yball_blank ? action :
8976 i == Ykey_1_blank ? action :
8977 i == Ykey_2_blank ? action :
8978 i == Ykey_3_blank ? action :
8979 i == Ykey_4_blank ? action :
8980 i == Ykey_5_blank ? action :
8981 i == Ykey_6_blank ? action :
8982 i == Ykey_7_blank ? action :
8983 i == Ykey_8_blank ? action :
8984 i == Ylenses_blank ? action :
8985 i == Ymagnify_blank ? action :
8986 i == Ygrass_blank ? action :
8987 i == Ydirt_blank ? action :
8988 i == Xsand_stonein_1 ? action :
8989 i == Xsand_stonein_2 ? action :
8990 i == Xsand_stonein_3 ? action :
8991 i == Xsand_stonein_4 ? action :
8992 i == Xsand_stoneout_1 ? action :
8993 i == Xsand_stoneout_2 ? action :
8994 i == Xboom_android ? ACTION_EXPLODING :
8995 action_exploding ? ACTION_EXPLODING :
8996 action_active ? action :
8997 action_other ? action :
8999 int graphic = (el_act_dir2img(effective_element, effective_action,
9001 int crumbled = (el_act_dir2crm(effective_element, effective_action,
9003 int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
9004 int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
9005 boolean has_action_graphics = (graphic != base_graphic);
9006 boolean has_crumbled_graphics = (base_crumbled != base_graphic);
9007 struct GraphicInfo *g = &graphic_info[graphic];
9008 struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
9011 // ensure to get symmetric 3-frame, 2-delay animations as used in EM
9012 boolean special_animation = (action != ACTION_DEFAULT &&
9013 g->anim_frames == 3 &&
9014 g->anim_delay == 2 &&
9015 g->anim_mode & ANIM_LINEAR);
9016 int sync_frame = (i == Xdrip_stretch ? 7 :
9017 i == Xdrip_stretchB ? 7 :
9018 i == Ydrip_2_s ? j + 8 :
9019 i == Ydrip_2_sB ? j + 8 :
9028 i == Xfake_acid_1 ? 0 :
9029 i == Xfake_acid_2 ? 10 :
9030 i == Xfake_acid_3 ? 20 :
9031 i == Xfake_acid_4 ? 30 :
9032 i == Xfake_acid_5 ? 40 :
9033 i == Xfake_acid_6 ? 50 :
9034 i == Xfake_acid_7 ? 60 :
9035 i == Xfake_acid_8 ? 70 :
9036 i == Xfake_acid_1_player ? 0 :
9037 i == Xfake_acid_2_player ? 10 :
9038 i == Xfake_acid_3_player ? 20 :
9039 i == Xfake_acid_4_player ? 30 :
9040 i == Xfake_acid_5_player ? 40 :
9041 i == Xfake_acid_6_player ? 50 :
9042 i == Xfake_acid_7_player ? 60 :
9043 i == Xfake_acid_8_player ? 70 :
9045 i == Yball_2 ? j + 8 :
9046 i == Yball_blank ? j + 1 :
9047 i == Ykey_1_blank ? j + 1 :
9048 i == Ykey_2_blank ? j + 1 :
9049 i == Ykey_3_blank ? j + 1 :
9050 i == Ykey_4_blank ? j + 1 :
9051 i == Ykey_5_blank ? j + 1 :
9052 i == Ykey_6_blank ? j + 1 :
9053 i == Ykey_7_blank ? j + 1 :
9054 i == Ykey_8_blank ? j + 1 :
9055 i == Ylenses_blank ? j + 1 :
9056 i == Ymagnify_blank ? j + 1 :
9057 i == Ygrass_blank ? j + 1 :
9058 i == Ydirt_blank ? j + 1 :
9059 i == Xamoeba_1 ? 0 :
9060 i == Xamoeba_2 ? 1 :
9061 i == Xamoeba_3 ? 2 :
9062 i == Xamoeba_4 ? 3 :
9063 i == Xamoeba_5 ? 0 :
9064 i == Xamoeba_6 ? 1 :
9065 i == Xamoeba_7 ? 2 :
9066 i == Xamoeba_8 ? 3 :
9067 i == Xexit_2 ? j + 8 :
9068 i == Xexit_3 ? j + 16 :
9069 i == Xdynamite_1 ? 0 :
9070 i == Xdynamite_2 ? 8 :
9071 i == Xdynamite_3 ? 16 :
9072 i == Xdynamite_4 ? 24 :
9073 i == Xsand_stonein_1 ? j + 1 :
9074 i == Xsand_stonein_2 ? j + 9 :
9075 i == Xsand_stonein_3 ? j + 17 :
9076 i == Xsand_stonein_4 ? j + 25 :
9077 i == Xsand_stoneout_1 && j == 0 ? 0 :
9078 i == Xsand_stoneout_1 && j == 1 ? 0 :
9079 i == Xsand_stoneout_1 && j == 2 ? 1 :
9080 i == Xsand_stoneout_1 && j == 3 ? 2 :
9081 i == Xsand_stoneout_1 && j == 4 ? 2 :
9082 i == Xsand_stoneout_1 && j == 5 ? 3 :
9083 i == Xsand_stoneout_1 && j == 6 ? 4 :
9084 i == Xsand_stoneout_1 && j == 7 ? 4 :
9085 i == Xsand_stoneout_2 && j == 0 ? 5 :
9086 i == Xsand_stoneout_2 && j == 1 ? 6 :
9087 i == Xsand_stoneout_2 && j == 2 ? 7 :
9088 i == Xsand_stoneout_2 && j == 3 ? 8 :
9089 i == Xsand_stoneout_2 && j == 4 ? 9 :
9090 i == Xsand_stoneout_2 && j == 5 ? 11 :
9091 i == Xsand_stoneout_2 && j == 6 ? 13 :
9092 i == Xsand_stoneout_2 && j == 7 ? 15 :
9093 i == Xboom_bug && j == 1 ? 2 :
9094 i == Xboom_bug && j == 2 ? 2 :
9095 i == Xboom_bug && j == 3 ? 4 :
9096 i == Xboom_bug && j == 4 ? 4 :
9097 i == Xboom_bug && j == 5 ? 2 :
9098 i == Xboom_bug && j == 6 ? 2 :
9099 i == Xboom_bug && j == 7 ? 0 :
9100 i == Xboom_tank && j == 1 ? 2 :
9101 i == Xboom_tank && j == 2 ? 2 :
9102 i == Xboom_tank && j == 3 ? 4 :
9103 i == Xboom_tank && j == 4 ? 4 :
9104 i == Xboom_tank && j == 5 ? 2 :
9105 i == Xboom_tank && j == 6 ? 2 :
9106 i == Xboom_tank && j == 7 ? 0 :
9107 i == Xboom_android && j == 7 ? 6 :
9108 i == Xboom_1 && j == 1 ? 2 :
9109 i == Xboom_1 && j == 2 ? 2 :
9110 i == Xboom_1 && j == 3 ? 4 :
9111 i == Xboom_1 && j == 4 ? 4 :
9112 i == Xboom_1 && j == 5 ? 6 :
9113 i == Xboom_1 && j == 6 ? 6 :
9114 i == Xboom_1 && j == 7 ? 8 :
9115 i == Xboom_2 && j == 0 ? 8 :
9116 i == Xboom_2 && j == 1 ? 8 :
9117 i == Xboom_2 && j == 2 ? 10 :
9118 i == Xboom_2 && j == 3 ? 10 :
9119 i == Xboom_2 && j == 4 ? 10 :
9120 i == Xboom_2 && j == 5 ? 12 :
9121 i == Xboom_2 && j == 6 ? 12 :
9122 i == Xboom_2 && j == 7 ? 12 :
9123 special_animation && j == 4 ? 3 :
9124 effective_action != action ? 0 :
9126 int frame = getAnimationFrame(g->anim_frames,
9129 g->anim_start_frame,
9132 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y,
9133 g->double_movement && is_backside);
9135 g_em->bitmap = src_bitmap;
9136 g_em->src_x = src_x;
9137 g_em->src_y = src_y;
9138 g_em->src_offset_x = 0;
9139 g_em->src_offset_y = 0;
9140 g_em->dst_offset_x = 0;
9141 g_em->dst_offset_y = 0;
9142 g_em->width = TILEX;
9143 g_em->height = TILEY;
9145 g_em->preserve_background = FALSE;
9147 set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
9150 if ((!g->double_movement && (effective_action == ACTION_FALLING ||
9151 effective_action == ACTION_MOVING ||
9152 effective_action == ACTION_PUSHING ||
9153 effective_action == ACTION_EATING)) ||
9154 (!has_action_graphics && (effective_action == ACTION_FILLING ||
9155 effective_action == ACTION_EMPTYING)))
9158 (effective_action == ACTION_FALLING ||
9159 effective_action == ACTION_FILLING ||
9160 effective_action == ACTION_EMPTYING ? MV_DOWN : direction);
9161 int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? 1 : 0);
9162 int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? 1 : 0);
9163 int num_steps = (i == Ydrip_1_s ? 16 :
9164 i == Ydrip_1_sB ? 16 :
9165 i == Ydrip_2_s ? 16 :
9166 i == Ydrip_2_sB ? 16 :
9167 i == Xsand_stonein_1 ? 32 :
9168 i == Xsand_stonein_2 ? 32 :
9169 i == Xsand_stonein_3 ? 32 :
9170 i == Xsand_stonein_4 ? 32 :
9171 i == Xsand_stoneout_1 ? 16 :
9172 i == Xsand_stoneout_2 ? 16 : 8);
9173 int cx = ABS(dx) * (TILEX / num_steps);
9174 int cy = ABS(dy) * (TILEY / num_steps);
9175 int step_frame = (i == Ydrip_2_s ? j + 8 :
9176 i == Ydrip_2_sB ? j + 8 :
9177 i == Xsand_stonein_2 ? j + 8 :
9178 i == Xsand_stonein_3 ? j + 16 :
9179 i == Xsand_stonein_4 ? j + 24 :
9180 i == Xsand_stoneout_2 ? j + 8 : j) + 1;
9181 int step = (is_backside ? step_frame : num_steps - step_frame);
9183 if (is_backside) // tile where movement starts
9185 if (dx < 0 || dy < 0)
9187 g_em->src_offset_x = cx * step;
9188 g_em->src_offset_y = cy * step;
9192 g_em->dst_offset_x = cx * step;
9193 g_em->dst_offset_y = cy * step;
9196 else // tile where movement ends
9198 if (dx < 0 || dy < 0)
9200 g_em->dst_offset_x = cx * step;
9201 g_em->dst_offset_y = cy * step;
9205 g_em->src_offset_x = cx * step;
9206 g_em->src_offset_y = cy * step;
9210 g_em->width = TILEX - cx * step;
9211 g_em->height = TILEY - cy * step;
9214 // create unique graphic identifier to decide if tile must be redrawn
9215 /* bit 31 - 16 (16 bit): EM style graphic
9216 bit 15 - 12 ( 4 bit): EM style frame
9217 bit 11 - 6 ( 6 bit): graphic width
9218 bit 5 - 0 ( 6 bit): graphic height */
9219 g_em->unique_identifier =
9220 (graphic << 16) | (frame << 12) | (g_em->width << 6) | g_em->height;
9224 for (i = 0; i < GAME_TILE_MAX; i++)
9226 for (j = 0; j < 8; j++)
9228 int element = object_mapping[i].element_rnd;
9229 int action = object_mapping[i].action;
9230 int direction = object_mapping[i].direction;
9231 boolean is_backside = object_mapping[i].is_backside;
9232 int graphic_action = el_act_dir2img(element, action, direction);
9233 int graphic_default = el_act_dir2img(element, ACTION_DEFAULT, direction);
9235 if ((action == ACTION_SMASHED_BY_ROCK ||
9236 action == ACTION_SMASHED_BY_SPRING ||
9237 action == ACTION_EATING) &&
9238 graphic_action == graphic_default)
9240 int e = (action == ACTION_SMASHED_BY_ROCK ? Ystone_s :
9241 action == ACTION_SMASHED_BY_SPRING ? Yspring_s :
9242 direction == MV_LEFT ? (is_backside? Yspring_wB: Yspring_w) :
9243 direction == MV_RIGHT ? (is_backside? Yspring_eB: Yspring_e) :
9246 // no separate animation for "smashed by rock" -- use rock instead
9247 struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
9248 struct GraphicInfo_EM *g_xx = &graphic_info_em_object[e][j];
9250 g_em->bitmap = g_xx->bitmap;
9251 g_em->src_x = g_xx->src_x;
9252 g_em->src_y = g_xx->src_y;
9253 g_em->src_offset_x = g_xx->src_offset_x;
9254 g_em->src_offset_y = g_xx->src_offset_y;
9255 g_em->dst_offset_x = g_xx->dst_offset_x;
9256 g_em->dst_offset_y = g_xx->dst_offset_y;
9257 g_em->width = g_xx->width;
9258 g_em->height = g_xx->height;
9259 g_em->unique_identifier = g_xx->unique_identifier;
9262 g_em->preserve_background = TRUE;
9267 for (p = 0; p < MAX_PLAYERS; p++)
9269 for (i = 0; i < PLY_MAX; i++)
9271 int element = player_mapping[p][i].element_rnd;
9272 int action = player_mapping[p][i].action;
9273 int direction = player_mapping[p][i].direction;
9275 for (j = 0; j < 8; j++)
9277 int effective_element = element;
9278 int effective_action = action;
9279 int graphic = (direction == MV_NONE ?
9280 el_act2img(effective_element, effective_action) :
9281 el_act_dir2img(effective_element, effective_action,
9283 struct GraphicInfo *g = &graphic_info[graphic];
9284 struct GraphicInfo_EM *g_em = &graphic_info_em_player[p][i][j];
9288 int frame = getAnimationFrame(g->anim_frames,
9291 g->anim_start_frame,
9294 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
9296 g_em->bitmap = src_bitmap;
9297 g_em->src_x = src_x;
9298 g_em->src_y = src_y;
9299 g_em->src_offset_x = 0;
9300 g_em->src_offset_y = 0;
9301 g_em->dst_offset_x = 0;
9302 g_em->dst_offset_y = 0;
9303 g_em->width = TILEX;
9304 g_em->height = TILEY;
9310 static void CheckSaveEngineSnapshot_EM(int frame,
9311 boolean any_player_moving,
9312 boolean any_player_snapping,
9313 boolean any_player_dropping)
9315 if (frame == 7 && !any_player_dropping)
9317 if (!local_player->was_waiting)
9319 if (!CheckSaveEngineSnapshotToList())
9322 local_player->was_waiting = TRUE;
9325 else if (any_player_moving || any_player_snapping || any_player_dropping)
9327 local_player->was_waiting = FALSE;
9331 static void CheckSaveEngineSnapshot_SP(boolean murphy_is_waiting,
9332 boolean murphy_is_dropping)
9334 if (murphy_is_waiting)
9336 if (!local_player->was_waiting)
9338 if (!CheckSaveEngineSnapshotToList())
9341 local_player->was_waiting = TRUE;
9346 local_player->was_waiting = FALSE;
9350 static void CheckSaveEngineSnapshot_MM(boolean element_clicked,
9351 boolean button_released)
9353 if (button_released)
9355 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE)
9356 CheckSaveEngineSnapshotToList();
9358 else if (element_clicked)
9360 if (game.snapshot.mode != SNAPSHOT_MODE_EVERY_MOVE)
9361 CheckSaveEngineSnapshotToList();
9363 game.snapshot.changed_action = TRUE;
9367 boolean CheckSingleStepMode_EM(int frame,
9368 boolean any_player_moving,
9369 boolean any_player_snapping,
9370 boolean any_player_dropping)
9372 if (tape.single_step && tape.recording && !tape.pausing)
9373 if (frame == 7 && !any_player_dropping && FrameCounter > 6)
9374 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9376 CheckSaveEngineSnapshot_EM(frame, any_player_moving,
9377 any_player_snapping, any_player_dropping);
9379 return tape.pausing;
9382 void CheckSingleStepMode_SP(boolean murphy_is_waiting,
9383 boolean murphy_is_dropping)
9385 boolean murphy_starts_dropping = FALSE;
9388 for (i = 0; i < MAX_PLAYERS; i++)
9389 if (stored_player[i].force_dropping)
9390 murphy_starts_dropping = TRUE;
9392 if (tape.single_step && tape.recording && !tape.pausing)
9393 if (murphy_is_waiting && !murphy_starts_dropping)
9394 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9396 CheckSaveEngineSnapshot_SP(murphy_is_waiting, murphy_is_dropping);
9399 void CheckSingleStepMode_MM(boolean element_clicked,
9400 boolean button_released)
9402 if (tape.single_step && tape.recording && !tape.pausing)
9403 if (button_released)
9404 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9406 CheckSaveEngineSnapshot_MM(element_clicked, button_released);
9409 void getGraphicSource_SP(struct GraphicInfo_SP *g_sp,
9410 int graphic, int sync_frame)
9412 int frame = getGraphicAnimationFrame(graphic, sync_frame);
9414 getGraphicSource(graphic, frame, &g_sp->bitmap, &g_sp->src_x, &g_sp->src_y);
9417 boolean isNextAnimationFrame_SP(int graphic, int sync_frame)
9419 return (IS_NEXT_FRAME(sync_frame, graphic));
9422 int getGraphicInfo_Delay(int graphic)
9424 return graphic_info[graphic].anim_delay;
9427 void PlayMenuSoundExt(int sound)
9429 if (sound == SND_UNDEFINED)
9432 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9433 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9436 if (IS_LOOP_SOUND(sound))
9437 PlaySoundLoop(sound);
9442 void PlayMenuSound(void)
9444 PlayMenuSoundExt(menu.sound[game_status]);
9447 void PlayMenuSoundStereo(int sound, int stereo_position)
9449 if (sound == SND_UNDEFINED)
9452 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9453 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9456 if (IS_LOOP_SOUND(sound))
9457 PlaySoundExt(sound, SOUND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_LOOP);
9459 PlaySoundStereo(sound, stereo_position);
9462 void PlayMenuSoundIfLoopExt(int sound)
9464 if (sound == SND_UNDEFINED)
9467 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9468 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9471 if (IS_LOOP_SOUND(sound))
9472 PlaySoundLoop(sound);
9475 void PlayMenuSoundIfLoop(void)
9477 PlayMenuSoundIfLoopExt(menu.sound[game_status]);
9480 void PlayMenuMusicExt(int music)
9482 if (music == MUS_UNDEFINED)
9485 if (!setup.sound_music)
9488 if (IS_LOOP_MUSIC(music))
9489 PlayMusicLoop(music);
9494 void PlayMenuMusic(void)
9496 char *curr_music = getCurrentlyPlayingMusicFilename();
9497 char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
9499 if (!strEqual(curr_music, next_music))
9500 PlayMenuMusicExt(menu.music[game_status]);
9503 void PlayMenuSoundsAndMusic(void)
9509 static void FadeMenuSounds(void)
9514 static void FadeMenuMusic(void)
9516 char *curr_music = getCurrentlyPlayingMusicFilename();
9517 char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
9519 if (!strEqual(curr_music, next_music))
9523 void FadeMenuSoundsAndMusic(void)
9529 void PlaySoundActivating(void)
9532 PlaySound(SND_MENU_ITEM_ACTIVATING);
9536 void PlaySoundSelecting(void)
9539 PlaySound(SND_MENU_ITEM_SELECTING);
9543 void ToggleFullscreenIfNeeded(void)
9545 // if setup and video fullscreen state are already matching, nothing do do
9546 if (setup.fullscreen == video.fullscreen_enabled ||
9547 !video.fullscreen_available)
9550 SDLSetWindowFullscreen(setup.fullscreen);
9552 // set setup value according to successfully changed fullscreen mode
9553 setup.fullscreen = video.fullscreen_enabled;
9556 void ChangeWindowScalingIfNeeded(void)
9558 // if setup and video window scaling are already matching, nothing do do
9559 if (setup.window_scaling_percent == video.window_scaling_percent ||
9560 video.fullscreen_enabled)
9563 SDLSetWindowScaling(setup.window_scaling_percent);
9565 // set setup value according to successfully changed window scaling
9566 setup.window_scaling_percent = video.window_scaling_percent;
9569 void ChangeVsyncModeIfNeeded(void)
9571 int setup_vsync_mode = VSYNC_MODE_STR_TO_INT(setup.vsync_mode);
9572 int video_vsync_mode = video.vsync_mode;
9574 // if setup and video vsync mode are already matching, nothing do do
9575 if (setup_vsync_mode == video_vsync_mode)
9578 // if renderer is using OpenGL, vsync mode can directly be changed
9579 SDLSetScreenVsyncMode(setup.vsync_mode);
9581 // if vsync mode unchanged, try re-creating renderer to set vsync mode
9582 if (video.vsync_mode == video_vsync_mode)
9584 Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
9586 // save backbuffer content which gets lost when re-creating screen
9587 BlitBitmap(backbuffer, tmp_backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9589 // force re-creating screen and renderer to set new vsync mode
9590 video.fullscreen_enabled = !setup.fullscreen;
9592 // when creating new renderer, destroy textures linked to old renderer
9593 FreeAllImageTextures(); // needs old renderer to free the textures
9595 // re-create screen and renderer (including change of vsync mode)
9596 ChangeVideoModeIfNeeded(setup.fullscreen);
9598 // set setup value according to successfully changed fullscreen mode
9599 setup.fullscreen = video.fullscreen_enabled;
9601 // restore backbuffer content from temporary backbuffer backup bitmap
9602 BlitBitmap(tmp_backbuffer, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9603 FreeBitmap(tmp_backbuffer);
9605 // update visible window/screen
9606 BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9608 // when changing vsync mode, re-create textures for new renderer
9609 InitImageTextures();
9612 // set setup value according to successfully changed vsync mode
9613 setup.vsync_mode = VSYNC_MODE_INT_TO_STR(video.vsync_mode);
9616 static void JoinRectangles(int *x, int *y, int *width, int *height,
9617 int x2, int y2, int width2, int height2)
9619 // do not join with "off-screen" rectangle
9620 if (x2 == -1 || y2 == -1)
9625 *width = MAX(*width, width2);
9626 *height = MAX(*height, height2);
9629 void SetAnimStatus(int anim_status_new)
9631 if (anim_status_new == GAME_MODE_MAIN)
9632 anim_status_new = GAME_MODE_PSEUDO_MAINONLY;
9633 else if (anim_status_new == GAME_MODE_NAMES)
9634 anim_status_new = GAME_MODE_PSEUDO_NAMESONLY;
9635 else if (anim_status_new == GAME_MODE_SCORES)
9636 anim_status_new = GAME_MODE_PSEUDO_SCORESOLD;
9638 global.anim_status_next = anim_status_new;
9640 // directly set screen modes that are entered without fading
9641 if ((global.anim_status == GAME_MODE_PSEUDO_MAINONLY &&
9642 global.anim_status_next == GAME_MODE_PSEUDO_TYPENAME) ||
9643 (global.anim_status == GAME_MODE_PSEUDO_TYPENAME &&
9644 global.anim_status_next == GAME_MODE_PSEUDO_MAINONLY) ||
9645 (global.anim_status == GAME_MODE_PSEUDO_NAMESONLY &&
9646 global.anim_status_next == GAME_MODE_PSEUDO_TYPENAMES) ||
9647 (global.anim_status == GAME_MODE_PSEUDO_TYPENAMES &&
9648 global.anim_status_next == GAME_MODE_PSEUDO_NAMESONLY))
9649 global.anim_status = global.anim_status_next;
9652 void SetGameStatus(int game_status_new)
9654 if (game_status_new != game_status)
9655 game_status_last_screen = game_status;
9657 game_status = game_status_new;
9659 SetAnimStatus(game_status_new);
9662 void SetFontStatus(int game_status_new)
9664 static int last_game_status = -1;
9666 if (game_status_new != -1)
9668 // set game status for font use after storing last game status
9669 last_game_status = game_status;
9670 game_status = game_status_new;
9674 // reset game status after font use from last stored game status
9675 game_status = last_game_status;
9679 void ResetFontStatus(void)
9684 void SetLevelSetInfo(char *identifier, int level_nr)
9686 setString(&levelset.identifier, identifier);
9688 levelset.level_nr = level_nr;
9691 boolean CheckIfAllViewportsHaveChanged(void)
9693 // if game status has not changed, viewports have not changed either
9694 if (game_status == game_status_last)
9697 // check if all viewports have changed with current game status
9699 struct RectWithBorder *vp_playfield = &viewport.playfield[game_status];
9700 struct RectWithBorder *vp_door_1 = &viewport.door_1[game_status];
9701 struct RectWithBorder *vp_door_2 = &viewport.door_2[game_status];
9702 int new_real_sx = vp_playfield->x;
9703 int new_real_sy = vp_playfield->y;
9704 int new_full_sxsize = vp_playfield->width;
9705 int new_full_sysize = vp_playfield->height;
9706 int new_dx = vp_door_1->x;
9707 int new_dy = vp_door_1->y;
9708 int new_dxsize = vp_door_1->width;
9709 int new_dysize = vp_door_1->height;
9710 int new_vx = vp_door_2->x;
9711 int new_vy = vp_door_2->y;
9712 int new_vxsize = vp_door_2->width;
9713 int new_vysize = vp_door_2->height;
9715 boolean playfield_viewport_has_changed =
9716 (new_real_sx != REAL_SX ||
9717 new_real_sy != REAL_SY ||
9718 new_full_sxsize != FULL_SXSIZE ||
9719 new_full_sysize != FULL_SYSIZE);
9721 boolean door_1_viewport_has_changed =
9724 new_dxsize != DXSIZE ||
9725 new_dysize != DYSIZE);
9727 boolean door_2_viewport_has_changed =
9730 new_vxsize != VXSIZE ||
9731 new_vysize != VYSIZE ||
9732 game_status_last == GAME_MODE_EDITOR);
9734 return (playfield_viewport_has_changed &&
9735 door_1_viewport_has_changed &&
9736 door_2_viewport_has_changed);
9739 boolean CheckFadeAll(void)
9741 return (CheckIfGlobalBorderHasChanged() ||
9742 CheckIfAllViewportsHaveChanged());
9745 void ChangeViewportPropertiesIfNeeded(void)
9747 boolean use_mini_tilesize = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
9748 FALSE : setup.small_game_graphics);
9749 int gfx_game_mode = getGlobalGameStatus(game_status);
9750 int gfx_game_mode2 = (gfx_game_mode == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
9752 struct RectWithBorder *vp_window = &viewport.window[gfx_game_mode];
9753 struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
9754 struct RectWithBorder *vp_door_1 = &viewport.door_1[gfx_game_mode];
9755 struct RectWithBorder *vp_door_2 = &viewport.door_2[gfx_game_mode2];
9756 struct RectWithBorder *vp_door_3 = &viewport.door_2[GAME_MODE_EDITOR];
9757 int new_win_xsize = vp_window->width;
9758 int new_win_ysize = vp_window->height;
9759 int border_left = vp_playfield->border_left;
9760 int border_right = vp_playfield->border_right;
9761 int border_top = vp_playfield->border_top;
9762 int border_bottom = vp_playfield->border_bottom;
9763 int new_sx = vp_playfield->x + border_left;
9764 int new_sy = vp_playfield->y + border_top;
9765 int new_sxsize = vp_playfield->width - border_left - border_right;
9766 int new_sysize = vp_playfield->height - border_top - border_bottom;
9767 int new_real_sx = vp_playfield->x;
9768 int new_real_sy = vp_playfield->y;
9769 int new_full_sxsize = vp_playfield->width;
9770 int new_full_sysize = vp_playfield->height;
9771 int new_dx = vp_door_1->x;
9772 int new_dy = vp_door_1->y;
9773 int new_dxsize = vp_door_1->width;
9774 int new_dysize = vp_door_1->height;
9775 int new_vx = vp_door_2->x;
9776 int new_vy = vp_door_2->y;
9777 int new_vxsize = vp_door_2->width;
9778 int new_vysize = vp_door_2->height;
9779 int new_ex = vp_door_3->x;
9780 int new_ey = vp_door_3->y;
9781 int new_exsize = vp_door_3->width;
9782 int new_eysize = vp_door_3->height;
9783 int new_tilesize_var = (use_mini_tilesize ? MINI_TILESIZE : game.tile_size);
9784 int tilesize = (gfx_game_mode == GAME_MODE_PLAYING ? new_tilesize_var :
9785 gfx_game_mode == GAME_MODE_EDITOR ? MINI_TILESIZE : TILESIZE);
9786 int new_scr_fieldx = new_sxsize / tilesize;
9787 int new_scr_fieldy = new_sysize / tilesize;
9788 int new_scr_fieldx_buffers = new_sxsize / new_tilesize_var;
9789 int new_scr_fieldy_buffers = new_sysize / new_tilesize_var;
9790 boolean init_gfx_buffers = FALSE;
9791 boolean init_video_buffer = FALSE;
9792 boolean init_gadgets_and_anims = FALSE;
9793 boolean init_em_graphics = FALSE;
9795 if (new_win_xsize != WIN_XSIZE ||
9796 new_win_ysize != WIN_YSIZE)
9798 WIN_XSIZE = new_win_xsize;
9799 WIN_YSIZE = new_win_ysize;
9801 init_video_buffer = TRUE;
9802 init_gfx_buffers = TRUE;
9803 init_gadgets_and_anims = TRUE;
9805 // Debug("tools:viewport", "video: init_video_buffer, init_gfx_buffers");
9808 if (new_scr_fieldx != SCR_FIELDX ||
9809 new_scr_fieldy != SCR_FIELDY)
9811 // this always toggles between MAIN and GAME when using small tile size
9813 SCR_FIELDX = new_scr_fieldx;
9814 SCR_FIELDY = new_scr_fieldy;
9816 // Debug("tools:viewport", "new_scr_fieldx != SCR_FIELDX ...");
9827 new_sxsize != SXSIZE ||
9828 new_sysize != SYSIZE ||
9829 new_dxsize != DXSIZE ||
9830 new_dysize != DYSIZE ||
9831 new_vxsize != VXSIZE ||
9832 new_vysize != VYSIZE ||
9833 new_exsize != EXSIZE ||
9834 new_eysize != EYSIZE ||
9835 new_real_sx != REAL_SX ||
9836 new_real_sy != REAL_SY ||
9837 new_full_sxsize != FULL_SXSIZE ||
9838 new_full_sysize != FULL_SYSIZE ||
9839 new_tilesize_var != TILESIZE_VAR
9842 // ------------------------------------------------------------------------
9843 // determine next fading area for changed viewport definitions
9844 // ------------------------------------------------------------------------
9846 // start with current playfield area (default fading area)
9849 FADE_SXSIZE = FULL_SXSIZE;
9850 FADE_SYSIZE = FULL_SYSIZE;
9852 // add new playfield area if position or size has changed
9853 if (new_real_sx != REAL_SX || new_real_sy != REAL_SY ||
9854 new_full_sxsize != FULL_SXSIZE || new_full_sysize != FULL_SYSIZE)
9856 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9857 new_real_sx, new_real_sy, new_full_sxsize,new_full_sysize);
9860 // add current and new door 1 area if position or size has changed
9861 if (new_dx != DX || new_dy != DY ||
9862 new_dxsize != DXSIZE || new_dysize != DYSIZE)
9864 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9865 DX, DY, DXSIZE, DYSIZE);
9866 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9867 new_dx, new_dy, new_dxsize, new_dysize);
9870 // add current and new door 2 area if position or size has changed
9871 if (new_vx != VX || new_vy != VY ||
9872 new_vxsize != VXSIZE || new_vysize != VYSIZE)
9874 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9875 VX, VY, VXSIZE, VYSIZE);
9876 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9877 new_vx, new_vy, new_vxsize, new_vysize);
9880 // ------------------------------------------------------------------------
9881 // handle changed tile size
9882 // ------------------------------------------------------------------------
9884 if (new_tilesize_var != TILESIZE_VAR)
9886 // Debug("tools:viewport", "new_tilesize_var != TILESIZE_VAR");
9888 // changing tile size invalidates scroll values of engine snapshots
9889 FreeEngineSnapshotSingle();
9891 // changing tile size requires update of graphic mapping for EM engine
9892 init_em_graphics = TRUE;
9903 SXSIZE = new_sxsize;
9904 SYSIZE = new_sysize;
9905 DXSIZE = new_dxsize;
9906 DYSIZE = new_dysize;
9907 VXSIZE = new_vxsize;
9908 VYSIZE = new_vysize;
9909 EXSIZE = new_exsize;
9910 EYSIZE = new_eysize;
9911 REAL_SX = new_real_sx;
9912 REAL_SY = new_real_sy;
9913 FULL_SXSIZE = new_full_sxsize;
9914 FULL_SYSIZE = new_full_sysize;
9915 TILESIZE_VAR = new_tilesize_var;
9917 init_gfx_buffers = TRUE;
9918 init_gadgets_and_anims = TRUE;
9920 // Debug("tools:viewport", "viewports: init_gfx_buffers");
9921 // Debug("tools:viewport", "viewports: init_gadgets_and_anims");
9924 if (init_gfx_buffers)
9926 // Debug("tools:viewport", "init_gfx_buffers");
9928 SCR_FIELDX = new_scr_fieldx_buffers;
9929 SCR_FIELDY = new_scr_fieldy_buffers;
9933 SCR_FIELDX = new_scr_fieldx;
9934 SCR_FIELDY = new_scr_fieldy;
9936 SetDrawDeactivationMask(REDRAW_NONE);
9937 SetDrawBackgroundMask(REDRAW_FIELD);
9940 if (init_video_buffer)
9942 // Debug("tools:viewport", "init_video_buffer");
9944 FreeAllImageTextures(); // needs old renderer to free the textures
9946 InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen);
9947 InitImageTextures();
9950 if (init_gadgets_and_anims)
9952 // Debug("tools:viewport", "init_gadgets_and_anims");
9955 InitGlobalAnimations();
9958 if (init_em_graphics)
9960 InitGraphicInfo_EM();
9964 void OpenURL(char *url)
9966 #if SDL_VERSION_ATLEAST(2,0,14)
9969 Warn("SDL_OpenURL(\"%s\") not supported by SDL %d.%d.%d!",
9970 url, SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
9971 Warn("Please upgrade to at least SDL 2.0.14 for URL support!");
9975 void OpenURLFromHash(SetupFileHash *hash, int hash_key)
9977 OpenURL(getHashEntry(hash, int2str(hash_key, 0)));
9981 // ============================================================================
9983 // ============================================================================
9985 #if defined(PLATFORM_WINDOWS)
9986 /* FILETIME of Jan 1 1970 00:00:00. */
9987 static const unsigned __int64 epoch = ((unsigned __int64) 116444736000000000ULL);
9990 * timezone information is stored outside the kernel so tzp isn't used anymore.
9992 * Note: this function is not for Win32 high precision timing purpose. See
9995 static int gettimeofday_windows(struct timeval * tp, struct timezone * tzp)
9998 SYSTEMTIME system_time;
9999 ULARGE_INTEGER ularge;
10001 GetSystemTime(&system_time);
10002 SystemTimeToFileTime(&system_time, &file_time);
10003 ularge.LowPart = file_time.dwLowDateTime;
10004 ularge.HighPart = file_time.dwHighDateTime;
10006 tp->tv_sec = (long) ((ularge.QuadPart - epoch) / 10000000L);
10007 tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
10013 static char *test_init_uuid_random_function_simple(void)
10015 static char seed_text[100];
10016 unsigned int seed = InitSimpleRandom(NEW_RANDOMIZE);
10018 sprintf(seed_text, "%d", seed);
10023 static char *test_init_uuid_random_function_better(void)
10025 static char seed_text[100];
10026 struct timeval current_time;
10028 gettimeofday(¤t_time, NULL);
10030 prng_seed_bytes(¤t_time, sizeof(current_time));
10032 sprintf(seed_text, "%ld.%ld",
10033 (long)current_time.tv_sec,
10034 (long)current_time.tv_usec);
10039 #if defined(PLATFORM_WINDOWS)
10040 static char *test_init_uuid_random_function_better_windows(void)
10042 static char seed_text[100];
10043 struct timeval current_time;
10045 gettimeofday_windows(¤t_time, NULL);
10047 prng_seed_bytes(¤t_time, sizeof(current_time));
10049 sprintf(seed_text, "%ld.%ld",
10050 (long)current_time.tv_sec,
10051 (long)current_time.tv_usec);
10057 static unsigned int test_uuid_random_function_simple(int max)
10059 return GetSimpleRandom(max);
10062 static unsigned int test_uuid_random_function_better(int max)
10064 return (max > 0 ? prng_get_uint() % max : 0);
10067 #if defined(PLATFORM_WINDOWS)
10068 #define NUM_UUID_TESTS 3
10070 #define NUM_UUID_TESTS 2
10073 static void TestGeneratingUUIDs_RunTest(int nr, int always_seed, int num_uuids)
10075 struct hashtable *hash_seeds =
10076 create_hashtable(16, 0.75, get_hash_from_key, hash_keys_are_equal);
10077 struct hashtable *hash_uuids =
10078 create_hashtable(16, 0.75, get_hash_from_key, hash_keys_are_equal);
10079 static char message[100];
10082 char *random_name = (nr == 0 ? "simple" : "better");
10083 char *random_type = (always_seed ? "always" : "only once");
10084 char *(*init_random_function)(void) =
10086 test_init_uuid_random_function_simple :
10087 test_init_uuid_random_function_better);
10088 unsigned int (*random_function)(int) =
10090 test_uuid_random_function_simple :
10091 test_uuid_random_function_better);
10094 #if defined(PLATFORM_WINDOWS)
10097 random_name = "windows";
10098 init_random_function = test_init_uuid_random_function_better_windows;
10104 DrawTextF(xpos, 40, FC_GREEN, "Test: Generating UUIDs");
10105 DrawTextF(xpos, 80, FC_YELLOW, "Test %d.%d:", nr + 1, always_seed + 1);
10107 DrawTextF(xpos, 100, FC_YELLOW, "Random Generator Name: %s", random_name);
10108 DrawTextF(xpos, 120, FC_YELLOW, "Seeding Random Generator: %s", random_type);
10109 DrawTextF(xpos, 140, FC_YELLOW, "Number of UUIDs generated: %d", num_uuids);
10111 DrawTextF(xpos, 180, FC_GREEN, "Please wait ...");
10115 // always initialize random number generator at least once
10116 init_random_function();
10118 unsigned int time_start = SDL_GetTicks();
10120 for (i = 0; i < num_uuids; i++)
10124 char *seed = getStringCopy(init_random_function());
10126 hashtable_remove(hash_seeds, seed);
10127 hashtable_insert(hash_seeds, seed, "1");
10130 char *uuid = getStringCopy(getUUIDExt(random_function));
10132 hashtable_remove(hash_uuids, uuid);
10133 hashtable_insert(hash_uuids, uuid, "1");
10136 int num_unique_seeds = hashtable_count(hash_seeds);
10137 int num_unique_uuids = hashtable_count(hash_uuids);
10139 unsigned int time_needed = SDL_GetTicks() - time_start;
10141 DrawTextF(xpos, 220, FC_YELLOW, "Time needed: %d ms", time_needed);
10143 DrawTextF(xpos, 240, FC_YELLOW, "Number of unique UUIDs: %d", num_unique_uuids);
10146 DrawTextF(xpos, 260, FC_YELLOW, "Number of unique seeds: %d", num_unique_seeds);
10148 if (nr == NUM_UUID_TESTS - 1 && always_seed)
10149 DrawTextF(xpos, 300, FC_GREEN, "All tests done!");
10151 DrawTextF(xpos, 300, FC_GREEN, "Confirm dialog for next test ...");
10153 sprintf(message, "Test %d.%d finished!", nr + 1, always_seed + 1);
10155 Request(message, REQ_CONFIRM);
10157 hashtable_destroy(hash_seeds, 0);
10158 hashtable_destroy(hash_uuids, 0);
10161 void TestGeneratingUUIDs(void)
10163 int num_uuids = 1000000;
10166 for (i = 0; i < NUM_UUID_TESTS; i++)
10167 for (j = 0; j < 2; j++)
10168 TestGeneratingUUIDs_RunTest(i, j, num_uuids);
10170 CloseAllAndExit(0);