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 if (Tile[next_jx][next_jy] == EL_EXPLOSION)
4254 int gfx_frame = GfxFrame[jx][jy];
4256 if (!IS_MOVING(jx, jy)) // push movement already finished
4258 element = Tile[next_jx][next_jy];
4259 gfx_frame = GfxFrame[next_jx][next_jy];
4262 int graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
4263 int sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
4264 int frame = getGraphicAnimationFrame(graphic, sync_frame);
4266 // draw background element under pushed element (like the Sokoban field)
4267 if (game.use_masked_pushing && IS_MOVING(jx, jy))
4269 // this allows transparent pushing animation over non-black background
4272 DrawLevelElement(jx, jy, Back[jx][jy]);
4274 DrawLevelElement(jx, jy, EL_EMPTY);
4277 if (Back[next_jx][next_jy])
4278 DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
4280 DrawLevelElement(next_jx, next_jy, EL_EMPTY);
4282 int px = SCREENX(jx), py = SCREENY(jy);
4283 int pxx = (TILEX - ABS(sxx)) * dx;
4284 int pyy = (TILEY - ABS(syy)) * dy;
4287 // do not draw (EM style) pushing animation when pushing is finished
4288 // (two-tile animations usually do not contain start and end frame)
4289 if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
4290 DrawLevelElement(next_jx, next_jy, Tile[next_jx][next_jy]);
4292 DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4294 // masked drawing is needed for EMC style (double) movement graphics
4295 // !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!!
4296 DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4299 else if (drawing_stage == DRAW_PLAYER_STAGE_PLAYER)
4301 // ------------------------------------------------------------------------
4302 // draw player himself
4303 // ------------------------------------------------------------------------
4305 int graphic = getPlayerGraphic(player, move_dir);
4307 // in the case of changed player action or direction, prevent the current
4308 // animation frame from being restarted for identical animations
4309 if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
4310 player->Frame = last_player_frame;
4312 int frame = getGraphicAnimationFrame(graphic, player->Frame);
4314 if (player_is_opaque)
4315 DrawGraphicShifted(sx,sy, sxx,syy, graphic, frame, NO_CUTTING,NO_MASKING);
4317 DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4319 if (SHIELD_ON(player))
4321 graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
4322 IMG_SHIELD_NORMAL_ACTIVE);
4323 frame = getGraphicAnimationFrame(graphic, -1);
4325 DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4328 else if (drawing_stage == DRAW_PLAYER_STAGE_ELEMENT_OVER_PLAYER)
4330 // ------------------------------------------------------------------------
4331 // draw things in front of player (active dynamite or dynabombs)
4332 // ------------------------------------------------------------------------
4334 if (IS_ACTIVE_BOMB(element))
4336 int graphic = el2img(element);
4337 int frame = getGraphicAnimationFrameXY(graphic, jx, jy);
4339 if (game.emulation == EMU_SUPAPLEX)
4340 DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
4342 DrawGraphicThruMask(sx, sy, graphic, frame);
4345 if (player_is_moving && last_element == EL_EXPLOSION)
4347 int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
4348 GfxElement[last_jx][last_jy] : EL_EMPTY);
4349 int graphic = el_act2img(element, ACTION_EXPLODING);
4350 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
4351 int phase = ExplodePhase[last_jx][last_jy] - 1;
4352 int frame = getGraphicAnimationFrame(graphic, phase - delay);
4355 DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
4358 else if (drawing_stage == DRAW_PLAYER_STAGE_FIELD_OVER_PLAYER)
4360 // ------------------------------------------------------------------------
4361 // draw elements the player is just walking/passing through/under
4362 // ------------------------------------------------------------------------
4364 if (player_is_moving)
4366 // handle the field the player is leaving ...
4367 if (IS_ACCESSIBLE_INSIDE(last_element))
4368 DrawLevelField(last_jx, last_jy);
4369 else if (IS_ACCESSIBLE_UNDER(last_element))
4370 DrawLevelFieldThruMask(last_jx, last_jy);
4373 // do not redraw accessible elements if the player is just pushing them
4374 if (!player_is_moving || !player->is_pushing)
4376 // ... and the field the player is entering
4377 if (IS_ACCESSIBLE_INSIDE(element))
4378 DrawLevelField(jx, jy);
4379 else if (IS_ACCESSIBLE_UNDER(element))
4380 DrawLevelFieldThruMask(jx, jy);
4383 MarkTileDirty(sx, sy);
4387 void DrawPlayer(struct PlayerInfo *player)
4391 for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4392 DrawPlayerExt(player, i);
4395 void DrawAllPlayers(void)
4399 for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4400 for (j = 0; j < MAX_PLAYERS; j++)
4401 if (stored_player[j].active)
4402 DrawPlayerExt(&stored_player[j], i);
4405 void DrawPlayerField(int x, int y)
4407 if (!IS_PLAYER(x, y))
4410 DrawPlayer(PLAYERINFO(x, y));
4413 // ----------------------------------------------------------------------------
4415 void WaitForEventToContinue(void)
4417 boolean first_wait = TRUE;
4418 boolean still_wait = TRUE;
4420 if (program.headless)
4423 // simulate releasing mouse button over last gadget, if still pressed
4425 HandleGadgets(-1, -1, 0);
4427 button_status = MB_RELEASED;
4430 ClearPlayerAction();
4436 if (NextValidEvent(&event))
4440 case EVENT_BUTTONPRESS:
4441 case EVENT_FINGERPRESS:
4445 case EVENT_BUTTONRELEASE:
4446 case EVENT_FINGERRELEASE:
4447 still_wait = first_wait;
4450 case EVENT_KEYPRESS:
4451 case SDL_CONTROLLERBUTTONDOWN:
4452 case SDL_JOYBUTTONDOWN:
4457 HandleOtherEvents(&event);
4461 else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4466 if (!PendingEvent())
4471 #define MAX_REQUEST_LINES 13
4472 #define MAX_REQUEST_LINE_FONT1_LEN 7
4473 #define MAX_REQUEST_LINE_FONT2_LEN 10
4475 static int RequestHandleEvents(unsigned int req_state, int draw_buffer_game)
4477 boolean game_just_ended = (game_status == GAME_MODE_PLAYING &&
4479 int draw_buffer_last = GetDrawtoField();
4480 int width = request.width;
4481 int height = request.height;
4485 // when showing request dialog after game ended, deactivate game panel
4486 if (game_just_ended)
4487 game.panel.active = FALSE;
4489 game.request_active = TRUE;
4491 setRequestPosition(&sx, &sy, FALSE);
4493 button_status = MB_RELEASED;
4495 request_gadget_id = -1;
4500 boolean event_handled = FALSE;
4502 if (game_just_ended)
4504 SetDrawtoField(draw_buffer_game);
4506 HandleGameActions();
4508 SetDrawtoField(DRAW_TO_BACKBUFFER);
4510 if (global.use_envelope_request)
4512 // copy current state of request area to middle of playfield area
4513 BlitBitmap(bitmap_db_store_2, drawto, sx, sy, width, height, sx, sy);
4521 while (NextValidEvent(&event))
4523 event_handled = TRUE;
4527 case EVENT_BUTTONPRESS:
4528 case EVENT_BUTTONRELEASE:
4529 case EVENT_MOTIONNOTIFY:
4533 if (event.type == EVENT_MOTIONNOTIFY)
4538 motion_status = TRUE;
4539 mx = ((MotionEvent *) &event)->x;
4540 my = ((MotionEvent *) &event)->y;
4544 motion_status = FALSE;
4545 mx = ((ButtonEvent *) &event)->x;
4546 my = ((ButtonEvent *) &event)->y;
4547 if (event.type == EVENT_BUTTONPRESS)
4548 button_status = ((ButtonEvent *) &event)->button;
4550 button_status = MB_RELEASED;
4553 // this sets 'request_gadget_id'
4554 HandleGadgets(mx, my, button_status);
4556 switch (request_gadget_id)
4558 case TOOL_CTRL_ID_YES:
4559 case TOOL_CTRL_ID_TOUCH_YES:
4562 case TOOL_CTRL_ID_NO:
4563 case TOOL_CTRL_ID_TOUCH_NO:
4566 case TOOL_CTRL_ID_CONFIRM:
4567 case TOOL_CTRL_ID_TOUCH_CONFIRM:
4568 result = TRUE | FALSE;
4571 case TOOL_CTRL_ID_PLAYER_1:
4574 case TOOL_CTRL_ID_PLAYER_2:
4577 case TOOL_CTRL_ID_PLAYER_3:
4580 case TOOL_CTRL_ID_PLAYER_4:
4585 // only check clickable animations if no request gadget clicked
4586 HandleGlobalAnimClicks(mx, my, button_status, FALSE);
4593 case SDL_WINDOWEVENT:
4594 HandleWindowEvent((WindowEvent *) &event);
4597 case SDL_APP_WILLENTERBACKGROUND:
4598 case SDL_APP_DIDENTERBACKGROUND:
4599 case SDL_APP_WILLENTERFOREGROUND:
4600 case SDL_APP_DIDENTERFOREGROUND:
4601 HandlePauseResumeEvent((PauseResumeEvent *) &event);
4604 case EVENT_KEYPRESS:
4606 Key key = GetEventKey((KeyEvent *)&event);
4611 if (req_state & REQ_CONFIRM)
4620 #if defined(KSYM_Rewind)
4621 case KSYM_Rewind: // for Amazon Fire TV remote
4630 #if defined(KSYM_FastForward)
4631 case KSYM_FastForward: // for Amazon Fire TV remote
4637 HandleKeysDebug(key, KEY_PRESSED);
4641 if (req_state & REQ_PLAYER)
4643 int old_player_nr = setup.network_player_nr;
4646 result = old_player_nr + 1;
4651 result = old_player_nr + 1;
4682 case EVENT_FINGERRELEASE:
4683 case EVENT_KEYRELEASE:
4684 ClearPlayerAction();
4687 case SDL_CONTROLLERBUTTONDOWN:
4688 switch (event.cbutton.button)
4690 case SDL_CONTROLLER_BUTTON_A:
4691 case SDL_CONTROLLER_BUTTON_X:
4692 case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
4693 case SDL_CONTROLLER_BUTTON_LEFTSTICK:
4697 case SDL_CONTROLLER_BUTTON_B:
4698 case SDL_CONTROLLER_BUTTON_Y:
4699 case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
4700 case SDL_CONTROLLER_BUTTON_RIGHTSTICK:
4701 case SDL_CONTROLLER_BUTTON_BACK:
4706 if (req_state & REQ_PLAYER)
4708 int old_player_nr = setup.network_player_nr;
4711 result = old_player_nr + 1;
4713 switch (event.cbutton.button)
4715 case SDL_CONTROLLER_BUTTON_DPAD_UP:
4716 case SDL_CONTROLLER_BUTTON_Y:
4720 case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
4721 case SDL_CONTROLLER_BUTTON_B:
4725 case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
4726 case SDL_CONTROLLER_BUTTON_A:
4730 case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
4731 case SDL_CONTROLLER_BUTTON_X:
4742 case SDL_CONTROLLERBUTTONUP:
4743 HandleJoystickEvent(&event);
4744 ClearPlayerAction();
4748 HandleOtherEvents(&event);
4753 else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4755 int joy = AnyJoystick();
4757 if (joy & JOY_BUTTON_1)
4759 else if (joy & JOY_BUTTON_2)
4762 else if (AnyJoystick())
4764 int joy = AnyJoystick();
4766 if (req_state & REQ_PLAYER)
4770 else if (joy & JOY_RIGHT)
4772 else if (joy & JOY_DOWN)
4774 else if (joy & JOY_LEFT)
4781 if (game_just_ended)
4783 if (global.use_envelope_request)
4785 // copy back current state of pressed buttons inside request area
4786 BlitBitmap(drawto, bitmap_db_store_2, sx, sy, width, height, sx, sy);
4790 PrepareEnvelopeRequestToScreen(drawto, sx, sy, width, height);
4796 SetDrawtoField(draw_buffer_last);
4798 game.request_active = FALSE;
4803 static boolean RequestDoor(char *text, unsigned int req_state)
4805 int draw_buffer_last = GetDrawtoField();
4806 unsigned int old_door_state;
4807 int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN;
4808 int font_nr = FONT_TEXT_2;
4813 if (maxWordLengthInRequestString(text) > MAX_REQUEST_LINE_FONT1_LEN)
4815 max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
4816 font_nr = FONT_TEXT_1;
4819 if (game_status == GAME_MODE_PLAYING)
4820 BlitScreenToBitmap(backbuffer);
4822 // disable deactivated drawing when quick-loading level tape recording
4823 if (tape.playing && tape.deactivate_display)
4824 TapeDeactivateDisplayOff(TRUE);
4826 SetMouseCursor(CURSOR_DEFAULT);
4828 // pause network game while waiting for request to answer
4829 if (network.enabled &&
4830 game_status == GAME_MODE_PLAYING &&
4831 !game.all_players_gone &&
4832 req_state & REQUEST_WAIT_FOR_INPUT)
4833 SendToServer_PausePlaying();
4835 old_door_state = GetDoorState();
4837 // simulate releasing mouse button over last gadget, if still pressed
4839 HandleGadgets(-1, -1, 0);
4843 // draw released gadget before proceeding
4846 if (old_door_state & DOOR_OPEN_1)
4848 CloseDoor(DOOR_CLOSE_1);
4850 // save old door content
4851 BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
4852 0 * DXSIZE, 0, DXSIZE, DYSIZE, 1 * DXSIZE, 0);
4855 SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
4856 SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4858 // clear door drawing field
4859 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4861 // force DOOR font inside door area
4862 SetFontStatus(GAME_MODE_PSEUDO_DOOR);
4864 // write text for request
4865 for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
4867 char text_line[max_request_line_len + 1];
4873 for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
4875 tc = *(text_ptr + tx);
4876 // if (!tc || tc == ' ')
4877 if (!tc || tc == ' ' || tc == '?' || tc == '!')
4881 if ((tc == '?' || tc == '!') && tl == 0)
4891 strncpy(text_line, text_ptr, tl);
4894 DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
4895 DY + 8 + ty * (getFontHeight(font_nr) + 2),
4896 text_line, font_nr);
4898 text_ptr += tl + (tc == ' ' ? 1 : 0);
4899 // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
4904 if (req_state & REQ_ASK)
4906 MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
4907 MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
4908 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_YES]);
4909 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_NO]);
4911 else if (req_state & REQ_CONFIRM)
4913 MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
4914 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_CONFIRM]);
4916 else if (req_state & REQ_PLAYER)
4918 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
4919 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
4920 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
4921 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
4924 // copy request gadgets to door backbuffer
4925 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4927 OpenDoor(DOOR_OPEN_1);
4929 if (!(req_state & REQUEST_WAIT_FOR_INPUT))
4931 if (game_status == GAME_MODE_PLAYING)
4933 SetPanelBackground();
4934 SetDrawBackgroundMask(REDRAW_DOOR_1);
4938 SetDrawBackgroundMask(REDRAW_FIELD);
4944 SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
4946 // ---------- handle request buttons ----------
4947 result = RequestHandleEvents(req_state, draw_buffer_last);
4951 if (!(req_state & REQ_STAY_OPEN))
4953 CloseDoor(DOOR_CLOSE_1);
4955 if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
4956 (req_state & REQ_REOPEN))
4957 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
4962 if (game_status == GAME_MODE_PLAYING)
4964 SetPanelBackground();
4965 SetDrawBackgroundMask(REDRAW_DOOR_1);
4969 SetDrawBackgroundMask(REDRAW_FIELD);
4972 // continue network game after request
4973 if (network.enabled &&
4974 game_status == GAME_MODE_PLAYING &&
4975 !game.all_players_gone &&
4976 req_state & REQUEST_WAIT_FOR_INPUT)
4977 SendToServer_ContinuePlaying();
4979 // restore deactivated drawing when quick-loading level tape recording
4980 if (tape.playing && tape.deactivate_display)
4981 TapeDeactivateDisplayOn();
4986 static boolean RequestEnvelope(char *text, unsigned int req_state)
4988 int draw_buffer_last = GetDrawtoField();
4991 if (game_status == GAME_MODE_PLAYING)
4992 BlitScreenToBitmap(backbuffer);
4994 // disable deactivated drawing when quick-loading level tape recording
4995 if (tape.playing && tape.deactivate_display)
4996 TapeDeactivateDisplayOff(TRUE);
4998 SetMouseCursor(CURSOR_DEFAULT);
5000 // pause network game while waiting for request to answer
5001 if (network.enabled &&
5002 game_status == GAME_MODE_PLAYING &&
5003 !game.all_players_gone &&
5004 req_state & REQUEST_WAIT_FOR_INPUT)
5005 SendToServer_PausePlaying();
5007 // simulate releasing mouse button over last gadget, if still pressed
5009 HandleGadgets(-1, -1, 0);
5013 // (replace with setting corresponding request background)
5014 // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
5015 // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
5017 // clear door drawing field
5018 // DrawBackground(DX, DY, DXSIZE, DYSIZE);
5020 ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
5022 if (!(req_state & REQUEST_WAIT_FOR_INPUT))
5024 if (game_status == GAME_MODE_PLAYING)
5026 SetPanelBackground();
5027 SetDrawBackgroundMask(REDRAW_DOOR_1);
5031 SetDrawBackgroundMask(REDRAW_FIELD);
5037 SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
5039 // ---------- handle request buttons ----------
5040 result = RequestHandleEvents(req_state, draw_buffer_last);
5044 ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
5048 if (game_status == GAME_MODE_PLAYING)
5050 SetPanelBackground();
5051 SetDrawBackgroundMask(REDRAW_DOOR_1);
5055 SetDrawBackgroundMask(REDRAW_FIELD);
5058 // continue network game after request
5059 if (network.enabled &&
5060 game_status == GAME_MODE_PLAYING &&
5061 !game.all_players_gone &&
5062 req_state & REQUEST_WAIT_FOR_INPUT)
5063 SendToServer_ContinuePlaying();
5065 // restore deactivated drawing when quick-loading level tape recording
5066 if (tape.playing && tape.deactivate_display)
5067 TapeDeactivateDisplayOn();
5072 boolean Request(char *text, unsigned int req_state)
5074 boolean overlay_enabled = GetOverlayEnabled();
5077 game.request_active_or_moving = TRUE;
5079 SetOverlayEnabled(FALSE);
5081 if (global.use_envelope_request)
5082 result = RequestEnvelope(text, req_state);
5084 result = RequestDoor(text, req_state);
5086 SetOverlayEnabled(overlay_enabled);
5088 game.request_active_or_moving = FALSE;
5093 static int compareDoorPartOrderInfo(const void *object1, const void *object2)
5095 const struct DoorPartOrderInfo *dpo1 = (struct DoorPartOrderInfo *)object1;
5096 const struct DoorPartOrderInfo *dpo2 = (struct DoorPartOrderInfo *)object2;
5099 if (dpo1->sort_priority != dpo2->sort_priority)
5100 compare_result = dpo1->sort_priority - dpo2->sort_priority;
5102 compare_result = dpo1->nr - dpo2->nr;
5104 return compare_result;
5107 void InitGraphicCompatibilityInfo_Doors(void)
5113 struct DoorInfo *door;
5117 { DOOR_1, IMG_GFX_DOOR_1_PART_1, IMG_GFX_DOOR_1_PART_8, &door_1 },
5118 { DOOR_2, IMG_GFX_DOOR_2_PART_1, IMG_GFX_DOOR_2_PART_8, &door_2 },
5120 { -1, -1, -1, NULL }
5122 struct Rect door_rect_list[] =
5124 { DX, DY, DXSIZE, DYSIZE },
5125 { VX, VY, VXSIZE, VYSIZE }
5129 for (i = 0; doors[i].door_token != -1; i++)
5131 int door_token = doors[i].door_token;
5132 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5133 int part_1 = doors[i].part_1;
5134 int part_8 = doors[i].part_8;
5135 int part_2 = part_1 + 1;
5136 int part_3 = part_1 + 2;
5137 struct DoorInfo *door = doors[i].door;
5138 struct Rect *door_rect = &door_rect_list[door_index];
5139 boolean door_gfx_redefined = FALSE;
5141 // check if any door part graphic definitions have been redefined
5143 for (j = 0; door_part_controls[j].door_token != -1; j++)
5145 struct DoorPartControlInfo *dpc = &door_part_controls[j];
5146 struct FileInfo *fi = getImageListEntryFromImageID(dpc->graphic);
5148 if (dpc->door_token == door_token && fi->redefined)
5149 door_gfx_redefined = TRUE;
5152 // check for old-style door graphic/animation modifications
5154 if (!door_gfx_redefined)
5156 if (door->anim_mode & ANIM_STATIC_PANEL)
5158 door->panel.step_xoffset = 0;
5159 door->panel.step_yoffset = 0;
5162 if (door->anim_mode & (ANIM_HORIZONTAL | ANIM_VERTICAL))
5164 struct GraphicInfo *g_part_1 = &graphic_info[part_1];
5165 struct GraphicInfo *g_part_2 = &graphic_info[part_2];
5166 int num_door_steps, num_panel_steps;
5168 // remove door part graphics other than the two default wings
5170 for (j = 0; door_part_controls[j].door_token != -1; j++)
5172 struct DoorPartControlInfo *dpc = &door_part_controls[j];
5173 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5175 if (dpc->graphic >= part_3 &&
5176 dpc->graphic <= part_8)
5180 // set graphics and screen positions of the default wings
5182 g_part_1->width = door_rect->width;
5183 g_part_1->height = door_rect->height;
5184 g_part_2->width = door_rect->width;
5185 g_part_2->height = door_rect->height;
5186 g_part_2->src_x = door_rect->width;
5187 g_part_2->src_y = g_part_1->src_y;
5189 door->part_2.x = door->part_1.x;
5190 door->part_2.y = door->part_1.y;
5192 if (door->width != -1)
5194 g_part_1->width = door->width;
5195 g_part_2->width = door->width;
5197 // special treatment for graphics and screen position of right wing
5198 g_part_2->src_x += door_rect->width - door->width;
5199 door->part_2.x += door_rect->width - door->width;
5202 if (door->height != -1)
5204 g_part_1->height = door->height;
5205 g_part_2->height = door->height;
5207 // special treatment for graphics and screen position of bottom wing
5208 g_part_2->src_y += door_rect->height - door->height;
5209 door->part_2.y += door_rect->height - door->height;
5212 // set animation delays for the default wings and panels
5214 door->part_1.step_delay = door->step_delay;
5215 door->part_2.step_delay = door->step_delay;
5216 door->panel.step_delay = door->step_delay;
5218 // set animation draw order for the default wings
5220 door->part_1.sort_priority = 2; // draw left wing over ...
5221 door->part_2.sort_priority = 1; // ... right wing
5223 // set animation draw offset for the default wings
5225 if (door->anim_mode & ANIM_HORIZONTAL)
5227 door->part_1.step_xoffset = door->step_offset;
5228 door->part_1.step_yoffset = 0;
5229 door->part_2.step_xoffset = door->step_offset * -1;
5230 door->part_2.step_yoffset = 0;
5232 num_door_steps = g_part_1->width / door->step_offset;
5234 else // ANIM_VERTICAL
5236 door->part_1.step_xoffset = 0;
5237 door->part_1.step_yoffset = door->step_offset;
5238 door->part_2.step_xoffset = 0;
5239 door->part_2.step_yoffset = door->step_offset * -1;
5241 num_door_steps = g_part_1->height / door->step_offset;
5244 // set animation draw offset for the default panels
5246 if (door->step_offset > 1)
5248 num_panel_steps = 2 * door_rect->height / door->step_offset;
5249 door->panel.start_step = num_panel_steps - num_door_steps;
5250 door->panel.start_step_closing = door->panel.start_step;
5254 num_panel_steps = door_rect->height / door->step_offset;
5255 door->panel.start_step = num_panel_steps - num_door_steps / 2;
5256 door->panel.start_step_closing = door->panel.start_step;
5257 door->panel.step_delay *= 2;
5264 void InitDoors(void)
5268 for (i = 0; door_part_controls[i].door_token != -1; i++)
5270 struct DoorPartControlInfo *dpc = &door_part_controls[i];
5271 struct DoorPartOrderInfo *dpo = &door_part_order[i];
5273 // initialize "start_step_opening" and "start_step_closing", if needed
5274 if (dpc->pos->start_step_opening == 0 &&
5275 dpc->pos->start_step_closing == 0)
5277 // dpc->pos->start_step_opening = dpc->pos->start_step;
5278 dpc->pos->start_step_closing = dpc->pos->start_step;
5281 // fill structure for door part draw order (sorted below)
5283 dpo->sort_priority = dpc->pos->sort_priority;
5286 // sort door part controls according to sort_priority and graphic number
5287 qsort(door_part_order, MAX_DOOR_PARTS,
5288 sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
5291 unsigned int OpenDoor(unsigned int door_state)
5293 if (door_state & DOOR_COPY_BACK)
5295 if (door_state & DOOR_OPEN_1)
5296 BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
5297 1 * DXSIZE, 0, DXSIZE, DYSIZE, 0 * DXSIZE, 0);
5299 if (door_state & DOOR_OPEN_2)
5300 BlitBitmap(bitmap_db_door_2, bitmap_db_door_2,
5301 1 * VXSIZE, 0, VXSIZE, VYSIZE, 0 * VXSIZE, 0);
5303 door_state &= ~DOOR_COPY_BACK;
5306 return MoveDoor(door_state);
5309 unsigned int CloseDoor(unsigned int door_state)
5311 unsigned int old_door_state = GetDoorState();
5313 if (!(door_state & DOOR_NO_COPY_BACK))
5315 if (old_door_state & DOOR_OPEN_1)
5316 BlitBitmap(backbuffer, bitmap_db_door_1,
5317 DX, DY, DXSIZE, DYSIZE, 0, 0);
5319 if (old_door_state & DOOR_OPEN_2)
5320 BlitBitmap(backbuffer, bitmap_db_door_2,
5321 VX, VY, VXSIZE, VYSIZE, 0, 0);
5323 door_state &= ~DOOR_NO_COPY_BACK;
5326 return MoveDoor(door_state);
5329 unsigned int GetDoorState(void)
5331 return MoveDoor(DOOR_GET_STATE);
5334 unsigned int SetDoorState(unsigned int door_state)
5336 return MoveDoor(door_state | DOOR_SET_STATE);
5339 static int euclid(int a, int b)
5341 return (b ? euclid(b, a % b) : a);
5344 unsigned int MoveDoor(unsigned int door_state)
5346 struct Rect door_rect_list[] =
5348 { DX, DY, DXSIZE, DYSIZE },
5349 { VX, VY, VXSIZE, VYSIZE }
5351 static int door1 = DOOR_CLOSE_1;
5352 static int door2 = DOOR_CLOSE_2;
5353 DelayCounter door_delay = { 0 };
5356 if (door_state == DOOR_GET_STATE)
5357 return (door1 | door2);
5359 if (door_state & DOOR_SET_STATE)
5361 if (door_state & DOOR_ACTION_1)
5362 door1 = door_state & DOOR_ACTION_1;
5363 if (door_state & DOOR_ACTION_2)
5364 door2 = door_state & DOOR_ACTION_2;
5366 return (door1 | door2);
5369 if (!(door_state & DOOR_FORCE_REDRAW))
5371 if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
5372 door_state &= ~DOOR_OPEN_1;
5373 else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
5374 door_state &= ~DOOR_CLOSE_1;
5375 if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
5376 door_state &= ~DOOR_OPEN_2;
5377 else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
5378 door_state &= ~DOOR_CLOSE_2;
5381 if (global.autoplay_leveldir)
5383 door_state |= DOOR_NO_DELAY;
5384 door_state &= ~DOOR_CLOSE_ALL;
5387 if (game_status == GAME_MODE_EDITOR && !(door_state & DOOR_FORCE_ANIM))
5388 door_state |= DOOR_NO_DELAY;
5390 if (door_state & DOOR_ACTION)
5392 boolean door_panel_drawn[NUM_DOORS];
5393 boolean panel_has_doors[NUM_DOORS];
5394 boolean door_part_skip[MAX_DOOR_PARTS];
5395 boolean door_part_done[MAX_DOOR_PARTS];
5396 boolean door_part_done_all;
5397 int num_steps[MAX_DOOR_PARTS];
5398 int max_move_delay = 0; // delay for complete animations of all doors
5399 int max_step_delay = 0; // delay (ms) between two animation frames
5400 int num_move_steps = 0; // number of animation steps for all doors
5401 int max_move_delay_doors_only = 0; // delay for doors only (no panel)
5402 int num_move_steps_doors_only = 0; // steps for doors only (no panel)
5406 for (i = 0; i < NUM_DOORS; i++)
5407 panel_has_doors[i] = FALSE;
5409 for (i = 0; i < MAX_DOOR_PARTS; i++)
5411 struct DoorPartControlInfo *dpc = &door_part_controls[i];
5412 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5413 int door_token = dpc->door_token;
5415 door_part_done[i] = FALSE;
5416 door_part_skip[i] = (!(door_state & door_token) ||
5420 for (i = 0; i < MAX_DOOR_PARTS; i++)
5422 int nr = door_part_order[i].nr;
5423 struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5424 struct DoorPartPosInfo *pos = dpc->pos;
5425 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5426 int door_token = dpc->door_token;
5427 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5428 boolean is_panel = DOOR_PART_IS_PANEL(nr);
5429 int step_xoffset = ABS(pos->step_xoffset);
5430 int step_yoffset = ABS(pos->step_yoffset);
5431 int step_delay = pos->step_delay;
5432 int current_door_state = door_state & door_token;
5433 boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
5434 boolean door_closing = ((current_door_state & DOOR_CLOSE) != 0);
5435 boolean part_opening = (is_panel ? door_closing : door_opening);
5436 int start_step = (part_opening ? pos->start_step_opening :
5437 pos->start_step_closing);
5438 float move_xsize = (step_xoffset ? g->width : 0);
5439 float move_ysize = (step_yoffset ? g->height : 0);
5440 int move_xsteps = (step_xoffset ? ceil(move_xsize / step_xoffset) : 0);
5441 int move_ysteps = (step_yoffset ? ceil(move_ysize / step_yoffset) : 0);
5442 int move_steps = (move_xsteps && move_ysteps ?
5443 MIN(move_xsteps, move_ysteps) :
5444 move_xsteps ? move_xsteps : move_ysteps) - start_step;
5445 int move_delay = move_steps * step_delay;
5447 if (door_part_skip[nr])
5450 max_move_delay = MAX(max_move_delay, move_delay);
5451 max_step_delay = (max_step_delay == 0 ? step_delay :
5452 euclid(max_step_delay, step_delay));
5453 num_steps[nr] = move_steps;
5457 max_move_delay_doors_only = MAX(max_move_delay_doors_only, move_delay);
5459 panel_has_doors[door_index] = TRUE;
5463 max_step_delay = MAX(1, max_step_delay); // prevent division by zero
5465 num_move_steps = max_move_delay / max_step_delay;
5466 num_move_steps_doors_only = max_move_delay_doors_only / max_step_delay;
5468 door_delay.value = max_step_delay;
5470 if ((door_state & DOOR_NO_DELAY) || setup.quick_doors)
5472 start = num_move_steps - 1;
5476 // opening door sound has priority over simultaneously closing door
5477 if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
5479 PlayMenuSoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
5481 if (door_state & DOOR_OPEN_1)
5482 PlayMenuSoundStereo(SND_DOOR_1_OPENING, SOUND_MIDDLE);
5483 if (door_state & DOOR_OPEN_2)
5484 PlayMenuSoundStereo(SND_DOOR_2_OPENING, SOUND_MIDDLE);
5486 else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
5488 PlayMenuSoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
5490 if (door_state & DOOR_CLOSE_1)
5491 PlayMenuSoundStereo(SND_DOOR_1_CLOSING, SOUND_MIDDLE);
5492 if (door_state & DOOR_CLOSE_2)
5493 PlayMenuSoundStereo(SND_DOOR_2_CLOSING, SOUND_MIDDLE);
5497 for (k = start; k < num_move_steps; k++)
5499 int last_frame = num_move_steps - 1; // last frame of this "for" loop
5501 door_part_done_all = TRUE;
5503 for (i = 0; i < NUM_DOORS; i++)
5504 door_panel_drawn[i] = FALSE;
5506 for (i = 0; i < MAX_DOOR_PARTS; i++)
5508 int nr = door_part_order[i].nr;
5509 struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5510 struct DoorPartPosInfo *pos = dpc->pos;
5511 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5512 int door_token = dpc->door_token;
5513 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5514 boolean is_panel = DOOR_PART_IS_PANEL(nr);
5515 boolean is_panel_and_door_has_closed = FALSE;
5516 struct Rect *door_rect = &door_rect_list[door_index];
5517 Bitmap *bitmap_db_door = (door_token == DOOR_1 ? bitmap_db_door_1 :
5519 Bitmap *bitmap = (is_panel ? bitmap_db_door : g->bitmap);
5520 int current_door_state = door_state & door_token;
5521 boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
5522 boolean door_closing = !door_opening;
5523 boolean part_opening = (is_panel ? door_closing : door_opening);
5524 boolean part_closing = !part_opening;
5525 int start_step = (part_opening ? pos->start_step_opening :
5526 pos->start_step_closing);
5527 int step_delay = pos->step_delay;
5528 int step_factor = step_delay / max_step_delay;
5529 int k1 = (step_factor ? k / step_factor + 1 : k);
5530 int k2 = (part_opening ? k1 + start_step : num_steps[nr] - k1);
5531 int kk = MAX(0, k2);
5534 int src_x, src_y, src_xx, src_yy;
5535 int dst_x, dst_y, dst_xx, dst_yy;
5538 if (door_part_skip[nr])
5541 if (!(door_state & door_token))
5549 int k2_door = (door_opening ? k : num_move_steps_doors_only - k - 1);
5550 int kk_door = MAX(0, k2_door);
5551 int sync_frame = kk_door * door_delay.value;
5552 int frame = getGraphicAnimationFrame(dpc->graphic, sync_frame);
5554 getFixedGraphicSource(dpc->graphic, frame, &bitmap,
5555 &g_src_x, &g_src_y);
5560 if (!door_panel_drawn[door_index])
5562 ClearRectangle(drawto, door_rect->x, door_rect->y,
5563 door_rect->width, door_rect->height);
5565 door_panel_drawn[door_index] = TRUE;
5568 // draw opening or closing door parts
5570 if (pos->step_xoffset < 0) // door part on right side
5573 dst_xx = pos->x + ABS(kk * pos->step_xoffset);
5576 if (dst_xx + width > door_rect->width)
5577 width = door_rect->width - dst_xx;
5579 else // door part on left side
5582 dst_xx = pos->x - kk * pos->step_xoffset;
5586 src_xx = ABS(dst_xx);
5590 width = g->width - src_xx;
5592 if (width > door_rect->width)
5593 width = door_rect->width;
5595 // Debug("tools:MoveDoor", "k == %d [%d]", k, start_step);
5598 if (pos->step_yoffset < 0) // door part on bottom side
5601 dst_yy = pos->y + ABS(kk * pos->step_yoffset);
5604 if (dst_yy + height > door_rect->height)
5605 height = door_rect->height - dst_yy;
5607 else // door part on top side
5610 dst_yy = pos->y - kk * pos->step_yoffset;
5614 src_yy = ABS(dst_yy);
5618 height = g->height - src_yy;
5621 src_x = g_src_x + src_xx;
5622 src_y = g_src_y + src_yy;
5624 dst_x = door_rect->x + dst_xx;
5625 dst_y = door_rect->y + dst_yy;
5627 is_panel_and_door_has_closed =
5630 panel_has_doors[door_index] &&
5631 k >= num_move_steps_doors_only - 1);
5633 if (width >= 0 && width <= g->width &&
5634 height >= 0 && height <= g->height &&
5635 !is_panel_and_door_has_closed)
5637 if (is_panel || !pos->draw_masked)
5638 BlitBitmap(bitmap, drawto, src_x, src_y, width, height,
5641 BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height,
5645 redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
5647 if ((part_opening && (width < 0 || height < 0)) ||
5648 (part_closing && (width >= g->width && height >= g->height)))
5649 door_part_done[nr] = TRUE;
5651 // continue door part animations, but not panel after door has closed
5652 if (!door_part_done[nr] && !is_panel_and_door_has_closed)
5653 door_part_done_all = FALSE;
5656 if (!(door_state & DOOR_NO_DELAY))
5660 SkipUntilDelayReached(&door_delay, &k, last_frame);
5662 // prevent OS (Windows) from complaining about program not responding
5666 if (door_part_done_all)
5670 if (!(door_state & DOOR_NO_DELAY))
5672 // wait for specified door action post delay
5673 if (door_state & DOOR_ACTION_1 && door_state & DOOR_ACTION_2)
5674 door_delay.value = MAX(door_1.post_delay, door_2.post_delay);
5675 else if (door_state & DOOR_ACTION_1)
5676 door_delay.value = door_1.post_delay;
5677 else if (door_state & DOOR_ACTION_2)
5678 door_delay.value = door_2.post_delay;
5680 while (!DelayReached(&door_delay))
5685 if (door_state & DOOR_ACTION_1)
5686 door1 = door_state & DOOR_ACTION_1;
5687 if (door_state & DOOR_ACTION_2)
5688 door2 = door_state & DOOR_ACTION_2;
5690 // draw masked border over door area
5691 DrawMaskedBorder(REDRAW_DOOR_1);
5692 DrawMaskedBorder(REDRAW_DOOR_2);
5694 ClearAutoRepeatKeyEvents();
5696 return (door1 | door2);
5699 static boolean useSpecialEditorDoor(void)
5701 int graphic = IMG_GLOBAL_BORDER_EDITOR;
5702 boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
5704 // do not draw special editor door if editor border defined or redefined
5705 if (graphic_info[graphic].bitmap != NULL || redefined)
5708 // do not draw special editor door if global border defined to be empty
5709 if (graphic_info[IMG_GLOBAL_BORDER].bitmap == NULL)
5712 // do not draw special editor door if viewport definitions do not match
5716 EY + EYSIZE != VY + VYSIZE)
5722 void DrawSpecialEditorDoor(void)
5724 struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5725 int top_border_width = gfx1->width;
5726 int top_border_height = gfx1->height;
5727 int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5728 int ex = EX - outer_border;
5729 int ey = EY - outer_border;
5730 int vy = VY - outer_border;
5731 int exsize = EXSIZE + 2 * outer_border;
5733 if (!useSpecialEditorDoor())
5736 // draw bigger level editor toolbox window
5737 BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
5738 top_border_width, top_border_height, ex, ey - top_border_height);
5739 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
5740 exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
5742 redraw_mask |= REDRAW_ALL;
5745 void UndrawSpecialEditorDoor(void)
5747 struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5748 int top_border_width = gfx1->width;
5749 int top_border_height = gfx1->height;
5750 int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5751 int ex = EX - outer_border;
5752 int ey = EY - outer_border;
5753 int ey_top = ey - top_border_height;
5754 int exsize = EXSIZE + 2 * outer_border;
5755 int eysize = EYSIZE + 2 * outer_border;
5757 if (!useSpecialEditorDoor())
5760 // draw normal tape recorder window
5761 if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
5763 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5764 ex, ey_top, top_border_width, top_border_height,
5766 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5767 ex, ey, exsize, eysize, ex, ey);
5771 // if screen background is set to "[NONE]", clear editor toolbox window
5772 ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
5773 ClearRectangle(drawto, ex, ey, exsize, eysize);
5776 redraw_mask |= REDRAW_ALL;
5780 // ---------- new tool button stuff -------------------------------------------
5785 struct TextPosInfo *pos;
5787 boolean is_touch_button;
5789 } toolbutton_info[NUM_TOOL_BUTTONS] =
5792 IMG_GFX_REQUEST_BUTTON_YES, &request.button.yes,
5793 TOOL_CTRL_ID_YES, FALSE, "yes"
5796 IMG_GFX_REQUEST_BUTTON_NO, &request.button.no,
5797 TOOL_CTRL_ID_NO, FALSE, "no"
5800 IMG_GFX_REQUEST_BUTTON_CONFIRM, &request.button.confirm,
5801 TOOL_CTRL_ID_CONFIRM, FALSE, "confirm"
5804 IMG_GFX_REQUEST_BUTTON_PLAYER_1, &request.button.player_1,
5805 TOOL_CTRL_ID_PLAYER_1, FALSE, "player 1"
5808 IMG_GFX_REQUEST_BUTTON_PLAYER_2, &request.button.player_2,
5809 TOOL_CTRL_ID_PLAYER_2, FALSE, "player 2"
5812 IMG_GFX_REQUEST_BUTTON_PLAYER_3, &request.button.player_3,
5813 TOOL_CTRL_ID_PLAYER_3, FALSE, "player 3"
5816 IMG_GFX_REQUEST_BUTTON_PLAYER_4, &request.button.player_4,
5817 TOOL_CTRL_ID_PLAYER_4, FALSE, "player 4"
5820 IMG_GFX_REQUEST_BUTTON_TOUCH_YES, &request.button.touch_yes,
5821 TOOL_CTRL_ID_TOUCH_YES, TRUE, "yes"
5824 IMG_GFX_REQUEST_BUTTON_TOUCH_NO, &request.button.touch_no,
5825 TOOL_CTRL_ID_TOUCH_NO, TRUE, "no"
5828 IMG_GFX_REQUEST_BUTTON_TOUCH_CONFIRM, &request.button.touch_confirm,
5829 TOOL_CTRL_ID_TOUCH_CONFIRM, TRUE, "confirm"
5833 void CreateToolButtons(void)
5837 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5839 int graphic = toolbutton_info[i].graphic;
5840 struct GraphicInfo *gfx = &graphic_info[graphic];
5841 struct TextPosInfo *pos = toolbutton_info[i].pos;
5842 struct GadgetInfo *gi;
5843 Bitmap *deco_bitmap = None;
5844 int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
5845 unsigned int event_mask = GD_EVENT_RELEASED;
5846 boolean is_touch_button = toolbutton_info[i].is_touch_button;
5847 int base_x = (is_touch_button ? 0 : DX);
5848 int base_y = (is_touch_button ? 0 : DY);
5849 int gd_x = gfx->src_x;
5850 int gd_y = gfx->src_y;
5851 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
5852 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
5857 // do not use touch buttons if overlay touch buttons are disabled
5858 if (is_touch_button && !setup.touch.overlay_buttons)
5861 if (global.use_envelope_request && !is_touch_button)
5863 setRequestPosition(&base_x, &base_y, TRUE);
5865 // check if request buttons are outside of envelope and fix, if needed
5866 if (x < 0 || x + gfx->width > request.width ||
5867 y < 0 || y + gfx->height > request.height)
5869 if (id == TOOL_CTRL_ID_YES)
5872 y = request.height - 2 * request.border_size - gfx->height;
5874 else if (id == TOOL_CTRL_ID_NO)
5876 x = request.width - 2 * request.border_size - gfx->width;
5877 y = request.height - 2 * request.border_size - gfx->height;
5879 else if (id == TOOL_CTRL_ID_CONFIRM)
5881 x = (request.width - 2 * request.border_size - gfx->width) / 2;
5882 y = request.height - 2 * request.border_size - gfx->height;
5884 else if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
5886 int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5888 x = (request.width - 2 * request.border_size - gfx->width) / 2;
5889 y = request.height - 2 * request.border_size - gfx->height * 2;
5891 x += (player_nr == 3 ? -1 : player_nr == 1 ? +1 : 0) * gfx->width;
5892 y += (player_nr == 0 ? -1 : player_nr == 2 ? +1 : 0) * gfx->height;
5897 if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4 &&
5900 int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5902 getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
5903 pos->size, &deco_bitmap, &deco_x, &deco_y);
5904 deco_xpos = (gfx->width - pos->size) / 2;
5905 deco_ypos = (gfx->height - pos->size) / 2;
5908 gi = CreateGadget(GDI_CUSTOM_ID, id,
5909 GDI_IMAGE_ID, graphic,
5910 GDI_INFO_TEXT, toolbutton_info[i].infotext,
5913 GDI_WIDTH, gfx->width,
5914 GDI_HEIGHT, gfx->height,
5915 GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
5916 GDI_STATE, GD_BUTTON_UNPRESSED,
5917 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
5918 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
5919 GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
5920 GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
5921 GDI_DECORATION_SIZE, pos->size, pos->size,
5922 GDI_DECORATION_SHIFTING, 1, 1,
5923 GDI_DIRECT_DRAW, FALSE,
5924 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
5925 GDI_EVENT_MASK, event_mask,
5926 GDI_CALLBACK_ACTION, HandleToolButtons,
5930 Fail("cannot create gadget");
5932 tool_gadget[id] = gi;
5936 void FreeToolButtons(void)
5940 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5941 FreeGadget(tool_gadget[i]);
5944 static void UnmapToolButtons(void)
5948 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5949 UnmapGadget(tool_gadget[i]);
5952 static void HandleToolButtons(struct GadgetInfo *gi)
5954 request_gadget_id = gi->custom_id;
5957 static struct Mapping_EM_to_RND_object
5960 boolean is_rnd_to_em_mapping; // unique mapping EM <-> RND
5961 boolean is_backside; // backside of moving element
5967 em_object_mapping_list[GAME_TILE_MAX + 1] =
5970 Zborder, FALSE, FALSE,
5974 Zplayer, FALSE, FALSE,
5983 Ztank, FALSE, FALSE,
5987 Zeater, FALSE, FALSE,
5991 Zdynamite, FALSE, FALSE,
5995 Zboom, FALSE, FALSE,
6000 Xchain, FALSE, FALSE,
6001 EL_DEFAULT, ACTION_EXPLODING, -1
6004 Xboom_bug, FALSE, FALSE,
6005 EL_BUG, ACTION_EXPLODING, -1
6008 Xboom_tank, FALSE, FALSE,
6009 EL_SPACESHIP, ACTION_EXPLODING, -1
6012 Xboom_android, FALSE, FALSE,
6013 EL_EMC_ANDROID, ACTION_OTHER, -1
6016 Xboom_1, FALSE, FALSE,
6017 EL_DEFAULT, ACTION_EXPLODING, -1
6020 Xboom_2, FALSE, FALSE,
6021 EL_DEFAULT, ACTION_EXPLODING, -1
6025 Xblank, TRUE, FALSE,
6030 Xsplash_e, FALSE, FALSE,
6031 EL_ACID_SPLASH_RIGHT, -1, -1
6034 Xsplash_w, FALSE, FALSE,
6035 EL_ACID_SPLASH_LEFT, -1, -1
6039 Xplant, TRUE, FALSE,
6040 EL_EMC_PLANT, -1, -1
6043 Yplant, FALSE, FALSE,
6044 EL_EMC_PLANT, -1, -1
6048 Xacid_1, TRUE, FALSE,
6052 Xacid_2, FALSE, FALSE,
6056 Xacid_3, FALSE, FALSE,
6060 Xacid_4, FALSE, FALSE,
6064 Xacid_5, FALSE, FALSE,
6068 Xacid_6, FALSE, FALSE,
6072 Xacid_7, FALSE, FALSE,
6076 Xacid_8, FALSE, FALSE,
6081 Xfake_acid_1, TRUE, FALSE,
6082 EL_EMC_FAKE_ACID, -1, -1
6085 Xfake_acid_2, FALSE, FALSE,
6086 EL_EMC_FAKE_ACID, -1, -1
6089 Xfake_acid_3, FALSE, FALSE,
6090 EL_EMC_FAKE_ACID, -1, -1
6093 Xfake_acid_4, FALSE, FALSE,
6094 EL_EMC_FAKE_ACID, -1, -1
6097 Xfake_acid_5, FALSE, FALSE,
6098 EL_EMC_FAKE_ACID, -1, -1
6101 Xfake_acid_6, FALSE, FALSE,
6102 EL_EMC_FAKE_ACID, -1, -1
6105 Xfake_acid_7, FALSE, FALSE,
6106 EL_EMC_FAKE_ACID, -1, -1
6109 Xfake_acid_8, FALSE, FALSE,
6110 EL_EMC_FAKE_ACID, -1, -1
6114 Xfake_acid_1_player, FALSE, FALSE,
6115 EL_EMC_FAKE_ACID, -1, -1
6118 Xfake_acid_2_player, FALSE, FALSE,
6119 EL_EMC_FAKE_ACID, -1, -1
6122 Xfake_acid_3_player, FALSE, FALSE,
6123 EL_EMC_FAKE_ACID, -1, -1
6126 Xfake_acid_4_player, FALSE, FALSE,
6127 EL_EMC_FAKE_ACID, -1, -1
6130 Xfake_acid_5_player, FALSE, FALSE,
6131 EL_EMC_FAKE_ACID, -1, -1
6134 Xfake_acid_6_player, FALSE, FALSE,
6135 EL_EMC_FAKE_ACID, -1, -1
6138 Xfake_acid_7_player, FALSE, FALSE,
6139 EL_EMC_FAKE_ACID, -1, -1
6142 Xfake_acid_8_player, FALSE, FALSE,
6143 EL_EMC_FAKE_ACID, -1, -1
6147 Xgrass, TRUE, FALSE,
6148 EL_EMC_GRASS, -1, -1
6151 Ygrass_nB, FALSE, FALSE,
6152 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_UP
6155 Ygrass_eB, FALSE, FALSE,
6156 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_RIGHT
6159 Ygrass_sB, FALSE, FALSE,
6160 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_DOWN
6163 Ygrass_wB, FALSE, FALSE,
6164 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_LEFT
6172 Ydirt_nB, FALSE, FALSE,
6173 EL_SAND, ACTION_DIGGING, MV_BIT_UP
6176 Ydirt_eB, FALSE, FALSE,
6177 EL_SAND, ACTION_DIGGING, MV_BIT_RIGHT
6180 Ydirt_sB, FALSE, FALSE,
6181 EL_SAND, ACTION_DIGGING, MV_BIT_DOWN
6184 Ydirt_wB, FALSE, FALSE,
6185 EL_SAND, ACTION_DIGGING, MV_BIT_LEFT
6189 Xandroid, TRUE, FALSE,
6190 EL_EMC_ANDROID, ACTION_ACTIVE, -1
6193 Xandroid_1_n, FALSE, FALSE,
6194 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
6197 Xandroid_2_n, FALSE, FALSE,
6198 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
6201 Xandroid_1_e, FALSE, FALSE,
6202 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
6205 Xandroid_2_e, FALSE, FALSE,
6206 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
6209 Xandroid_1_w, FALSE, FALSE,
6210 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
6213 Xandroid_2_w, FALSE, FALSE,
6214 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
6217 Xandroid_1_s, FALSE, FALSE,
6218 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
6221 Xandroid_2_s, FALSE, FALSE,
6222 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
6225 Yandroid_n, FALSE, FALSE,
6226 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
6229 Yandroid_nB, FALSE, TRUE,
6230 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
6233 Yandroid_ne, FALSE, FALSE,
6234 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPRIGHT
6237 Yandroid_neB, FALSE, TRUE,
6238 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPRIGHT
6241 Yandroid_e, FALSE, FALSE,
6242 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
6245 Yandroid_eB, FALSE, TRUE,
6246 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
6249 Yandroid_se, FALSE, FALSE,
6250 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNRIGHT
6253 Yandroid_seB, FALSE, TRUE,
6254 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNRIGHT
6257 Yandroid_s, FALSE, FALSE,
6258 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
6261 Yandroid_sB, FALSE, TRUE,
6262 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
6265 Yandroid_sw, FALSE, FALSE,
6266 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNLEFT
6269 Yandroid_swB, FALSE, TRUE,
6270 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNLEFT
6273 Yandroid_w, FALSE, FALSE,
6274 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
6277 Yandroid_wB, FALSE, TRUE,
6278 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
6281 Yandroid_nw, FALSE, FALSE,
6282 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPLEFT
6285 Yandroid_nwB, FALSE, TRUE,
6286 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPLEFT
6290 Xeater_n, TRUE, FALSE,
6291 EL_YAMYAM_UP, -1, -1
6294 Xeater_e, TRUE, FALSE,
6295 EL_YAMYAM_RIGHT, -1, -1
6298 Xeater_w, TRUE, FALSE,
6299 EL_YAMYAM_LEFT, -1, -1
6302 Xeater_s, TRUE, FALSE,
6303 EL_YAMYAM_DOWN, -1, -1
6306 Yeater_n, FALSE, FALSE,
6307 EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
6310 Yeater_nB, FALSE, TRUE,
6311 EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
6314 Yeater_e, FALSE, FALSE,
6315 EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
6318 Yeater_eB, FALSE, TRUE,
6319 EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
6322 Yeater_s, FALSE, FALSE,
6323 EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
6326 Yeater_sB, FALSE, TRUE,
6327 EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
6330 Yeater_w, FALSE, FALSE,
6331 EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
6334 Yeater_wB, FALSE, TRUE,
6335 EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
6338 Yeater_stone, FALSE, FALSE,
6339 EL_YAMYAM, ACTION_SMASHED_BY_ROCK, -1
6342 Yeater_spring, FALSE, FALSE,
6343 EL_YAMYAM, ACTION_SMASHED_BY_SPRING, -1
6347 Xalien, TRUE, FALSE,
6351 Xalien_pause, FALSE, FALSE,
6355 Yalien_n, FALSE, FALSE,
6356 EL_ROBOT, ACTION_MOVING, MV_BIT_UP
6359 Yalien_nB, FALSE, TRUE,
6360 EL_ROBOT, ACTION_MOVING, MV_BIT_UP
6363 Yalien_e, FALSE, FALSE,
6364 EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
6367 Yalien_eB, FALSE, TRUE,
6368 EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
6371 Yalien_s, FALSE, FALSE,
6372 EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
6375 Yalien_sB, FALSE, TRUE,
6376 EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
6379 Yalien_w, FALSE, FALSE,
6380 EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
6383 Yalien_wB, FALSE, TRUE,
6384 EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
6387 Yalien_stone, FALSE, FALSE,
6388 EL_ROBOT, ACTION_SMASHED_BY_ROCK, -1
6391 Yalien_spring, FALSE, FALSE,
6392 EL_ROBOT, ACTION_SMASHED_BY_SPRING, -1
6396 Xbug_1_n, TRUE, FALSE,
6400 Xbug_1_e, TRUE, FALSE,
6401 EL_BUG_RIGHT, -1, -1
6404 Xbug_1_s, TRUE, FALSE,
6408 Xbug_1_w, TRUE, FALSE,
6412 Xbug_2_n, FALSE, FALSE,
6416 Xbug_2_e, FALSE, FALSE,
6417 EL_BUG_RIGHT, -1, -1
6420 Xbug_2_s, FALSE, FALSE,
6424 Xbug_2_w, FALSE, FALSE,
6428 Ybug_n, FALSE, FALSE,
6429 EL_BUG, ACTION_MOVING, MV_BIT_UP
6432 Ybug_nB, FALSE, TRUE,
6433 EL_BUG, ACTION_MOVING, MV_BIT_UP
6436 Ybug_e, FALSE, FALSE,
6437 EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
6440 Ybug_eB, FALSE, TRUE,
6441 EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
6444 Ybug_s, FALSE, FALSE,
6445 EL_BUG, ACTION_MOVING, MV_BIT_DOWN
6448 Ybug_sB, FALSE, TRUE,
6449 EL_BUG, ACTION_MOVING, MV_BIT_DOWN
6452 Ybug_w, FALSE, FALSE,
6453 EL_BUG, ACTION_MOVING, MV_BIT_LEFT
6456 Ybug_wB, FALSE, TRUE,
6457 EL_BUG, ACTION_MOVING, MV_BIT_LEFT
6460 Ybug_w_n, FALSE, FALSE,
6461 EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
6464 Ybug_n_e, FALSE, FALSE,
6465 EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
6468 Ybug_e_s, FALSE, FALSE,
6469 EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
6472 Ybug_s_w, FALSE, FALSE,
6473 EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
6476 Ybug_e_n, FALSE, FALSE,
6477 EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
6480 Ybug_s_e, FALSE, FALSE,
6481 EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
6484 Ybug_w_s, FALSE, FALSE,
6485 EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
6488 Ybug_n_w, FALSE, FALSE,
6489 EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
6492 Ybug_stone, FALSE, FALSE,
6493 EL_BUG, ACTION_SMASHED_BY_ROCK, -1
6496 Ybug_spring, FALSE, FALSE,
6497 EL_BUG, ACTION_SMASHED_BY_SPRING, -1
6501 Xtank_1_n, TRUE, FALSE,
6502 EL_SPACESHIP_UP, -1, -1
6505 Xtank_1_e, TRUE, FALSE,
6506 EL_SPACESHIP_RIGHT, -1, -1
6509 Xtank_1_s, TRUE, FALSE,
6510 EL_SPACESHIP_DOWN, -1, -1
6513 Xtank_1_w, TRUE, FALSE,
6514 EL_SPACESHIP_LEFT, -1, -1
6517 Xtank_2_n, FALSE, FALSE,
6518 EL_SPACESHIP_UP, -1, -1
6521 Xtank_2_e, FALSE, FALSE,
6522 EL_SPACESHIP_RIGHT, -1, -1
6525 Xtank_2_s, FALSE, FALSE,
6526 EL_SPACESHIP_DOWN, -1, -1
6529 Xtank_2_w, FALSE, FALSE,
6530 EL_SPACESHIP_LEFT, -1, -1
6533 Ytank_n, FALSE, FALSE,
6534 EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
6537 Ytank_nB, FALSE, TRUE,
6538 EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
6541 Ytank_e, FALSE, FALSE,
6542 EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
6545 Ytank_eB, FALSE, TRUE,
6546 EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
6549 Ytank_s, FALSE, FALSE,
6550 EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
6553 Ytank_sB, FALSE, TRUE,
6554 EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
6557 Ytank_w, FALSE, FALSE,
6558 EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
6561 Ytank_wB, FALSE, TRUE,
6562 EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
6565 Ytank_w_n, FALSE, FALSE,
6566 EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
6569 Ytank_n_e, FALSE, FALSE,
6570 EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
6573 Ytank_e_s, FALSE, FALSE,
6574 EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
6577 Ytank_s_w, FALSE, FALSE,
6578 EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
6581 Ytank_e_n, FALSE, FALSE,
6582 EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
6585 Ytank_s_e, FALSE, FALSE,
6586 EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
6589 Ytank_w_s, FALSE, FALSE,
6590 EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
6593 Ytank_n_w, FALSE, FALSE,
6594 EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
6597 Ytank_stone, FALSE, FALSE,
6598 EL_SPACESHIP, ACTION_SMASHED_BY_ROCK, -1
6601 Ytank_spring, FALSE, FALSE,
6602 EL_SPACESHIP, ACTION_SMASHED_BY_SPRING, -1
6606 Xemerald, TRUE, FALSE,
6610 Xemerald_pause, FALSE, FALSE,
6614 Xemerald_fall, FALSE, FALSE,
6618 Xemerald_shine, FALSE, FALSE,
6619 EL_EMERALD, ACTION_TWINKLING, -1
6622 Yemerald_s, FALSE, FALSE,
6623 EL_EMERALD, ACTION_FALLING, -1
6626 Yemerald_sB, FALSE, TRUE,
6627 EL_EMERALD, ACTION_FALLING, -1
6630 Yemerald_e, FALSE, FALSE,
6631 EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
6634 Yemerald_eB, FALSE, TRUE,
6635 EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
6638 Yemerald_w, FALSE, FALSE,
6639 EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
6642 Yemerald_wB, FALSE, TRUE,
6643 EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
6646 Yemerald_blank, FALSE, FALSE,
6647 EL_EMERALD, ACTION_COLLECTING, -1
6651 Xdiamond, TRUE, FALSE,
6655 Xdiamond_pause, FALSE, FALSE,
6659 Xdiamond_fall, FALSE, FALSE,
6663 Xdiamond_shine, FALSE, FALSE,
6664 EL_DIAMOND, ACTION_TWINKLING, -1
6667 Ydiamond_s, FALSE, FALSE,
6668 EL_DIAMOND, ACTION_FALLING, -1
6671 Ydiamond_sB, FALSE, TRUE,
6672 EL_DIAMOND, ACTION_FALLING, -1
6675 Ydiamond_e, FALSE, FALSE,
6676 EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
6679 Ydiamond_eB, FALSE, TRUE,
6680 EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
6683 Ydiamond_w, FALSE, FALSE,
6684 EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
6687 Ydiamond_wB, FALSE, TRUE,
6688 EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
6691 Ydiamond_blank, FALSE, FALSE,
6692 EL_DIAMOND, ACTION_COLLECTING, -1
6695 Ydiamond_stone, FALSE, FALSE,
6696 EL_DIAMOND, ACTION_SMASHED_BY_ROCK, -1
6700 Xstone, TRUE, FALSE,
6704 Xstone_pause, FALSE, FALSE,
6708 Xstone_fall, FALSE, FALSE,
6712 Ystone_s, FALSE, FALSE,
6713 EL_ROCK, ACTION_FALLING, -1
6716 Ystone_sB, FALSE, TRUE,
6717 EL_ROCK, ACTION_FALLING, -1
6720 Ystone_e, FALSE, FALSE,
6721 EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
6724 Ystone_eB, FALSE, TRUE,
6725 EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
6728 Ystone_w, FALSE, FALSE,
6729 EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
6732 Ystone_wB, FALSE, TRUE,
6733 EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
6741 Xbomb_pause, FALSE, FALSE,
6745 Xbomb_fall, FALSE, FALSE,
6749 Ybomb_s, FALSE, FALSE,
6750 EL_BOMB, ACTION_FALLING, -1
6753 Ybomb_sB, FALSE, TRUE,
6754 EL_BOMB, ACTION_FALLING, -1
6757 Ybomb_e, FALSE, FALSE,
6758 EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
6761 Ybomb_eB, FALSE, TRUE,
6762 EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
6765 Ybomb_w, FALSE, FALSE,
6766 EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
6769 Ybomb_wB, FALSE, TRUE,
6770 EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
6773 Ybomb_blank, FALSE, FALSE,
6774 EL_BOMB, ACTION_ACTIVATING, -1
6782 Xnut_pause, FALSE, FALSE,
6786 Xnut_fall, FALSE, FALSE,
6790 Ynut_s, FALSE, FALSE,
6791 EL_NUT, ACTION_FALLING, -1
6794 Ynut_sB, FALSE, TRUE,
6795 EL_NUT, ACTION_FALLING, -1
6798 Ynut_e, FALSE, FALSE,
6799 EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
6802 Ynut_eB, FALSE, TRUE,
6803 EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
6806 Ynut_w, FALSE, FALSE,
6807 EL_NUT, ACTION_MOVING, MV_BIT_LEFT
6810 Ynut_wB, FALSE, TRUE,
6811 EL_NUT, ACTION_MOVING, MV_BIT_LEFT
6814 Ynut_stone, FALSE, FALSE,
6815 EL_NUT, ACTION_BREAKING, -1
6819 Xspring, TRUE, FALSE,
6823 Xspring_pause, FALSE, FALSE,
6827 Xspring_e, TRUE, FALSE,
6828 EL_SPRING_RIGHT, -1, -1
6831 Xspring_w, TRUE, FALSE,
6832 EL_SPRING_LEFT, -1, -1
6835 Xspring_fall, FALSE, FALSE,
6839 Yspring_s, FALSE, FALSE,
6840 EL_SPRING, ACTION_FALLING, -1
6843 Yspring_sB, FALSE, TRUE,
6844 EL_SPRING, ACTION_FALLING, -1
6847 Yspring_e, FALSE, FALSE,
6848 EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
6851 Yspring_eB, FALSE, TRUE,
6852 EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
6855 Yspring_w, FALSE, FALSE,
6856 EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
6859 Yspring_wB, FALSE, TRUE,
6860 EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
6863 Yspring_alien_e, FALSE, FALSE,
6864 EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
6867 Yspring_alien_eB, FALSE, TRUE,
6868 EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
6871 Yspring_alien_w, FALSE, FALSE,
6872 EL_SPRING, ACTION_EATING, MV_BIT_LEFT
6875 Yspring_alien_wB, FALSE, TRUE,
6876 EL_SPRING, ACTION_EATING, MV_BIT_LEFT
6880 Xpush_emerald_e, FALSE, FALSE,
6881 EL_EMERALD, -1, MV_BIT_RIGHT
6884 Xpush_emerald_w, FALSE, FALSE,
6885 EL_EMERALD, -1, MV_BIT_LEFT
6888 Xpush_diamond_e, FALSE, FALSE,
6889 EL_DIAMOND, -1, MV_BIT_RIGHT
6892 Xpush_diamond_w, FALSE, FALSE,
6893 EL_DIAMOND, -1, MV_BIT_LEFT
6896 Xpush_stone_e, FALSE, FALSE,
6897 EL_ROCK, -1, MV_BIT_RIGHT
6900 Xpush_stone_w, FALSE, FALSE,
6901 EL_ROCK, -1, MV_BIT_LEFT
6904 Xpush_bomb_e, FALSE, FALSE,
6905 EL_BOMB, -1, MV_BIT_RIGHT
6908 Xpush_bomb_w, FALSE, FALSE,
6909 EL_BOMB, -1, MV_BIT_LEFT
6912 Xpush_nut_e, FALSE, FALSE,
6913 EL_NUT, -1, MV_BIT_RIGHT
6916 Xpush_nut_w, FALSE, FALSE,
6917 EL_NUT, -1, MV_BIT_LEFT
6920 Xpush_spring_e, FALSE, FALSE,
6921 EL_SPRING_RIGHT, -1, MV_BIT_RIGHT
6924 Xpush_spring_w, FALSE, FALSE,
6925 EL_SPRING_LEFT, -1, MV_BIT_LEFT
6929 Xdynamite, TRUE, FALSE,
6930 EL_EM_DYNAMITE, -1, -1
6933 Ydynamite_blank, FALSE, FALSE,
6934 EL_EM_DYNAMITE, ACTION_COLLECTING, -1
6937 Xdynamite_1, TRUE, FALSE,
6938 EL_EM_DYNAMITE_ACTIVE, -1, -1
6941 Xdynamite_2, FALSE, FALSE,
6942 EL_EM_DYNAMITE_ACTIVE, -1, -1
6945 Xdynamite_3, FALSE, FALSE,
6946 EL_EM_DYNAMITE_ACTIVE, -1, -1
6949 Xdynamite_4, FALSE, FALSE,
6950 EL_EM_DYNAMITE_ACTIVE, -1, -1
6954 Xkey_1, TRUE, FALSE,
6958 Xkey_2, TRUE, FALSE,
6962 Xkey_3, TRUE, FALSE,
6966 Xkey_4, TRUE, FALSE,
6970 Xkey_5, TRUE, FALSE,
6971 EL_EMC_KEY_5, -1, -1
6974 Xkey_6, TRUE, FALSE,
6975 EL_EMC_KEY_6, -1, -1
6978 Xkey_7, TRUE, FALSE,
6979 EL_EMC_KEY_7, -1, -1
6982 Xkey_8, TRUE, FALSE,
6983 EL_EMC_KEY_8, -1, -1
6987 Xdoor_1, TRUE, FALSE,
6988 EL_EM_GATE_1, -1, -1
6991 Xdoor_2, TRUE, FALSE,
6992 EL_EM_GATE_2, -1, -1
6995 Xdoor_3, TRUE, FALSE,
6996 EL_EM_GATE_3, -1, -1
6999 Xdoor_4, TRUE, FALSE,
7000 EL_EM_GATE_4, -1, -1
7003 Xdoor_5, TRUE, FALSE,
7004 EL_EMC_GATE_5, -1, -1
7007 Xdoor_6, TRUE, FALSE,
7008 EL_EMC_GATE_6, -1, -1
7011 Xdoor_7, TRUE, FALSE,
7012 EL_EMC_GATE_7, -1, -1
7015 Xdoor_8, TRUE, FALSE,
7016 EL_EMC_GATE_8, -1, -1
7020 Xfake_door_1, TRUE, FALSE,
7021 EL_EM_GATE_1_GRAY, -1, -1
7024 Xfake_door_2, TRUE, FALSE,
7025 EL_EM_GATE_2_GRAY, -1, -1
7028 Xfake_door_3, TRUE, FALSE,
7029 EL_EM_GATE_3_GRAY, -1, -1
7032 Xfake_door_4, TRUE, FALSE,
7033 EL_EM_GATE_4_GRAY, -1, -1
7036 Xfake_door_5, TRUE, FALSE,
7037 EL_EMC_GATE_5_GRAY, -1, -1
7040 Xfake_door_6, TRUE, FALSE,
7041 EL_EMC_GATE_6_GRAY, -1, -1
7044 Xfake_door_7, TRUE, FALSE,
7045 EL_EMC_GATE_7_GRAY, -1, -1
7048 Xfake_door_8, TRUE, FALSE,
7049 EL_EMC_GATE_8_GRAY, -1, -1
7053 Xballoon, TRUE, FALSE,
7057 Yballoon_n, FALSE, FALSE,
7058 EL_BALLOON, ACTION_MOVING, MV_BIT_UP
7061 Yballoon_nB, FALSE, TRUE,
7062 EL_BALLOON, ACTION_MOVING, MV_BIT_UP
7065 Yballoon_e, FALSE, FALSE,
7066 EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
7069 Yballoon_eB, FALSE, TRUE,
7070 EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
7073 Yballoon_s, FALSE, FALSE,
7074 EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
7077 Yballoon_sB, FALSE, TRUE,
7078 EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
7081 Yballoon_w, FALSE, FALSE,
7082 EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
7085 Yballoon_wB, FALSE, TRUE,
7086 EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
7090 Xball_1, TRUE, FALSE,
7091 EL_EMC_MAGIC_BALL, -1, -1
7094 Yball_1, FALSE, FALSE,
7095 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
7098 Xball_2, FALSE, FALSE,
7099 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
7102 Yball_2, FALSE, FALSE,
7103 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
7106 Yball_blank, FALSE, FALSE,
7107 EL_EMC_MAGIC_BALL, ACTION_DROPPING, -1
7111 Xamoeba_1, TRUE, FALSE,
7112 EL_AMOEBA_DRY, ACTION_OTHER, -1
7115 Xamoeba_2, FALSE, FALSE,
7116 EL_AMOEBA_DRY, ACTION_OTHER, -1
7119 Xamoeba_3, FALSE, FALSE,
7120 EL_AMOEBA_DRY, ACTION_OTHER, -1
7123 Xamoeba_4, FALSE, FALSE,
7124 EL_AMOEBA_DRY, ACTION_OTHER, -1
7127 Xamoeba_5, TRUE, FALSE,
7128 EL_AMOEBA_WET, ACTION_OTHER, -1
7131 Xamoeba_6, FALSE, FALSE,
7132 EL_AMOEBA_WET, ACTION_OTHER, -1
7135 Xamoeba_7, FALSE, FALSE,
7136 EL_AMOEBA_WET, ACTION_OTHER, -1
7139 Xamoeba_8, FALSE, FALSE,
7140 EL_AMOEBA_WET, ACTION_OTHER, -1
7145 EL_AMOEBA_DROP, ACTION_GROWING, -1
7148 Xdrip_fall, FALSE, FALSE,
7149 EL_AMOEBA_DROP, -1, -1
7152 Xdrip_stretch, FALSE, FALSE,
7153 EL_AMOEBA_DROP, ACTION_FALLING, -1
7156 Xdrip_stretchB, FALSE, TRUE,
7157 EL_AMOEBA_DROP, ACTION_FALLING, -1
7160 Ydrip_1_s, FALSE, FALSE,
7161 EL_AMOEBA_DROP, ACTION_FALLING, -1
7164 Ydrip_1_sB, FALSE, TRUE,
7165 EL_AMOEBA_DROP, ACTION_FALLING, -1
7168 Ydrip_2_s, FALSE, FALSE,
7169 EL_AMOEBA_DROP, ACTION_FALLING, -1
7172 Ydrip_2_sB, FALSE, TRUE,
7173 EL_AMOEBA_DROP, ACTION_FALLING, -1
7177 Xwonderwall, TRUE, FALSE,
7178 EL_MAGIC_WALL, -1, -1
7181 Ywonderwall, FALSE, FALSE,
7182 EL_MAGIC_WALL, ACTION_ACTIVE, -1
7186 Xwheel, TRUE, FALSE,
7187 EL_ROBOT_WHEEL, -1, -1
7190 Ywheel, FALSE, FALSE,
7191 EL_ROBOT_WHEEL, ACTION_ACTIVE, -1
7195 Xswitch, TRUE, FALSE,
7196 EL_EMC_MAGIC_BALL_SWITCH, -1, -1
7199 Yswitch, FALSE, FALSE,
7200 EL_EMC_MAGIC_BALL_SWITCH, ACTION_ACTIVE, -1
7204 Xbumper, TRUE, FALSE,
7205 EL_EMC_SPRING_BUMPER, -1, -1
7208 Ybumper, FALSE, FALSE,
7209 EL_EMC_SPRING_BUMPER, ACTION_ACTIVE, -1
7213 Xacid_nw, TRUE, FALSE,
7214 EL_ACID_POOL_TOPLEFT, -1, -1
7217 Xacid_ne, TRUE, FALSE,
7218 EL_ACID_POOL_TOPRIGHT, -1, -1
7221 Xacid_sw, TRUE, FALSE,
7222 EL_ACID_POOL_BOTTOMLEFT, -1, -1
7225 Xacid_s, TRUE, FALSE,
7226 EL_ACID_POOL_BOTTOM, -1, -1
7229 Xacid_se, TRUE, FALSE,
7230 EL_ACID_POOL_BOTTOMRIGHT, -1, -1
7234 Xfake_blank, TRUE, FALSE,
7235 EL_INVISIBLE_WALL, -1, -1
7238 Yfake_blank, FALSE, FALSE,
7239 EL_INVISIBLE_WALL, ACTION_ACTIVE, -1
7243 Xfake_grass, TRUE, FALSE,
7244 EL_EMC_FAKE_GRASS, -1, -1
7247 Yfake_grass, FALSE, FALSE,
7248 EL_EMC_FAKE_GRASS, ACTION_ACTIVE, -1
7252 Xfake_amoeba, TRUE, FALSE,
7253 EL_EMC_DRIPPER, -1, -1
7256 Yfake_amoeba, FALSE, FALSE,
7257 EL_EMC_DRIPPER, ACTION_ACTIVE, -1
7261 Xlenses, TRUE, FALSE,
7262 EL_EMC_LENSES, -1, -1
7266 Xmagnify, TRUE, FALSE,
7267 EL_EMC_MAGNIFIER, -1, -1
7272 EL_QUICKSAND_EMPTY, -1, -1
7275 Xsand_stone, TRUE, FALSE,
7276 EL_QUICKSAND_FULL, -1, -1
7279 Xsand_stonein_1, FALSE, TRUE,
7280 EL_ROCK, ACTION_FILLING, -1
7283 Xsand_stonein_2, FALSE, TRUE,
7284 EL_ROCK, ACTION_FILLING, -1
7287 Xsand_stonein_3, FALSE, TRUE,
7288 EL_ROCK, ACTION_FILLING, -1
7291 Xsand_stonein_4, FALSE, TRUE,
7292 EL_ROCK, ACTION_FILLING, -1
7295 Xsand_sandstone_1, FALSE, FALSE,
7296 EL_QUICKSAND_FILLING, -1, -1
7299 Xsand_sandstone_2, FALSE, FALSE,
7300 EL_QUICKSAND_FILLING, -1, -1
7303 Xsand_sandstone_3, FALSE, FALSE,
7304 EL_QUICKSAND_FILLING, -1, -1
7307 Xsand_sandstone_4, FALSE, FALSE,
7308 EL_QUICKSAND_FILLING, -1, -1
7311 Xsand_stonesand_1, FALSE, FALSE,
7312 EL_QUICKSAND_EMPTYING, -1, -1
7315 Xsand_stonesand_2, FALSE, FALSE,
7316 EL_QUICKSAND_EMPTYING, -1, -1
7319 Xsand_stonesand_3, FALSE, FALSE,
7320 EL_QUICKSAND_EMPTYING, -1, -1
7323 Xsand_stonesand_4, FALSE, FALSE,
7324 EL_QUICKSAND_EMPTYING, -1, -1
7327 Xsand_stoneout_1, FALSE, FALSE,
7328 EL_ROCK, ACTION_EMPTYING, -1
7331 Xsand_stoneout_2, FALSE, FALSE,
7332 EL_ROCK, ACTION_EMPTYING, -1
7335 Xsand_stonesand_quickout_1, FALSE, FALSE,
7336 EL_QUICKSAND_EMPTYING, -1, -1
7339 Xsand_stonesand_quickout_2, FALSE, FALSE,
7340 EL_QUICKSAND_EMPTYING, -1, -1
7344 Xslide_ns, TRUE, FALSE,
7345 EL_EXPANDABLE_WALL_VERTICAL, -1, -1
7348 Yslide_ns_blank, FALSE, FALSE,
7349 EL_EXPANDABLE_WALL_VERTICAL, ACTION_GROWING, -1
7352 Xslide_ew, TRUE, FALSE,
7353 EL_EXPANDABLE_WALL_HORIZONTAL, -1, -1
7356 Yslide_ew_blank, FALSE, FALSE,
7357 EL_EXPANDABLE_WALL_HORIZONTAL, ACTION_GROWING, -1
7361 Xwind_n, TRUE, FALSE,
7362 EL_BALLOON_SWITCH_UP, -1, -1
7365 Xwind_e, TRUE, FALSE,
7366 EL_BALLOON_SWITCH_RIGHT, -1, -1
7369 Xwind_s, TRUE, FALSE,
7370 EL_BALLOON_SWITCH_DOWN, -1, -1
7373 Xwind_w, TRUE, FALSE,
7374 EL_BALLOON_SWITCH_LEFT, -1, -1
7377 Xwind_any, TRUE, FALSE,
7378 EL_BALLOON_SWITCH_ANY, -1, -1
7381 Xwind_stop, TRUE, FALSE,
7382 EL_BALLOON_SWITCH_NONE, -1, -1
7387 EL_EM_EXIT_CLOSED, -1, -1
7390 Xexit_1, TRUE, FALSE,
7391 EL_EM_EXIT_OPEN, -1, -1
7394 Xexit_2, FALSE, FALSE,
7395 EL_EM_EXIT_OPEN, -1, -1
7398 Xexit_3, FALSE, FALSE,
7399 EL_EM_EXIT_OPEN, -1, -1
7403 Xpause, FALSE, FALSE,
7408 Xwall_1, TRUE, FALSE,
7412 Xwall_2, TRUE, FALSE,
7413 EL_EMC_WALL_14, -1, -1
7416 Xwall_3, TRUE, FALSE,
7417 EL_EMC_WALL_15, -1, -1
7420 Xwall_4, TRUE, FALSE,
7421 EL_EMC_WALL_16, -1, -1
7425 Xroundwall_1, TRUE, FALSE,
7426 EL_WALL_SLIPPERY, -1, -1
7429 Xroundwall_2, TRUE, FALSE,
7430 EL_EMC_WALL_SLIPPERY_2, -1, -1
7433 Xroundwall_3, TRUE, FALSE,
7434 EL_EMC_WALL_SLIPPERY_3, -1, -1
7437 Xroundwall_4, TRUE, FALSE,
7438 EL_EMC_WALL_SLIPPERY_4, -1, -1
7442 Xsteel_1, TRUE, FALSE,
7443 EL_STEELWALL, -1, -1
7446 Xsteel_2, TRUE, FALSE,
7447 EL_EMC_STEELWALL_2, -1, -1
7450 Xsteel_3, TRUE, FALSE,
7451 EL_EMC_STEELWALL_3, -1, -1
7454 Xsteel_4, TRUE, FALSE,
7455 EL_EMC_STEELWALL_4, -1, -1
7459 Xdecor_1, TRUE, FALSE,
7460 EL_EMC_WALL_8, -1, -1
7463 Xdecor_2, TRUE, FALSE,
7464 EL_EMC_WALL_6, -1, -1
7467 Xdecor_3, TRUE, FALSE,
7468 EL_EMC_WALL_4, -1, -1
7471 Xdecor_4, TRUE, FALSE,
7472 EL_EMC_WALL_7, -1, -1
7475 Xdecor_5, TRUE, FALSE,
7476 EL_EMC_WALL_5, -1, -1
7479 Xdecor_6, TRUE, FALSE,
7480 EL_EMC_WALL_9, -1, -1
7483 Xdecor_7, TRUE, FALSE,
7484 EL_EMC_WALL_10, -1, -1
7487 Xdecor_8, TRUE, FALSE,
7488 EL_EMC_WALL_1, -1, -1
7491 Xdecor_9, TRUE, FALSE,
7492 EL_EMC_WALL_2, -1, -1
7495 Xdecor_10, TRUE, FALSE,
7496 EL_EMC_WALL_3, -1, -1
7499 Xdecor_11, TRUE, FALSE,
7500 EL_EMC_WALL_11, -1, -1
7503 Xdecor_12, TRUE, FALSE,
7504 EL_EMC_WALL_12, -1, -1
7508 Xalpha_0, TRUE, FALSE,
7509 EL_CHAR('0'), -1, -1
7512 Xalpha_1, TRUE, FALSE,
7513 EL_CHAR('1'), -1, -1
7516 Xalpha_2, TRUE, FALSE,
7517 EL_CHAR('2'), -1, -1
7520 Xalpha_3, TRUE, FALSE,
7521 EL_CHAR('3'), -1, -1
7524 Xalpha_4, TRUE, FALSE,
7525 EL_CHAR('4'), -1, -1
7528 Xalpha_5, TRUE, FALSE,
7529 EL_CHAR('5'), -1, -1
7532 Xalpha_6, TRUE, FALSE,
7533 EL_CHAR('6'), -1, -1
7536 Xalpha_7, TRUE, FALSE,
7537 EL_CHAR('7'), -1, -1
7540 Xalpha_8, TRUE, FALSE,
7541 EL_CHAR('8'), -1, -1
7544 Xalpha_9, TRUE, FALSE,
7545 EL_CHAR('9'), -1, -1
7548 Xalpha_excla, TRUE, FALSE,
7549 EL_CHAR('!'), -1, -1
7552 Xalpha_apost, TRUE, FALSE,
7553 EL_CHAR('\''), -1, -1
7556 Xalpha_comma, TRUE, FALSE,
7557 EL_CHAR(','), -1, -1
7560 Xalpha_minus, TRUE, FALSE,
7561 EL_CHAR('-'), -1, -1
7564 Xalpha_perio, TRUE, FALSE,
7565 EL_CHAR('.'), -1, -1
7568 Xalpha_colon, TRUE, FALSE,
7569 EL_CHAR(':'), -1, -1
7572 Xalpha_quest, TRUE, FALSE,
7573 EL_CHAR('?'), -1, -1
7576 Xalpha_a, TRUE, FALSE,
7577 EL_CHAR('A'), -1, -1
7580 Xalpha_b, TRUE, FALSE,
7581 EL_CHAR('B'), -1, -1
7584 Xalpha_c, TRUE, FALSE,
7585 EL_CHAR('C'), -1, -1
7588 Xalpha_d, TRUE, FALSE,
7589 EL_CHAR('D'), -1, -1
7592 Xalpha_e, TRUE, FALSE,
7593 EL_CHAR('E'), -1, -1
7596 Xalpha_f, TRUE, FALSE,
7597 EL_CHAR('F'), -1, -1
7600 Xalpha_g, TRUE, FALSE,
7601 EL_CHAR('G'), -1, -1
7604 Xalpha_h, TRUE, FALSE,
7605 EL_CHAR('H'), -1, -1
7608 Xalpha_i, TRUE, FALSE,
7609 EL_CHAR('I'), -1, -1
7612 Xalpha_j, TRUE, FALSE,
7613 EL_CHAR('J'), -1, -1
7616 Xalpha_k, TRUE, FALSE,
7617 EL_CHAR('K'), -1, -1
7620 Xalpha_l, TRUE, FALSE,
7621 EL_CHAR('L'), -1, -1
7624 Xalpha_m, TRUE, FALSE,
7625 EL_CHAR('M'), -1, -1
7628 Xalpha_n, TRUE, FALSE,
7629 EL_CHAR('N'), -1, -1
7632 Xalpha_o, TRUE, FALSE,
7633 EL_CHAR('O'), -1, -1
7636 Xalpha_p, TRUE, FALSE,
7637 EL_CHAR('P'), -1, -1
7640 Xalpha_q, TRUE, FALSE,
7641 EL_CHAR('Q'), -1, -1
7644 Xalpha_r, TRUE, FALSE,
7645 EL_CHAR('R'), -1, -1
7648 Xalpha_s, TRUE, FALSE,
7649 EL_CHAR('S'), -1, -1
7652 Xalpha_t, TRUE, FALSE,
7653 EL_CHAR('T'), -1, -1
7656 Xalpha_u, TRUE, FALSE,
7657 EL_CHAR('U'), -1, -1
7660 Xalpha_v, TRUE, FALSE,
7661 EL_CHAR('V'), -1, -1
7664 Xalpha_w, TRUE, FALSE,
7665 EL_CHAR('W'), -1, -1
7668 Xalpha_x, TRUE, FALSE,
7669 EL_CHAR('X'), -1, -1
7672 Xalpha_y, TRUE, FALSE,
7673 EL_CHAR('Y'), -1, -1
7676 Xalpha_z, TRUE, FALSE,
7677 EL_CHAR('Z'), -1, -1
7680 Xalpha_arrow_e, TRUE, FALSE,
7681 EL_CHAR('>'), -1, -1
7684 Xalpha_arrow_w, TRUE, FALSE,
7685 EL_CHAR('<'), -1, -1
7688 Xalpha_copyr, TRUE, FALSE,
7689 EL_CHAR(CHAR_BYTE_COPYRIGHT), -1, -1
7693 Ykey_1_blank, FALSE, FALSE,
7694 EL_EM_KEY_1, ACTION_COLLECTING, -1
7697 Ykey_2_blank, FALSE, FALSE,
7698 EL_EM_KEY_2, ACTION_COLLECTING, -1
7701 Ykey_3_blank, FALSE, FALSE,
7702 EL_EM_KEY_3, ACTION_COLLECTING, -1
7705 Ykey_4_blank, FALSE, FALSE,
7706 EL_EM_KEY_4, ACTION_COLLECTING, -1
7709 Ykey_5_blank, FALSE, FALSE,
7710 EL_EMC_KEY_5, ACTION_COLLECTING, -1
7713 Ykey_6_blank, FALSE, FALSE,
7714 EL_EMC_KEY_6, ACTION_COLLECTING, -1
7717 Ykey_7_blank, FALSE, FALSE,
7718 EL_EMC_KEY_7, ACTION_COLLECTING, -1
7721 Ykey_8_blank, FALSE, FALSE,
7722 EL_EMC_KEY_8, ACTION_COLLECTING, -1
7725 Ylenses_blank, FALSE, FALSE,
7726 EL_EMC_LENSES, ACTION_COLLECTING, -1
7729 Ymagnify_blank, FALSE, FALSE,
7730 EL_EMC_MAGNIFIER, ACTION_COLLECTING, -1
7733 Ygrass_blank, FALSE, FALSE,
7734 EL_EMC_GRASS, ACTION_SNAPPING, -1
7737 Ydirt_blank, FALSE, FALSE,
7738 EL_SAND, ACTION_SNAPPING, -1
7747 static struct Mapping_EM_to_RND_player
7756 em_player_mapping_list[MAX_PLAYERS * PLY_MAX + 1] =
7760 EL_PLAYER_1, ACTION_MOVING, MV_BIT_UP,
7764 EL_PLAYER_1, ACTION_MOVING, MV_BIT_RIGHT,
7768 EL_PLAYER_1, ACTION_MOVING, MV_BIT_DOWN,
7772 EL_PLAYER_1, ACTION_MOVING, MV_BIT_LEFT,
7776 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_UP,
7780 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_RIGHT,
7784 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_DOWN,
7788 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_LEFT,
7792 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_UP,
7796 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_RIGHT,
7800 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_DOWN,
7804 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_LEFT,
7808 EL_PLAYER_2, ACTION_MOVING, MV_BIT_UP,
7812 EL_PLAYER_2, ACTION_MOVING, MV_BIT_RIGHT,
7816 EL_PLAYER_2, ACTION_MOVING, MV_BIT_DOWN,
7820 EL_PLAYER_2, ACTION_MOVING, MV_BIT_LEFT,
7824 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_UP,
7828 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_RIGHT,
7832 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_DOWN,
7836 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_LEFT,
7840 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_UP,
7844 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_RIGHT,
7848 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_DOWN,
7852 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_LEFT,
7856 EL_PLAYER_1, ACTION_DEFAULT, -1,
7860 EL_PLAYER_2, ACTION_DEFAULT, -1,
7864 EL_PLAYER_3, ACTION_MOVING, MV_BIT_UP,
7868 EL_PLAYER_3, ACTION_MOVING, MV_BIT_RIGHT,
7872 EL_PLAYER_3, ACTION_MOVING, MV_BIT_DOWN,
7876 EL_PLAYER_3, ACTION_MOVING, MV_BIT_LEFT,
7880 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_UP,
7884 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_RIGHT,
7888 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_DOWN,
7892 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_LEFT,
7896 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_UP,
7900 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_RIGHT,
7904 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_DOWN,
7908 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_LEFT,
7912 EL_PLAYER_4, ACTION_MOVING, MV_BIT_UP,
7916 EL_PLAYER_4, ACTION_MOVING, MV_BIT_RIGHT,
7920 EL_PLAYER_4, ACTION_MOVING, MV_BIT_DOWN,
7924 EL_PLAYER_4, ACTION_MOVING, MV_BIT_LEFT,
7928 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_UP,
7932 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_RIGHT,
7936 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_DOWN,
7940 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_LEFT,
7944 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_UP,
7948 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_RIGHT,
7952 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_DOWN,
7956 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_LEFT,
7960 EL_PLAYER_3, ACTION_DEFAULT, -1,
7964 EL_PLAYER_4, ACTION_DEFAULT, -1,
7973 int map_element_RND_to_EM_cave(int element_rnd)
7975 static unsigned short mapping_RND_to_EM[NUM_FILE_ELEMENTS];
7976 static boolean mapping_initialized = FALSE;
7978 if (!mapping_initialized)
7982 // return "Xalpha_quest" for all undefined elements in mapping array
7983 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
7984 mapping_RND_to_EM[i] = Xalpha_quest;
7986 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
7987 if (em_object_mapping_list[i].is_rnd_to_em_mapping)
7988 mapping_RND_to_EM[em_object_mapping_list[i].element_rnd] =
7989 em_object_mapping_list[i].element_em;
7991 mapping_initialized = TRUE;
7994 if (element_rnd < 0 || element_rnd >= NUM_FILE_ELEMENTS)
7996 Warn("invalid RND level element %d", element_rnd);
8001 return map_em_element_X_to_C(mapping_RND_to_EM[element_rnd]);
8004 int map_element_EM_to_RND_cave(int element_em_cave)
8006 static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
8007 static boolean mapping_initialized = FALSE;
8009 if (!mapping_initialized)
8013 // return "EL_UNKNOWN" for all undefined elements in mapping array
8014 for (i = 0; i < GAME_TILE_MAX; i++)
8015 mapping_EM_to_RND[i] = EL_UNKNOWN;
8017 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8018 mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
8019 em_object_mapping_list[i].element_rnd;
8021 mapping_initialized = TRUE;
8024 if (element_em_cave < 0 || element_em_cave >= CAVE_TILE_MAX)
8026 Warn("invalid EM cave element %d", element_em_cave);
8031 return mapping_EM_to_RND[map_em_element_C_to_X(element_em_cave)];
8034 int map_element_EM_to_RND_game(int element_em_game)
8036 static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
8037 static boolean mapping_initialized = FALSE;
8039 if (!mapping_initialized)
8043 // return "EL_UNKNOWN" for all undefined elements in mapping array
8044 for (i = 0; i < GAME_TILE_MAX; i++)
8045 mapping_EM_to_RND[i] = EL_UNKNOWN;
8047 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8048 mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
8049 em_object_mapping_list[i].element_rnd;
8051 mapping_initialized = TRUE;
8054 if (element_em_game < 0 || element_em_game >= GAME_TILE_MAX)
8056 Warn("invalid EM game element %d", element_em_game);
8061 return mapping_EM_to_RND[element_em_game];
8064 void map_android_clone_elements_RND_to_EM(struct LevelInfo *level)
8066 struct LevelInfo_EM *level_em = level->native_em_level;
8067 struct CAVE *cav = level_em->cav;
8070 for (i = 0; i < GAME_TILE_MAX; i++)
8071 cav->android_array[i] = Cblank;
8073 for (i = 0; i < level->num_android_clone_elements; i++)
8075 int element_rnd = level->android_clone_element[i];
8076 int element_em_cave = map_element_RND_to_EM_cave(element_rnd);
8078 for (j = 0; em_object_mapping_list[j].element_em != -1; j++)
8079 if (em_object_mapping_list[j].element_rnd == element_rnd)
8080 cav->android_array[em_object_mapping_list[j].element_em] =
8085 void map_android_clone_elements_EM_to_RND(struct LevelInfo *level)
8087 struct LevelInfo_EM *level_em = level->native_em_level;
8088 struct CAVE *cav = level_em->cav;
8091 level->num_android_clone_elements = 0;
8093 for (i = 0; i < GAME_TILE_MAX; i++)
8095 int element_em_cave = cav->android_array[i];
8097 boolean element_found = FALSE;
8099 if (element_em_cave == Cblank)
8102 element_rnd = map_element_EM_to_RND_cave(element_em_cave);
8104 for (j = 0; j < level->num_android_clone_elements; j++)
8105 if (level->android_clone_element[j] == element_rnd)
8106 element_found = TRUE;
8110 level->android_clone_element[level->num_android_clone_elements++] =
8113 if (level->num_android_clone_elements == MAX_ANDROID_ELEMENTS)
8118 if (level->num_android_clone_elements == 0)
8120 level->num_android_clone_elements = 1;
8121 level->android_clone_element[0] = EL_EMPTY;
8125 int map_direction_RND_to_EM(int direction)
8127 return (direction == MV_UP ? 0 :
8128 direction == MV_RIGHT ? 1 :
8129 direction == MV_DOWN ? 2 :
8130 direction == MV_LEFT ? 3 :
8134 int map_direction_EM_to_RND(int direction)
8136 return (direction == 0 ? MV_UP :
8137 direction == 1 ? MV_RIGHT :
8138 direction == 2 ? MV_DOWN :
8139 direction == 3 ? MV_LEFT :
8143 int map_element_RND_to_SP(int element_rnd)
8145 int element_sp = 0x20; // map unknown elements to yellow "hardware"
8147 if (element_rnd >= EL_SP_START &&
8148 element_rnd <= EL_SP_END)
8149 element_sp = element_rnd - EL_SP_START;
8150 else if (element_rnd == EL_EMPTY_SPACE)
8152 else if (element_rnd == EL_INVISIBLE_WALL)
8158 int map_element_SP_to_RND(int element_sp)
8160 int element_rnd = EL_UNKNOWN;
8162 if (element_sp >= 0x00 &&
8164 element_rnd = EL_SP_START + element_sp;
8165 else if (element_sp == 0x28)
8166 element_rnd = EL_INVISIBLE_WALL;
8171 int map_action_SP_to_RND(int action_sp)
8175 case actActive: return ACTION_ACTIVE;
8176 case actImpact: return ACTION_IMPACT;
8177 case actExploding: return ACTION_EXPLODING;
8178 case actDigging: return ACTION_DIGGING;
8179 case actSnapping: return ACTION_SNAPPING;
8180 case actCollecting: return ACTION_COLLECTING;
8181 case actPassing: return ACTION_PASSING;
8182 case actPushing: return ACTION_PUSHING;
8183 case actDropping: return ACTION_DROPPING;
8185 default: return ACTION_DEFAULT;
8189 int map_element_RND_to_MM(int element_rnd)
8191 return (element_rnd >= EL_MM_START_1 &&
8192 element_rnd <= EL_MM_END_1 ?
8193 EL_MM_START_1_NATIVE + element_rnd - EL_MM_START_1 :
8195 element_rnd >= EL_MM_START_2 &&
8196 element_rnd <= EL_MM_END_2 ?
8197 EL_MM_START_2_NATIVE + element_rnd - EL_MM_START_2 :
8199 element_rnd >= EL_CHAR_START &&
8200 element_rnd <= EL_CHAR_END ?
8201 EL_MM_CHAR_START_NATIVE + element_rnd - EL_CHAR_START :
8203 element_rnd >= EL_MM_RUNTIME_START &&
8204 element_rnd <= EL_MM_RUNTIME_END ?
8205 EL_MM_RUNTIME_START_NATIVE + element_rnd - EL_MM_RUNTIME_START :
8207 EL_MM_EMPTY_NATIVE);
8210 int map_element_MM_to_RND(int element_mm)
8212 return (element_mm == EL_MM_EMPTY_NATIVE ||
8213 element_mm == EL_DF_EMPTY_NATIVE ?
8216 element_mm >= EL_MM_START_1_NATIVE &&
8217 element_mm <= EL_MM_END_1_NATIVE ?
8218 EL_MM_START_1 + element_mm - EL_MM_START_1_NATIVE :
8220 element_mm >= EL_MM_START_2_NATIVE &&
8221 element_mm <= EL_MM_END_2_NATIVE ?
8222 EL_MM_START_2 + element_mm - EL_MM_START_2_NATIVE :
8224 element_mm >= EL_MM_CHAR_START_NATIVE &&
8225 element_mm <= EL_MM_CHAR_END_NATIVE ?
8226 EL_CHAR_START + element_mm - EL_MM_CHAR_START_NATIVE :
8228 element_mm >= EL_MM_RUNTIME_START_NATIVE &&
8229 element_mm <= EL_MM_RUNTIME_END_NATIVE ?
8230 EL_MM_RUNTIME_START + element_mm - EL_MM_RUNTIME_START_NATIVE :
8235 int map_action_MM_to_RND(int action_mm)
8237 // all MM actions are defined to exactly match their RND counterparts
8241 int map_sound_MM_to_RND(int sound_mm)
8245 case SND_MM_GAME_LEVELTIME_CHARGING:
8246 return SND_GAME_LEVELTIME_CHARGING;
8248 case SND_MM_GAME_HEALTH_CHARGING:
8249 return SND_GAME_HEALTH_CHARGING;
8252 return SND_UNDEFINED;
8256 int map_mm_wall_element(int element)
8258 return (element >= EL_MM_STEEL_WALL_START &&
8259 element <= EL_MM_STEEL_WALL_END ?
8262 element >= EL_MM_WOODEN_WALL_START &&
8263 element <= EL_MM_WOODEN_WALL_END ?
8266 element >= EL_MM_ICE_WALL_START &&
8267 element <= EL_MM_ICE_WALL_END ?
8270 element >= EL_MM_AMOEBA_WALL_START &&
8271 element <= EL_MM_AMOEBA_WALL_END ?
8274 element >= EL_DF_STEEL_WALL_START &&
8275 element <= EL_DF_STEEL_WALL_END ?
8278 element >= EL_DF_WOODEN_WALL_START &&
8279 element <= EL_DF_WOODEN_WALL_END ?
8285 int map_mm_wall_element_editor(int element)
8289 case EL_MM_STEEL_WALL: return EL_MM_STEEL_WALL_START;
8290 case EL_MM_WOODEN_WALL: return EL_MM_WOODEN_WALL_START;
8291 case EL_MM_ICE_WALL: return EL_MM_ICE_WALL_START;
8292 case EL_MM_AMOEBA_WALL: return EL_MM_AMOEBA_WALL_START;
8293 case EL_DF_STEEL_WALL: return EL_DF_STEEL_WALL_START;
8294 case EL_DF_WOODEN_WALL: return EL_DF_WOODEN_WALL_START;
8296 default: return element;
8300 int get_next_element(int element)
8304 case EL_QUICKSAND_FILLING: return EL_QUICKSAND_FULL;
8305 case EL_QUICKSAND_EMPTYING: return EL_QUICKSAND_EMPTY;
8306 case EL_QUICKSAND_FAST_FILLING: return EL_QUICKSAND_FAST_FULL;
8307 case EL_QUICKSAND_FAST_EMPTYING: return EL_QUICKSAND_FAST_EMPTY;
8308 case EL_MAGIC_WALL_FILLING: return EL_MAGIC_WALL_FULL;
8309 case EL_MAGIC_WALL_EMPTYING: return EL_MAGIC_WALL_ACTIVE;
8310 case EL_BD_MAGIC_WALL_FILLING: return EL_BD_MAGIC_WALL_FULL;
8311 case EL_BD_MAGIC_WALL_EMPTYING: return EL_BD_MAGIC_WALL_ACTIVE;
8312 case EL_DC_MAGIC_WALL_FILLING: return EL_DC_MAGIC_WALL_FULL;
8313 case EL_DC_MAGIC_WALL_EMPTYING: return EL_DC_MAGIC_WALL_ACTIVE;
8314 case EL_AMOEBA_DROPPING: return EL_AMOEBA_WET;
8316 default: return element;
8320 int el2img_mm(int element_mm)
8322 return el2img(map_element_MM_to_RND(element_mm));
8325 int el_act2img_mm(int element_mm, int action)
8327 return el_act2img(map_element_MM_to_RND(element_mm), action);
8330 int el_act_dir2img(int element, int action, int direction)
8332 element = GFX_ELEMENT(element);
8333 direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
8335 // direction_graphic[][] == graphic[] for undefined direction graphics
8336 return element_info[element].direction_graphic[action][direction];
8339 static int el_act_dir2crm(int element, int action, int direction)
8341 element = GFX_ELEMENT(element);
8342 direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
8344 // direction_graphic[][] == graphic[] for undefined direction graphics
8345 return element_info[element].direction_crumbled[action][direction];
8348 int el_act2img(int element, int action)
8350 element = GFX_ELEMENT(element);
8352 return element_info[element].graphic[action];
8355 int el_act2crm(int element, int action)
8357 element = GFX_ELEMENT(element);
8359 return element_info[element].crumbled[action];
8362 int el_dir2img(int element, int direction)
8364 element = GFX_ELEMENT(element);
8366 return el_act_dir2img(element, ACTION_DEFAULT, direction);
8369 int el2baseimg(int element)
8371 return element_info[element].graphic[ACTION_DEFAULT];
8374 int el2img(int element)
8376 element = GFX_ELEMENT(element);
8378 return element_info[element].graphic[ACTION_DEFAULT];
8381 int el2edimg(int element)
8383 element = GFX_ELEMENT(element);
8385 return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
8388 int el2preimg(int element)
8390 element = GFX_ELEMENT(element);
8392 return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
8395 int el2panelimg(int element)
8397 element = GFX_ELEMENT(element);
8399 return element_info[element].special_graphic[GFX_SPECIAL_ARG_PANEL];
8402 int font2baseimg(int font_nr)
8404 return font_info[font_nr].special_graphic[GFX_SPECIAL_ARG_DEFAULT];
8407 int getBeltNrFromBeltElement(int element)
8409 return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
8410 element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
8411 element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
8414 int getBeltNrFromBeltActiveElement(int element)
8416 return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
8417 element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
8418 element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
8421 int getBeltNrFromBeltSwitchElement(int element)
8423 return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
8424 element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
8425 element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
8428 int getBeltDirNrFromBeltElement(int element)
8430 static int belt_base_element[4] =
8432 EL_CONVEYOR_BELT_1_LEFT,
8433 EL_CONVEYOR_BELT_2_LEFT,
8434 EL_CONVEYOR_BELT_3_LEFT,
8435 EL_CONVEYOR_BELT_4_LEFT
8438 int belt_nr = getBeltNrFromBeltElement(element);
8439 int belt_dir_nr = element - belt_base_element[belt_nr];
8441 return (belt_dir_nr % 3);
8444 int getBeltDirNrFromBeltSwitchElement(int element)
8446 static int belt_base_element[4] =
8448 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
8449 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
8450 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
8451 EL_CONVEYOR_BELT_4_SWITCH_LEFT
8454 int belt_nr = getBeltNrFromBeltSwitchElement(element);
8455 int belt_dir_nr = element - belt_base_element[belt_nr];
8457 return (belt_dir_nr % 3);
8460 int getBeltDirFromBeltElement(int element)
8462 static int belt_move_dir[3] =
8469 int belt_dir_nr = getBeltDirNrFromBeltElement(element);
8471 return belt_move_dir[belt_dir_nr];
8474 int getBeltDirFromBeltSwitchElement(int element)
8476 static int belt_move_dir[3] =
8483 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
8485 return belt_move_dir[belt_dir_nr];
8488 int getBeltElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
8490 static int belt_base_element[4] =
8492 EL_CONVEYOR_BELT_1_LEFT,
8493 EL_CONVEYOR_BELT_2_LEFT,
8494 EL_CONVEYOR_BELT_3_LEFT,
8495 EL_CONVEYOR_BELT_4_LEFT
8498 return belt_base_element[belt_nr] + belt_dir_nr;
8501 int getBeltElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
8503 int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
8505 return getBeltElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
8508 int getBeltSwitchElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
8510 static int belt_base_element[4] =
8512 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
8513 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
8514 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
8515 EL_CONVEYOR_BELT_4_SWITCH_LEFT
8518 return belt_base_element[belt_nr] + belt_dir_nr;
8521 int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
8523 int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
8525 return getBeltSwitchElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
8528 boolean swapTiles_EM(boolean is_pre_emc_cave)
8530 return is_pre_emc_cave && leveldir_current->use_emc_tiles;
8533 boolean getTeamMode_EM(void)
8535 return game.team_mode || network_playing;
8538 boolean isActivePlayer_EM(int player_nr)
8540 return stored_player[player_nr].active;
8543 unsigned int InitRND(int seed)
8545 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
8546 return InitEngineRandom_EM(seed);
8547 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
8548 return InitEngineRandom_SP(seed);
8549 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
8550 return InitEngineRandom_MM(seed);
8552 return InitEngineRandom_RND(seed);
8555 static struct Mapping_EM_to_RND_object object_mapping[GAME_TILE_MAX];
8556 static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][PLY_MAX];
8558 static int get_effective_element_EM(int tile, int frame_em)
8560 int element = object_mapping[tile].element_rnd;
8561 int action = object_mapping[tile].action;
8562 boolean is_backside = object_mapping[tile].is_backside;
8563 boolean action_removing = (action == ACTION_DIGGING ||
8564 action == ACTION_SNAPPING ||
8565 action == ACTION_COLLECTING);
8573 return (frame_em > 5 ? EL_EMPTY : element);
8579 else // frame_em == 7
8590 case Ydiamond_stone:
8594 case Xdrip_stretchB:
8610 case Ymagnify_blank:
8613 case Xsand_stonein_1:
8614 case Xsand_stonein_2:
8615 case Xsand_stonein_3:
8616 case Xsand_stonein_4:
8620 return (is_backside || action_removing ? EL_EMPTY : element);
8625 static boolean check_linear_animation_EM(int tile)
8629 case Xsand_stonesand_1:
8630 case Xsand_stonesand_quickout_1:
8631 case Xsand_sandstone_1:
8632 case Xsand_stonein_1:
8633 case Xsand_stoneout_1:
8661 static void set_crumbled_graphics_EM(struct GraphicInfo_EM *g_em,
8662 boolean has_crumbled_graphics,
8663 int crumbled, int sync_frame)
8665 // if element can be crumbled, but certain action graphics are just empty
8666 // space (like instantly snapping sand to empty space in 1 frame), do not
8667 // treat these empty space graphics as crumbled graphics in EMC engine
8668 if (crumbled == IMG_EMPTY_SPACE)
8669 has_crumbled_graphics = FALSE;
8671 if (has_crumbled_graphics)
8673 struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
8674 int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
8675 g_crumbled->anim_delay,
8676 g_crumbled->anim_mode,
8677 g_crumbled->anim_start_frame,
8680 getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
8681 &g_em->crumbled_src_x, &g_em->crumbled_src_y);
8683 g_em->crumbled_border_size = graphic_info[crumbled].border_size;
8684 g_em->crumbled_tile_size = graphic_info[crumbled].tile_size;
8686 g_em->has_crumbled_graphics = TRUE;
8690 g_em->crumbled_bitmap = NULL;
8691 g_em->crumbled_src_x = 0;
8692 g_em->crumbled_src_y = 0;
8693 g_em->crumbled_border_size = 0;
8694 g_em->crumbled_tile_size = 0;
8696 g_em->has_crumbled_graphics = FALSE;
8701 void ResetGfxAnimation_EM(int x, int y, int tile)
8707 void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
8708 int tile, int frame_em, int x, int y)
8710 int action = object_mapping[tile].action;
8711 int direction = object_mapping[tile].direction;
8712 int effective_element = get_effective_element_EM(tile, frame_em);
8713 int graphic = (direction == MV_NONE ?
8714 el_act2img(effective_element, action) :
8715 el_act_dir2img(effective_element, action, direction));
8716 struct GraphicInfo *g = &graphic_info[graphic];
8718 boolean action_removing = (action == ACTION_DIGGING ||
8719 action == ACTION_SNAPPING ||
8720 action == ACTION_COLLECTING);
8721 boolean action_moving = (action == ACTION_FALLING ||
8722 action == ACTION_MOVING ||
8723 action == ACTION_PUSHING ||
8724 action == ACTION_EATING ||
8725 action == ACTION_FILLING ||
8726 action == ACTION_EMPTYING);
8727 boolean action_falling = (action == ACTION_FALLING ||
8728 action == ACTION_FILLING ||
8729 action == ACTION_EMPTYING);
8731 // special case: graphic uses "2nd movement tile" and has defined
8732 // 7 frames for movement animation (or less) => use default graphic
8733 // for last (8th) frame which ends the movement animation
8734 if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
8736 action = ACTION_DEFAULT; // (keep action_* unchanged for now)
8737 graphic = (direction == MV_NONE ?
8738 el_act2img(effective_element, action) :
8739 el_act_dir2img(effective_element, action, direction));
8741 g = &graphic_info[graphic];
8744 if ((action_removing || check_linear_animation_EM(tile)) && frame_em == 0)
8748 else if (action_moving)
8750 boolean is_backside = object_mapping[tile].is_backside;
8754 int direction = object_mapping[tile].direction;
8755 int move_dir = (action_falling ? MV_DOWN : direction);
8760 // !!! TEST !!! NEW !!! DOES NOT WORK RIGHT YET !!!
8761 if (g->double_movement && frame_em == 0)
8765 if (move_dir == MV_LEFT)
8766 GfxFrame[x - 1][y] = GfxFrame[x][y];
8767 else if (move_dir == MV_RIGHT)
8768 GfxFrame[x + 1][y] = GfxFrame[x][y];
8769 else if (move_dir == MV_UP)
8770 GfxFrame[x][y - 1] = GfxFrame[x][y];
8771 else if (move_dir == MV_DOWN)
8772 GfxFrame[x][y + 1] = GfxFrame[x][y];
8779 // special case: animation for Xsand_stonesand_quickout_1/2 twice as fast
8780 if (tile == Xsand_stonesand_quickout_1 ||
8781 tile == Xsand_stonesand_quickout_2)
8785 if (graphic_info[graphic].anim_global_sync)
8786 sync_frame = FrameCounter;
8787 else if (graphic_info[graphic].anim_global_anim_sync)
8788 sync_frame = getGlobalAnimSyncFrame();
8789 else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
8790 sync_frame = GfxFrame[x][y];
8792 sync_frame = 0; // playfield border (pseudo steel)
8794 SetRandomAnimationValue(x, y);
8796 int frame = getAnimationFrame(g->anim_frames,
8799 g->anim_start_frame,
8802 g_em->unique_identifier =
8803 (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
8806 void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
8807 int tile, int frame_em, int x, int y)
8809 int action = object_mapping[tile].action;
8810 int direction = object_mapping[tile].direction;
8811 boolean is_backside = object_mapping[tile].is_backside;
8812 int effective_element = get_effective_element_EM(tile, frame_em);
8813 int effective_action = action;
8814 int graphic = (direction == MV_NONE ?
8815 el_act2img(effective_element, effective_action) :
8816 el_act_dir2img(effective_element, effective_action,
8818 int crumbled = (direction == MV_NONE ?
8819 el_act2crm(effective_element, effective_action) :
8820 el_act_dir2crm(effective_element, effective_action,
8822 int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
8823 int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
8824 boolean has_crumbled_graphics = (base_crumbled != base_graphic);
8825 struct GraphicInfo *g = &graphic_info[graphic];
8828 // special case: graphic uses "2nd movement tile" and has defined
8829 // 7 frames for movement animation (or less) => use default graphic
8830 // for last (8th) frame which ends the movement animation
8831 if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
8833 effective_action = ACTION_DEFAULT;
8834 graphic = (direction == MV_NONE ?
8835 el_act2img(effective_element, effective_action) :
8836 el_act_dir2img(effective_element, effective_action,
8838 crumbled = (direction == MV_NONE ?
8839 el_act2crm(effective_element, effective_action) :
8840 el_act_dir2crm(effective_element, effective_action,
8843 g = &graphic_info[graphic];
8846 if (graphic_info[graphic].anim_global_sync)
8847 sync_frame = FrameCounter;
8848 else if (graphic_info[graphic].anim_global_anim_sync)
8849 sync_frame = getGlobalAnimSyncFrame();
8850 else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
8851 sync_frame = GfxFrame[x][y];
8853 sync_frame = 0; // playfield border (pseudo steel)
8855 SetRandomAnimationValue(x, y);
8857 int frame = getAnimationFrame(g->anim_frames,
8860 g->anim_start_frame,
8863 getGraphicSourceExt(graphic, frame, &g_em->bitmap, &g_em->src_x, &g_em->src_y,
8864 g->double_movement && is_backside);
8866 // (updating the "crumbled" graphic definitions is probably not really needed,
8867 // as animations for crumbled graphics can't be longer than one EMC cycle)
8868 set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
8872 void getGraphicSourcePlayerExt_EM(struct GraphicInfo_EM *g_em,
8873 int player_nr, int anim, int frame_em)
8875 int element = player_mapping[player_nr][anim].element_rnd;
8876 int action = player_mapping[player_nr][anim].action;
8877 int direction = player_mapping[player_nr][anim].direction;
8878 int graphic = (direction == MV_NONE ?
8879 el_act2img(element, action) :
8880 el_act_dir2img(element, action, direction));
8881 struct GraphicInfo *g = &graphic_info[graphic];
8884 InitPlayerGfxAnimation(&stored_player[player_nr], action, direction);
8886 stored_player[player_nr].StepFrame = frame_em;
8888 sync_frame = stored_player[player_nr].Frame;
8890 int frame = getAnimationFrame(g->anim_frames,
8893 g->anim_start_frame,
8896 getGraphicSourceExt(graphic, frame, &g_em->bitmap,
8897 &g_em->src_x, &g_em->src_y, FALSE);
8900 void InitGraphicInfo_EM(void)
8904 // always start with reliable default values
8905 for (i = 0; i < GAME_TILE_MAX; i++)
8907 object_mapping[i].element_rnd = EL_UNKNOWN;
8908 object_mapping[i].is_backside = FALSE;
8909 object_mapping[i].action = ACTION_DEFAULT;
8910 object_mapping[i].direction = MV_NONE;
8913 // always start with reliable default values
8914 for (p = 0; p < MAX_PLAYERS; p++)
8916 for (i = 0; i < PLY_MAX; i++)
8918 player_mapping[p][i].element_rnd = EL_UNKNOWN;
8919 player_mapping[p][i].action = ACTION_DEFAULT;
8920 player_mapping[p][i].direction = MV_NONE;
8924 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
8926 int e = em_object_mapping_list[i].element_em;
8928 object_mapping[e].element_rnd = em_object_mapping_list[i].element_rnd;
8929 object_mapping[e].is_backside = em_object_mapping_list[i].is_backside;
8931 if (em_object_mapping_list[i].action != -1)
8932 object_mapping[e].action = em_object_mapping_list[i].action;
8934 if (em_object_mapping_list[i].direction != -1)
8935 object_mapping[e].direction =
8936 MV_DIR_FROM_BIT(em_object_mapping_list[i].direction);
8939 for (i = 0; em_player_mapping_list[i].action_em != -1; i++)
8941 int a = em_player_mapping_list[i].action_em;
8942 int p = em_player_mapping_list[i].player_nr;
8944 player_mapping[p][a].element_rnd = em_player_mapping_list[i].element_rnd;
8946 if (em_player_mapping_list[i].action != -1)
8947 player_mapping[p][a].action = em_player_mapping_list[i].action;
8949 if (em_player_mapping_list[i].direction != -1)
8950 player_mapping[p][a].direction =
8951 MV_DIR_FROM_BIT(em_player_mapping_list[i].direction);
8954 for (i = 0; i < GAME_TILE_MAX; i++)
8956 int element = object_mapping[i].element_rnd;
8957 int action = object_mapping[i].action;
8958 int direction = object_mapping[i].direction;
8959 boolean is_backside = object_mapping[i].is_backside;
8960 boolean action_exploding = ((action == ACTION_EXPLODING ||
8961 action == ACTION_SMASHED_BY_ROCK ||
8962 action == ACTION_SMASHED_BY_SPRING) &&
8963 element != EL_DIAMOND);
8964 boolean action_active = (action == ACTION_ACTIVE);
8965 boolean action_other = (action == ACTION_OTHER);
8967 for (j = 0; j < 8; j++)
8969 int effective_element = get_effective_element_EM(i, j);
8970 int effective_action = (j < 7 ? action :
8971 i == Xdrip_stretch ? action :
8972 i == Xdrip_stretchB ? action :
8973 i == Ydrip_1_s ? action :
8974 i == Ydrip_1_sB ? action :
8975 i == Yball_1 ? action :
8976 i == Xball_2 ? action :
8977 i == Yball_2 ? action :
8978 i == Yball_blank ? action :
8979 i == Ykey_1_blank ? action :
8980 i == Ykey_2_blank ? action :
8981 i == Ykey_3_blank ? action :
8982 i == Ykey_4_blank ? action :
8983 i == Ykey_5_blank ? action :
8984 i == Ykey_6_blank ? action :
8985 i == Ykey_7_blank ? action :
8986 i == Ykey_8_blank ? action :
8987 i == Ylenses_blank ? action :
8988 i == Ymagnify_blank ? action :
8989 i == Ygrass_blank ? action :
8990 i == Ydirt_blank ? action :
8991 i == Xsand_stonein_1 ? action :
8992 i == Xsand_stonein_2 ? action :
8993 i == Xsand_stonein_3 ? action :
8994 i == Xsand_stonein_4 ? action :
8995 i == Xsand_stoneout_1 ? action :
8996 i == Xsand_stoneout_2 ? action :
8997 i == Xboom_android ? ACTION_EXPLODING :
8998 action_exploding ? ACTION_EXPLODING :
8999 action_active ? action :
9000 action_other ? action :
9002 int graphic = (el_act_dir2img(effective_element, effective_action,
9004 int crumbled = (el_act_dir2crm(effective_element, effective_action,
9006 int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
9007 int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
9008 boolean has_action_graphics = (graphic != base_graphic);
9009 boolean has_crumbled_graphics = (base_crumbled != base_graphic);
9010 struct GraphicInfo *g = &graphic_info[graphic];
9011 struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
9014 // ensure to get symmetric 3-frame, 2-delay animations as used in EM
9015 boolean special_animation = (action != ACTION_DEFAULT &&
9016 g->anim_frames == 3 &&
9017 g->anim_delay == 2 &&
9018 g->anim_mode & ANIM_LINEAR);
9019 int sync_frame = (i == Xdrip_stretch ? 7 :
9020 i == Xdrip_stretchB ? 7 :
9021 i == Ydrip_2_s ? j + 8 :
9022 i == Ydrip_2_sB ? j + 8 :
9031 i == Xfake_acid_1 ? 0 :
9032 i == Xfake_acid_2 ? 10 :
9033 i == Xfake_acid_3 ? 20 :
9034 i == Xfake_acid_4 ? 30 :
9035 i == Xfake_acid_5 ? 40 :
9036 i == Xfake_acid_6 ? 50 :
9037 i == Xfake_acid_7 ? 60 :
9038 i == Xfake_acid_8 ? 70 :
9039 i == Xfake_acid_1_player ? 0 :
9040 i == Xfake_acid_2_player ? 10 :
9041 i == Xfake_acid_3_player ? 20 :
9042 i == Xfake_acid_4_player ? 30 :
9043 i == Xfake_acid_5_player ? 40 :
9044 i == Xfake_acid_6_player ? 50 :
9045 i == Xfake_acid_7_player ? 60 :
9046 i == Xfake_acid_8_player ? 70 :
9048 i == Yball_2 ? j + 8 :
9049 i == Yball_blank ? j + 1 :
9050 i == Ykey_1_blank ? j + 1 :
9051 i == Ykey_2_blank ? j + 1 :
9052 i == Ykey_3_blank ? j + 1 :
9053 i == Ykey_4_blank ? j + 1 :
9054 i == Ykey_5_blank ? j + 1 :
9055 i == Ykey_6_blank ? j + 1 :
9056 i == Ykey_7_blank ? j + 1 :
9057 i == Ykey_8_blank ? j + 1 :
9058 i == Ylenses_blank ? j + 1 :
9059 i == Ymagnify_blank ? j + 1 :
9060 i == Ygrass_blank ? j + 1 :
9061 i == Ydirt_blank ? j + 1 :
9062 i == Xamoeba_1 ? 0 :
9063 i == Xamoeba_2 ? 1 :
9064 i == Xamoeba_3 ? 2 :
9065 i == Xamoeba_4 ? 3 :
9066 i == Xamoeba_5 ? 0 :
9067 i == Xamoeba_6 ? 1 :
9068 i == Xamoeba_7 ? 2 :
9069 i == Xamoeba_8 ? 3 :
9070 i == Xexit_2 ? j + 8 :
9071 i == Xexit_3 ? j + 16 :
9072 i == Xdynamite_1 ? 0 :
9073 i == Xdynamite_2 ? 8 :
9074 i == Xdynamite_3 ? 16 :
9075 i == Xdynamite_4 ? 24 :
9076 i == Xsand_stonein_1 ? j + 1 :
9077 i == Xsand_stonein_2 ? j + 9 :
9078 i == Xsand_stonein_3 ? j + 17 :
9079 i == Xsand_stonein_4 ? j + 25 :
9080 i == Xsand_stoneout_1 && j == 0 ? 0 :
9081 i == Xsand_stoneout_1 && j == 1 ? 0 :
9082 i == Xsand_stoneout_1 && j == 2 ? 1 :
9083 i == Xsand_stoneout_1 && j == 3 ? 2 :
9084 i == Xsand_stoneout_1 && j == 4 ? 2 :
9085 i == Xsand_stoneout_1 && j == 5 ? 3 :
9086 i == Xsand_stoneout_1 && j == 6 ? 4 :
9087 i == Xsand_stoneout_1 && j == 7 ? 4 :
9088 i == Xsand_stoneout_2 && j == 0 ? 5 :
9089 i == Xsand_stoneout_2 && j == 1 ? 6 :
9090 i == Xsand_stoneout_2 && j == 2 ? 7 :
9091 i == Xsand_stoneout_2 && j == 3 ? 8 :
9092 i == Xsand_stoneout_2 && j == 4 ? 9 :
9093 i == Xsand_stoneout_2 && j == 5 ? 11 :
9094 i == Xsand_stoneout_2 && j == 6 ? 13 :
9095 i == Xsand_stoneout_2 && j == 7 ? 15 :
9096 i == Xboom_bug && j == 1 ? 2 :
9097 i == Xboom_bug && j == 2 ? 2 :
9098 i == Xboom_bug && j == 3 ? 4 :
9099 i == Xboom_bug && j == 4 ? 4 :
9100 i == Xboom_bug && j == 5 ? 2 :
9101 i == Xboom_bug && j == 6 ? 2 :
9102 i == Xboom_bug && j == 7 ? 0 :
9103 i == Xboom_tank && j == 1 ? 2 :
9104 i == Xboom_tank && j == 2 ? 2 :
9105 i == Xboom_tank && j == 3 ? 4 :
9106 i == Xboom_tank && j == 4 ? 4 :
9107 i == Xboom_tank && j == 5 ? 2 :
9108 i == Xboom_tank && j == 6 ? 2 :
9109 i == Xboom_tank && j == 7 ? 0 :
9110 i == Xboom_android && j == 7 ? 6 :
9111 i == Xboom_1 && j == 1 ? 2 :
9112 i == Xboom_1 && j == 2 ? 2 :
9113 i == Xboom_1 && j == 3 ? 4 :
9114 i == Xboom_1 && j == 4 ? 4 :
9115 i == Xboom_1 && j == 5 ? 6 :
9116 i == Xboom_1 && j == 6 ? 6 :
9117 i == Xboom_1 && j == 7 ? 8 :
9118 i == Xboom_2 && j == 0 ? 8 :
9119 i == Xboom_2 && j == 1 ? 8 :
9120 i == Xboom_2 && j == 2 ? 10 :
9121 i == Xboom_2 && j == 3 ? 10 :
9122 i == Xboom_2 && j == 4 ? 10 :
9123 i == Xboom_2 && j == 5 ? 12 :
9124 i == Xboom_2 && j == 6 ? 12 :
9125 i == Xboom_2 && j == 7 ? 12 :
9126 special_animation && j == 4 ? 3 :
9127 effective_action != action ? 0 :
9129 int frame = getAnimationFrame(g->anim_frames,
9132 g->anim_start_frame,
9135 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y,
9136 g->double_movement && is_backside);
9138 g_em->bitmap = src_bitmap;
9139 g_em->src_x = src_x;
9140 g_em->src_y = src_y;
9141 g_em->src_offset_x = 0;
9142 g_em->src_offset_y = 0;
9143 g_em->dst_offset_x = 0;
9144 g_em->dst_offset_y = 0;
9145 g_em->width = TILEX;
9146 g_em->height = TILEY;
9148 g_em->preserve_background = FALSE;
9150 set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
9153 if ((!g->double_movement && (effective_action == ACTION_FALLING ||
9154 effective_action == ACTION_MOVING ||
9155 effective_action == ACTION_PUSHING ||
9156 effective_action == ACTION_EATING)) ||
9157 (!has_action_graphics && (effective_action == ACTION_FILLING ||
9158 effective_action == ACTION_EMPTYING)))
9161 (effective_action == ACTION_FALLING ||
9162 effective_action == ACTION_FILLING ||
9163 effective_action == ACTION_EMPTYING ? MV_DOWN : direction);
9164 int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? 1 : 0);
9165 int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? 1 : 0);
9166 int num_steps = (i == Ydrip_1_s ? 16 :
9167 i == Ydrip_1_sB ? 16 :
9168 i == Ydrip_2_s ? 16 :
9169 i == Ydrip_2_sB ? 16 :
9170 i == Xsand_stonein_1 ? 32 :
9171 i == Xsand_stonein_2 ? 32 :
9172 i == Xsand_stonein_3 ? 32 :
9173 i == Xsand_stonein_4 ? 32 :
9174 i == Xsand_stoneout_1 ? 16 :
9175 i == Xsand_stoneout_2 ? 16 : 8);
9176 int cx = ABS(dx) * (TILEX / num_steps);
9177 int cy = ABS(dy) * (TILEY / num_steps);
9178 int step_frame = (i == Ydrip_2_s ? j + 8 :
9179 i == Ydrip_2_sB ? j + 8 :
9180 i == Xsand_stonein_2 ? j + 8 :
9181 i == Xsand_stonein_3 ? j + 16 :
9182 i == Xsand_stonein_4 ? j + 24 :
9183 i == Xsand_stoneout_2 ? j + 8 : j) + 1;
9184 int step = (is_backside ? step_frame : num_steps - step_frame);
9186 if (is_backside) // tile where movement starts
9188 if (dx < 0 || dy < 0)
9190 g_em->src_offset_x = cx * step;
9191 g_em->src_offset_y = cy * step;
9195 g_em->dst_offset_x = cx * step;
9196 g_em->dst_offset_y = cy * step;
9199 else // tile where movement ends
9201 if (dx < 0 || dy < 0)
9203 g_em->dst_offset_x = cx * step;
9204 g_em->dst_offset_y = cy * step;
9208 g_em->src_offset_x = cx * step;
9209 g_em->src_offset_y = cy * step;
9213 g_em->width = TILEX - cx * step;
9214 g_em->height = TILEY - cy * step;
9217 // create unique graphic identifier to decide if tile must be redrawn
9218 /* bit 31 - 16 (16 bit): EM style graphic
9219 bit 15 - 12 ( 4 bit): EM style frame
9220 bit 11 - 6 ( 6 bit): graphic width
9221 bit 5 - 0 ( 6 bit): graphic height */
9222 g_em->unique_identifier =
9223 (graphic << 16) | (frame << 12) | (g_em->width << 6) | g_em->height;
9227 for (i = 0; i < GAME_TILE_MAX; i++)
9229 for (j = 0; j < 8; j++)
9231 int element = object_mapping[i].element_rnd;
9232 int action = object_mapping[i].action;
9233 int direction = object_mapping[i].direction;
9234 boolean is_backside = object_mapping[i].is_backside;
9235 int graphic_action = el_act_dir2img(element, action, direction);
9236 int graphic_default = el_act_dir2img(element, ACTION_DEFAULT, direction);
9238 if ((action == ACTION_SMASHED_BY_ROCK ||
9239 action == ACTION_SMASHED_BY_SPRING ||
9240 action == ACTION_EATING) &&
9241 graphic_action == graphic_default)
9243 int e = (action == ACTION_SMASHED_BY_ROCK ? Ystone_s :
9244 action == ACTION_SMASHED_BY_SPRING ? Yspring_s :
9245 direction == MV_LEFT ? (is_backside? Yspring_wB: Yspring_w) :
9246 direction == MV_RIGHT ? (is_backside? Yspring_eB: Yspring_e) :
9249 // no separate animation for "smashed by rock" -- use rock instead
9250 struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
9251 struct GraphicInfo_EM *g_xx = &graphic_info_em_object[e][j];
9253 g_em->bitmap = g_xx->bitmap;
9254 g_em->src_x = g_xx->src_x;
9255 g_em->src_y = g_xx->src_y;
9256 g_em->src_offset_x = g_xx->src_offset_x;
9257 g_em->src_offset_y = g_xx->src_offset_y;
9258 g_em->dst_offset_x = g_xx->dst_offset_x;
9259 g_em->dst_offset_y = g_xx->dst_offset_y;
9260 g_em->width = g_xx->width;
9261 g_em->height = g_xx->height;
9262 g_em->unique_identifier = g_xx->unique_identifier;
9265 g_em->preserve_background = TRUE;
9270 for (p = 0; p < MAX_PLAYERS; p++)
9272 for (i = 0; i < PLY_MAX; i++)
9274 int element = player_mapping[p][i].element_rnd;
9275 int action = player_mapping[p][i].action;
9276 int direction = player_mapping[p][i].direction;
9278 for (j = 0; j < 8; j++)
9280 int effective_element = element;
9281 int effective_action = action;
9282 int graphic = (direction == MV_NONE ?
9283 el_act2img(effective_element, effective_action) :
9284 el_act_dir2img(effective_element, effective_action,
9286 struct GraphicInfo *g = &graphic_info[graphic];
9287 struct GraphicInfo_EM *g_em = &graphic_info_em_player[p][i][j];
9291 int frame = getAnimationFrame(g->anim_frames,
9294 g->anim_start_frame,
9297 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
9299 g_em->bitmap = src_bitmap;
9300 g_em->src_x = src_x;
9301 g_em->src_y = src_y;
9302 g_em->src_offset_x = 0;
9303 g_em->src_offset_y = 0;
9304 g_em->dst_offset_x = 0;
9305 g_em->dst_offset_y = 0;
9306 g_em->width = TILEX;
9307 g_em->height = TILEY;
9313 static void CheckSaveEngineSnapshot_EM(int frame,
9314 boolean any_player_moving,
9315 boolean any_player_snapping,
9316 boolean any_player_dropping)
9318 if (frame == 7 && !any_player_dropping)
9320 if (!local_player->was_waiting)
9322 if (!CheckSaveEngineSnapshotToList())
9325 local_player->was_waiting = TRUE;
9328 else if (any_player_moving || any_player_snapping || any_player_dropping)
9330 local_player->was_waiting = FALSE;
9334 static void CheckSaveEngineSnapshot_SP(boolean murphy_is_waiting,
9335 boolean murphy_is_dropping)
9337 if (murphy_is_waiting)
9339 if (!local_player->was_waiting)
9341 if (!CheckSaveEngineSnapshotToList())
9344 local_player->was_waiting = TRUE;
9349 local_player->was_waiting = FALSE;
9353 static void CheckSaveEngineSnapshot_MM(boolean element_clicked,
9354 boolean button_released)
9356 if (button_released)
9358 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE)
9359 CheckSaveEngineSnapshotToList();
9361 else if (element_clicked)
9363 if (game.snapshot.mode != SNAPSHOT_MODE_EVERY_MOVE)
9364 CheckSaveEngineSnapshotToList();
9366 game.snapshot.changed_action = TRUE;
9370 boolean CheckSingleStepMode_EM(int frame,
9371 boolean any_player_moving,
9372 boolean any_player_snapping,
9373 boolean any_player_dropping)
9375 if (tape.single_step && tape.recording && !tape.pausing)
9376 if (frame == 7 && !any_player_dropping && FrameCounter > 6)
9377 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9379 CheckSaveEngineSnapshot_EM(frame, any_player_moving,
9380 any_player_snapping, any_player_dropping);
9382 return tape.pausing;
9385 void CheckSingleStepMode_SP(boolean murphy_is_waiting,
9386 boolean murphy_is_dropping)
9388 boolean murphy_starts_dropping = FALSE;
9391 for (i = 0; i < MAX_PLAYERS; i++)
9392 if (stored_player[i].force_dropping)
9393 murphy_starts_dropping = TRUE;
9395 if (tape.single_step && tape.recording && !tape.pausing)
9396 if (murphy_is_waiting && !murphy_starts_dropping)
9397 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9399 CheckSaveEngineSnapshot_SP(murphy_is_waiting, murphy_is_dropping);
9402 void CheckSingleStepMode_MM(boolean element_clicked,
9403 boolean button_released)
9405 if (tape.single_step && tape.recording && !tape.pausing)
9406 if (button_released)
9407 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9409 CheckSaveEngineSnapshot_MM(element_clicked, button_released);
9412 void getGraphicSource_SP(struct GraphicInfo_SP *g_sp,
9413 int graphic, int sync_frame)
9415 int frame = getGraphicAnimationFrame(graphic, sync_frame);
9417 getGraphicSource(graphic, frame, &g_sp->bitmap, &g_sp->src_x, &g_sp->src_y);
9420 boolean isNextAnimationFrame_SP(int graphic, int sync_frame)
9422 return (IS_NEXT_FRAME(sync_frame, graphic));
9425 int getGraphicInfo_Delay(int graphic)
9427 return graphic_info[graphic].anim_delay;
9430 boolean getGraphicInfo_NewFrame(int x, int y, int graphic)
9432 if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
9435 if (ANIM_MODE(graphic) & (ANIM_TILED | ANIM_RANDOM_STATIC))
9441 void PlayMenuSoundExt(int sound)
9443 if (sound == SND_UNDEFINED)
9446 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9447 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9450 if (IS_LOOP_SOUND(sound))
9451 PlaySoundLoop(sound);
9456 void PlayMenuSound(void)
9458 PlayMenuSoundExt(menu.sound[game_status]);
9461 void PlayMenuSoundStereo(int sound, int stereo_position)
9463 if (sound == SND_UNDEFINED)
9466 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9467 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9470 if (IS_LOOP_SOUND(sound))
9471 PlaySoundExt(sound, SOUND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_LOOP);
9473 PlaySoundStereo(sound, stereo_position);
9476 void PlayMenuSoundIfLoopExt(int sound)
9478 if (sound == SND_UNDEFINED)
9481 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
9482 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
9485 if (IS_LOOP_SOUND(sound))
9486 PlaySoundLoop(sound);
9489 void PlayMenuSoundIfLoop(void)
9491 PlayMenuSoundIfLoopExt(menu.sound[game_status]);
9494 void PlayMenuMusicExt(int music)
9496 if (music == MUS_UNDEFINED)
9499 if (!setup.sound_music)
9502 if (IS_LOOP_MUSIC(music))
9503 PlayMusicLoop(music);
9508 void PlayMenuMusic(void)
9510 char *curr_music = getCurrentlyPlayingMusicFilename();
9511 char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
9513 if (!strEqual(curr_music, next_music))
9514 PlayMenuMusicExt(menu.music[game_status]);
9517 void PlayMenuSoundsAndMusic(void)
9523 static void FadeMenuSounds(void)
9528 static void FadeMenuMusic(void)
9530 char *curr_music = getCurrentlyPlayingMusicFilename();
9531 char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
9533 if (!strEqual(curr_music, next_music))
9537 void FadeMenuSoundsAndMusic(void)
9543 void PlaySoundActivating(void)
9546 PlaySound(SND_MENU_ITEM_ACTIVATING);
9550 void PlaySoundSelecting(void)
9553 PlaySound(SND_MENU_ITEM_SELECTING);
9557 void ToggleFullscreenIfNeeded(void)
9559 // if setup and video fullscreen state are already matching, nothing do do
9560 if (setup.fullscreen == video.fullscreen_enabled ||
9561 !video.fullscreen_available)
9564 SDLSetWindowFullscreen(setup.fullscreen);
9566 // set setup value according to successfully changed fullscreen mode
9567 setup.fullscreen = video.fullscreen_enabled;
9570 void ChangeWindowScalingIfNeeded(void)
9572 // if setup and video window scaling are already matching, nothing do do
9573 if (setup.window_scaling_percent == video.window_scaling_percent ||
9574 video.fullscreen_enabled)
9577 SDLSetWindowScaling(setup.window_scaling_percent);
9579 // set setup value according to successfully changed window scaling
9580 setup.window_scaling_percent = video.window_scaling_percent;
9583 void ChangeVsyncModeIfNeeded(void)
9585 int setup_vsync_mode = VSYNC_MODE_STR_TO_INT(setup.vsync_mode);
9586 int video_vsync_mode = video.vsync_mode;
9588 // if setup and video vsync mode are already matching, nothing do do
9589 if (setup_vsync_mode == video_vsync_mode)
9592 // if renderer is using OpenGL, vsync mode can directly be changed
9593 SDLSetScreenVsyncMode(setup.vsync_mode);
9595 // if vsync mode unchanged, try re-creating renderer to set vsync mode
9596 if (video.vsync_mode == video_vsync_mode)
9598 Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
9600 // save backbuffer content which gets lost when re-creating screen
9601 BlitBitmap(backbuffer, tmp_backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9603 // force re-creating screen and renderer to set new vsync mode
9604 video.fullscreen_enabled = !setup.fullscreen;
9606 // when creating new renderer, destroy textures linked to old renderer
9607 FreeAllImageTextures(); // needs old renderer to free the textures
9609 // re-create screen and renderer (including change of vsync mode)
9610 ChangeVideoModeIfNeeded(setup.fullscreen);
9612 // set setup value according to successfully changed fullscreen mode
9613 setup.fullscreen = video.fullscreen_enabled;
9615 // restore backbuffer content from temporary backbuffer backup bitmap
9616 BlitBitmap(tmp_backbuffer, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9617 FreeBitmap(tmp_backbuffer);
9619 // update visible window/screen
9620 BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
9622 // when changing vsync mode, re-create textures for new renderer
9623 InitImageTextures();
9626 // set setup value according to successfully changed vsync mode
9627 setup.vsync_mode = VSYNC_MODE_INT_TO_STR(video.vsync_mode);
9630 static void JoinRectangles(int *x, int *y, int *width, int *height,
9631 int x2, int y2, int width2, int height2)
9633 // do not join with "off-screen" rectangle
9634 if (x2 == -1 || y2 == -1)
9639 *width = MAX(*width, width2);
9640 *height = MAX(*height, height2);
9643 void SetAnimStatus(int anim_status_new)
9645 if (anim_status_new == GAME_MODE_MAIN)
9646 anim_status_new = GAME_MODE_PSEUDO_MAINONLY;
9647 else if (anim_status_new == GAME_MODE_NAMES)
9648 anim_status_new = GAME_MODE_PSEUDO_NAMESONLY;
9649 else if (anim_status_new == GAME_MODE_SCORES)
9650 anim_status_new = GAME_MODE_PSEUDO_SCORESOLD;
9652 global.anim_status_next = anim_status_new;
9654 // directly set screen modes that are entered without fading
9655 if ((global.anim_status == GAME_MODE_PSEUDO_MAINONLY &&
9656 global.anim_status_next == GAME_MODE_PSEUDO_TYPENAME) ||
9657 (global.anim_status == GAME_MODE_PSEUDO_TYPENAME &&
9658 global.anim_status_next == GAME_MODE_PSEUDO_MAINONLY) ||
9659 (global.anim_status == GAME_MODE_PSEUDO_NAMESONLY &&
9660 global.anim_status_next == GAME_MODE_PSEUDO_TYPENAMES) ||
9661 (global.anim_status == GAME_MODE_PSEUDO_TYPENAMES &&
9662 global.anim_status_next == GAME_MODE_PSEUDO_NAMESONLY))
9663 global.anim_status = global.anim_status_next;
9666 void SetGameStatus(int game_status_new)
9668 if (game_status_new != game_status)
9669 game_status_last_screen = game_status;
9671 game_status = game_status_new;
9673 SetAnimStatus(game_status_new);
9676 void SetFontStatus(int game_status_new)
9678 static int last_game_status = -1;
9680 if (game_status_new != -1)
9682 // set game status for font use after storing last game status
9683 last_game_status = game_status;
9684 game_status = game_status_new;
9688 // reset game status after font use from last stored game status
9689 game_status = last_game_status;
9693 void ResetFontStatus(void)
9698 void SetLevelSetInfo(char *identifier, int level_nr)
9700 setString(&levelset.identifier, identifier);
9702 levelset.level_nr = level_nr;
9705 boolean CheckIfAllViewportsHaveChanged(void)
9707 // if game status has not changed, viewports have not changed either
9708 if (game_status == game_status_last)
9711 // check if all viewports have changed with current game status
9713 struct RectWithBorder *vp_playfield = &viewport.playfield[game_status];
9714 struct RectWithBorder *vp_door_1 = &viewport.door_1[game_status];
9715 struct RectWithBorder *vp_door_2 = &viewport.door_2[game_status];
9716 int new_real_sx = vp_playfield->x;
9717 int new_real_sy = vp_playfield->y;
9718 int new_full_sxsize = vp_playfield->width;
9719 int new_full_sysize = vp_playfield->height;
9720 int new_dx = vp_door_1->x;
9721 int new_dy = vp_door_1->y;
9722 int new_dxsize = vp_door_1->width;
9723 int new_dysize = vp_door_1->height;
9724 int new_vx = vp_door_2->x;
9725 int new_vy = vp_door_2->y;
9726 int new_vxsize = vp_door_2->width;
9727 int new_vysize = vp_door_2->height;
9729 boolean playfield_viewport_has_changed =
9730 (new_real_sx != REAL_SX ||
9731 new_real_sy != REAL_SY ||
9732 new_full_sxsize != FULL_SXSIZE ||
9733 new_full_sysize != FULL_SYSIZE);
9735 boolean door_1_viewport_has_changed =
9738 new_dxsize != DXSIZE ||
9739 new_dysize != DYSIZE);
9741 boolean door_2_viewport_has_changed =
9744 new_vxsize != VXSIZE ||
9745 new_vysize != VYSIZE ||
9746 game_status_last == GAME_MODE_EDITOR);
9748 return (playfield_viewport_has_changed &&
9749 door_1_viewport_has_changed &&
9750 door_2_viewport_has_changed);
9753 boolean CheckFadeAll(void)
9755 return (CheckIfGlobalBorderHasChanged() ||
9756 CheckIfAllViewportsHaveChanged());
9759 void ChangeViewportPropertiesIfNeeded(void)
9761 boolean use_mini_tilesize = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
9762 FALSE : setup.small_game_graphics);
9763 int gfx_game_mode = getGlobalGameStatus(game_status);
9764 int gfx_game_mode2 = (gfx_game_mode == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
9766 struct RectWithBorder *vp_window = &viewport.window[gfx_game_mode];
9767 struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
9768 struct RectWithBorder *vp_door_1 = &viewport.door_1[gfx_game_mode];
9769 struct RectWithBorder *vp_door_2 = &viewport.door_2[gfx_game_mode2];
9770 struct RectWithBorder *vp_door_3 = &viewport.door_2[GAME_MODE_EDITOR];
9771 int new_win_xsize = vp_window->width;
9772 int new_win_ysize = vp_window->height;
9773 int border_left = vp_playfield->border_left;
9774 int border_right = vp_playfield->border_right;
9775 int border_top = vp_playfield->border_top;
9776 int border_bottom = vp_playfield->border_bottom;
9777 int new_sx = vp_playfield->x + border_left;
9778 int new_sy = vp_playfield->y + border_top;
9779 int new_sxsize = vp_playfield->width - border_left - border_right;
9780 int new_sysize = vp_playfield->height - border_top - border_bottom;
9781 int new_real_sx = vp_playfield->x;
9782 int new_real_sy = vp_playfield->y;
9783 int new_full_sxsize = vp_playfield->width;
9784 int new_full_sysize = vp_playfield->height;
9785 int new_dx = vp_door_1->x;
9786 int new_dy = vp_door_1->y;
9787 int new_dxsize = vp_door_1->width;
9788 int new_dysize = vp_door_1->height;
9789 int new_vx = vp_door_2->x;
9790 int new_vy = vp_door_2->y;
9791 int new_vxsize = vp_door_2->width;
9792 int new_vysize = vp_door_2->height;
9793 int new_ex = vp_door_3->x;
9794 int new_ey = vp_door_3->y;
9795 int new_exsize = vp_door_3->width;
9796 int new_eysize = vp_door_3->height;
9797 int new_tilesize_var = (use_mini_tilesize ? MINI_TILESIZE : game.tile_size);
9798 int tilesize = (gfx_game_mode == GAME_MODE_PLAYING ? new_tilesize_var :
9799 gfx_game_mode == GAME_MODE_EDITOR ? MINI_TILESIZE : TILESIZE);
9800 int new_scr_fieldx = new_sxsize / tilesize;
9801 int new_scr_fieldy = new_sysize / tilesize;
9802 int new_scr_fieldx_buffers = new_sxsize / new_tilesize_var;
9803 int new_scr_fieldy_buffers = new_sysize / new_tilesize_var;
9804 boolean init_gfx_buffers = FALSE;
9805 boolean init_video_buffer = FALSE;
9806 boolean init_gadgets_and_anims = FALSE;
9807 boolean init_em_graphics = FALSE;
9809 if (new_win_xsize != WIN_XSIZE ||
9810 new_win_ysize != WIN_YSIZE)
9812 WIN_XSIZE = new_win_xsize;
9813 WIN_YSIZE = new_win_ysize;
9815 init_video_buffer = TRUE;
9816 init_gfx_buffers = TRUE;
9817 init_gadgets_and_anims = TRUE;
9819 // Debug("tools:viewport", "video: init_video_buffer, init_gfx_buffers");
9822 if (new_scr_fieldx != SCR_FIELDX ||
9823 new_scr_fieldy != SCR_FIELDY)
9825 // this always toggles between MAIN and GAME when using small tile size
9827 SCR_FIELDX = new_scr_fieldx;
9828 SCR_FIELDY = new_scr_fieldy;
9830 // Debug("tools:viewport", "new_scr_fieldx != SCR_FIELDX ...");
9841 new_sxsize != SXSIZE ||
9842 new_sysize != SYSIZE ||
9843 new_dxsize != DXSIZE ||
9844 new_dysize != DYSIZE ||
9845 new_vxsize != VXSIZE ||
9846 new_vysize != VYSIZE ||
9847 new_exsize != EXSIZE ||
9848 new_eysize != EYSIZE ||
9849 new_real_sx != REAL_SX ||
9850 new_real_sy != REAL_SY ||
9851 new_full_sxsize != FULL_SXSIZE ||
9852 new_full_sysize != FULL_SYSIZE ||
9853 new_tilesize_var != TILESIZE_VAR
9856 // ------------------------------------------------------------------------
9857 // determine next fading area for changed viewport definitions
9858 // ------------------------------------------------------------------------
9860 // start with current playfield area (default fading area)
9863 FADE_SXSIZE = FULL_SXSIZE;
9864 FADE_SYSIZE = FULL_SYSIZE;
9866 // add new playfield area if position or size has changed
9867 if (new_real_sx != REAL_SX || new_real_sy != REAL_SY ||
9868 new_full_sxsize != FULL_SXSIZE || new_full_sysize != FULL_SYSIZE)
9870 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9871 new_real_sx, new_real_sy, new_full_sxsize,new_full_sysize);
9874 // add current and new door 1 area if position or size has changed
9875 if (new_dx != DX || new_dy != DY ||
9876 new_dxsize != DXSIZE || new_dysize != DYSIZE)
9878 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9879 DX, DY, DXSIZE, DYSIZE);
9880 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9881 new_dx, new_dy, new_dxsize, new_dysize);
9884 // add current and new door 2 area if position or size has changed
9885 if (new_vx != VX || new_vy != VY ||
9886 new_vxsize != VXSIZE || new_vysize != VYSIZE)
9888 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9889 VX, VY, VXSIZE, VYSIZE);
9890 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
9891 new_vx, new_vy, new_vxsize, new_vysize);
9894 // ------------------------------------------------------------------------
9895 // handle changed tile size
9896 // ------------------------------------------------------------------------
9898 if (new_tilesize_var != TILESIZE_VAR)
9900 // Debug("tools:viewport", "new_tilesize_var != TILESIZE_VAR");
9902 // changing tile size invalidates scroll values of engine snapshots
9903 FreeEngineSnapshotSingle();
9905 // changing tile size requires update of graphic mapping for EM engine
9906 init_em_graphics = TRUE;
9917 SXSIZE = new_sxsize;
9918 SYSIZE = new_sysize;
9919 DXSIZE = new_dxsize;
9920 DYSIZE = new_dysize;
9921 VXSIZE = new_vxsize;
9922 VYSIZE = new_vysize;
9923 EXSIZE = new_exsize;
9924 EYSIZE = new_eysize;
9925 REAL_SX = new_real_sx;
9926 REAL_SY = new_real_sy;
9927 FULL_SXSIZE = new_full_sxsize;
9928 FULL_SYSIZE = new_full_sysize;
9929 TILESIZE_VAR = new_tilesize_var;
9931 init_gfx_buffers = TRUE;
9932 init_gadgets_and_anims = TRUE;
9934 // Debug("tools:viewport", "viewports: init_gfx_buffers");
9935 // Debug("tools:viewport", "viewports: init_gadgets_and_anims");
9938 if (init_gfx_buffers)
9940 // Debug("tools:viewport", "init_gfx_buffers");
9942 SCR_FIELDX = new_scr_fieldx_buffers;
9943 SCR_FIELDY = new_scr_fieldy_buffers;
9947 SCR_FIELDX = new_scr_fieldx;
9948 SCR_FIELDY = new_scr_fieldy;
9950 SetDrawDeactivationMask(REDRAW_NONE);
9951 SetDrawBackgroundMask(REDRAW_FIELD);
9954 if (init_video_buffer)
9956 // Debug("tools:viewport", "init_video_buffer");
9958 FreeAllImageTextures(); // needs old renderer to free the textures
9960 InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen);
9961 InitImageTextures();
9964 if (init_gadgets_and_anims)
9966 // Debug("tools:viewport", "init_gadgets_and_anims");
9969 InitGlobalAnimations();
9972 if (init_em_graphics)
9974 InitGraphicInfo_EM();
9978 void OpenURL(char *url)
9980 #if SDL_VERSION_ATLEAST(2,0,14)
9983 Warn("SDL_OpenURL(\"%s\") not supported by SDL %d.%d.%d!",
9984 url, SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
9985 Warn("Please upgrade to at least SDL 2.0.14 for URL support!");
9989 void OpenURLFromHash(SetupFileHash *hash, int hash_key)
9991 OpenURL(getHashEntry(hash, int2str(hash_key, 0)));
9995 // ============================================================================
9997 // ============================================================================
9999 #if defined(PLATFORM_WINDOWS)
10000 /* FILETIME of Jan 1 1970 00:00:00. */
10001 static const unsigned __int64 epoch = ((unsigned __int64) 116444736000000000ULL);
10004 * timezone information is stored outside the kernel so tzp isn't used anymore.
10006 * Note: this function is not for Win32 high precision timing purpose. See
10009 static int gettimeofday_windows(struct timeval * tp, struct timezone * tzp)
10011 FILETIME file_time;
10012 SYSTEMTIME system_time;
10013 ULARGE_INTEGER ularge;
10015 GetSystemTime(&system_time);
10016 SystemTimeToFileTime(&system_time, &file_time);
10017 ularge.LowPart = file_time.dwLowDateTime;
10018 ularge.HighPart = file_time.dwHighDateTime;
10020 tp->tv_sec = (long) ((ularge.QuadPart - epoch) / 10000000L);
10021 tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
10027 static char *test_init_uuid_random_function_simple(void)
10029 static char seed_text[100];
10030 unsigned int seed = InitSimpleRandom(NEW_RANDOMIZE);
10032 sprintf(seed_text, "%d", seed);
10037 static char *test_init_uuid_random_function_better(void)
10039 static char seed_text[100];
10040 struct timeval current_time;
10042 gettimeofday(¤t_time, NULL);
10044 prng_seed_bytes(¤t_time, sizeof(current_time));
10046 sprintf(seed_text, "%ld.%ld",
10047 (long)current_time.tv_sec,
10048 (long)current_time.tv_usec);
10053 #if defined(PLATFORM_WINDOWS)
10054 static char *test_init_uuid_random_function_better_windows(void)
10056 static char seed_text[100];
10057 struct timeval current_time;
10059 gettimeofday_windows(¤t_time, NULL);
10061 prng_seed_bytes(¤t_time, sizeof(current_time));
10063 sprintf(seed_text, "%ld.%ld",
10064 (long)current_time.tv_sec,
10065 (long)current_time.tv_usec);
10071 static unsigned int test_uuid_random_function_simple(int max)
10073 return GetSimpleRandom(max);
10076 static unsigned int test_uuid_random_function_better(int max)
10078 return (max > 0 ? prng_get_uint() % max : 0);
10081 #if defined(PLATFORM_WINDOWS)
10082 #define NUM_UUID_TESTS 3
10084 #define NUM_UUID_TESTS 2
10087 static void TestGeneratingUUIDs_RunTest(int nr, int always_seed, int num_uuids)
10089 struct hashtable *hash_seeds =
10090 create_hashtable(16, 0.75, get_hash_from_key, hash_keys_are_equal);
10091 struct hashtable *hash_uuids =
10092 create_hashtable(16, 0.75, get_hash_from_key, hash_keys_are_equal);
10093 static char message[100];
10096 char *random_name = (nr == 0 ? "simple" : "better");
10097 char *random_type = (always_seed ? "always" : "only once");
10098 char *(*init_random_function)(void) =
10100 test_init_uuid_random_function_simple :
10101 test_init_uuid_random_function_better);
10102 unsigned int (*random_function)(int) =
10104 test_uuid_random_function_simple :
10105 test_uuid_random_function_better);
10108 #if defined(PLATFORM_WINDOWS)
10111 random_name = "windows";
10112 init_random_function = test_init_uuid_random_function_better_windows;
10118 DrawTextF(xpos, 40, FC_GREEN, "Test: Generating UUIDs");
10119 DrawTextF(xpos, 80, FC_YELLOW, "Test %d.%d:", nr + 1, always_seed + 1);
10121 DrawTextF(xpos, 100, FC_YELLOW, "Random Generator Name: %s", random_name);
10122 DrawTextF(xpos, 120, FC_YELLOW, "Seeding Random Generator: %s", random_type);
10123 DrawTextF(xpos, 140, FC_YELLOW, "Number of UUIDs generated: %d", num_uuids);
10125 DrawTextF(xpos, 180, FC_GREEN, "Please wait ...");
10129 // always initialize random number generator at least once
10130 init_random_function();
10132 unsigned int time_start = SDL_GetTicks();
10134 for (i = 0; i < num_uuids; i++)
10138 char *seed = getStringCopy(init_random_function());
10140 hashtable_remove(hash_seeds, seed);
10141 hashtable_insert(hash_seeds, seed, "1");
10144 char *uuid = getStringCopy(getUUIDExt(random_function));
10146 hashtable_remove(hash_uuids, uuid);
10147 hashtable_insert(hash_uuids, uuid, "1");
10150 int num_unique_seeds = hashtable_count(hash_seeds);
10151 int num_unique_uuids = hashtable_count(hash_uuids);
10153 unsigned int time_needed = SDL_GetTicks() - time_start;
10155 DrawTextF(xpos, 220, FC_YELLOW, "Time needed: %d ms", time_needed);
10157 DrawTextF(xpos, 240, FC_YELLOW, "Number of unique UUIDs: %d", num_unique_uuids);
10160 DrawTextF(xpos, 260, FC_YELLOW, "Number of unique seeds: %d", num_unique_seeds);
10162 if (nr == NUM_UUID_TESTS - 1 && always_seed)
10163 DrawTextF(xpos, 300, FC_GREEN, "All tests done!");
10165 DrawTextF(xpos, 300, FC_GREEN, "Confirm dialog for next test ...");
10167 sprintf(message, "Test %d.%d finished!", nr + 1, always_seed + 1);
10169 Request(message, REQ_CONFIRM);
10171 hashtable_destroy(hash_seeds, 0);
10172 hashtable_destroy(hash_uuids, 0);
10175 void TestGeneratingUUIDs(void)
10177 int num_uuids = 1000000;
10180 for (i = 0; i < NUM_UUID_TESTS; i++)
10181 for (j = 0; j < 2; j++)
10182 TestGeneratingUUIDs_RunTest(i, j, num_uuids);
10184 CloseAllAndExit(0);