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 MapToolButtons(unsigned int);
179 static void UnmapToolButtons(void);
180 static void HandleToolButtons(struct GadgetInfo *);
181 static int el_act_dir2crm(int, int, int);
182 static int el_act2crm(int, int);
184 static struct GadgetInfo *tool_gadget[NUM_TOOL_BUTTONS];
185 static int request_gadget_id = -1;
187 static char *print_if_not_empty(int element)
189 static char *s = NULL;
190 char *token_name = element_info[element].token_name;
195 s = checked_malloc(strlen(token_name) + 10 + 1);
197 if (element != EL_EMPTY)
198 sprintf(s, "%d\t['%s']", element, token_name);
200 sprintf(s, "%d", element);
205 int getFieldbufferOffsetX_RND(int dir, int pos)
207 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
208 int dx = (dir & MV_HORIZONTAL ? pos : 0);
209 int dx_var = dx * TILESIZE_VAR / TILESIZE;
212 if (EVEN(SCR_FIELDX))
214 int sbx_right = SBX_Right + (BorderElement != EL_EMPTY ? 1 : 0);
215 int ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx_var;
217 if (ffx < sbx_right * TILEX_VAR + TILEX_VAR / 2)
218 fx += dx_var - MIN(ffx, TILEX_VAR / 2) + TILEX_VAR;
220 fx += (dx_var > 0 ? TILEX_VAR : 0);
227 if (full_lev_fieldx <= SCR_FIELDX)
229 if (EVEN(SCR_FIELDX))
230 fx = 2 * TILEX_VAR - (ODD(lev_fieldx) ? TILEX_VAR / 2 : 0);
232 fx = 2 * TILEX_VAR - (EVEN(lev_fieldx) ? TILEX_VAR / 2 : 0);
238 int getFieldbufferOffsetY_RND(int dir, int pos)
240 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
241 int dy = (dir & MV_VERTICAL ? pos : 0);
242 int dy_var = dy * TILESIZE_VAR / TILESIZE;
245 if (EVEN(SCR_FIELDY))
247 int sby_lower = SBY_Lower + (BorderElement != EL_EMPTY ? 1 : 0);
248 int ffy = (scroll_y - SBY_Upper) * TILEY_VAR + dy_var;
250 if (ffy < sby_lower * TILEY_VAR + TILEY_VAR / 2)
251 fy += dy_var - MIN(ffy, TILEY_VAR / 2) + TILEY_VAR;
253 fy += (dy_var > 0 ? TILEY_VAR : 0);
260 if (full_lev_fieldy <= SCR_FIELDY)
262 if (EVEN(SCR_FIELDY))
263 fy = 2 * TILEY_VAR - (ODD(lev_fieldy) ? TILEY_VAR / 2 : 0);
265 fy = 2 * TILEY_VAR - (EVEN(lev_fieldy) ? TILEY_VAR / 2 : 0);
271 static int getLevelFromScreenX_RND(int sx)
273 int fx = getFieldbufferOffsetX_RND(ScreenMovDir, ScreenGfxPos);
276 int lx = LEVELX((px + dx) / TILESIZE_VAR);
281 static int getLevelFromScreenY_RND(int sy)
283 int fy = getFieldbufferOffsetY_RND(ScreenMovDir, ScreenGfxPos);
286 int ly = LEVELY((py + dy) / TILESIZE_VAR);
291 static int getLevelFromScreenX_EM(int sx)
293 int level_xsize = level.native_em_level->cav->width;
294 int full_xsize = level_xsize * TILESIZE_VAR;
296 sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
298 int fx = getFieldbufferOffsetX_EM();
301 int lx = LEVELX((px + dx) / TILESIZE_VAR);
306 static int getLevelFromScreenY_EM(int sy)
308 int level_ysize = level.native_em_level->cav->height;
309 int full_ysize = level_ysize * TILESIZE_VAR;
311 sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
313 int fy = getFieldbufferOffsetY_EM();
316 int ly = LEVELY((py + dy) / TILESIZE_VAR);
321 static int getLevelFromScreenX_SP(int sx)
323 int menBorder = setup.sp_show_border_elements;
324 int level_xsize = level.native_sp_level->width;
325 int full_xsize = (level_xsize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
327 sx += (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
329 int fx = getFieldbufferOffsetX_SP();
332 int lx = LEVELX((px + dx) / TILESIZE_VAR);
337 static int getLevelFromScreenY_SP(int sy)
339 int menBorder = setup.sp_show_border_elements;
340 int level_ysize = level.native_sp_level->height;
341 int full_ysize = (level_ysize - (menBorder ? 0 : 1)) * TILESIZE_VAR;
343 sy += (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
345 int fy = getFieldbufferOffsetY_SP();
348 int ly = LEVELY((py + dy) / TILESIZE_VAR);
353 static int getLevelFromScreenX_MM(int sx)
355 int level_xsize = level.native_mm_level->fieldx;
356 int full_xsize = level_xsize * TILESIZE_VAR;
358 sx -= (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0);
361 int lx = (px + TILESIZE_VAR) / TILESIZE_VAR - 1;
366 static int getLevelFromScreenY_MM(int sy)
368 int level_ysize = level.native_mm_level->fieldy;
369 int full_ysize = level_ysize * TILESIZE_VAR;
371 sy -= (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0);
374 int ly = (py + TILESIZE_VAR) / TILESIZE_VAR - 1;
379 int getLevelFromScreenX(int x)
381 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
382 return getLevelFromScreenX_EM(x);
383 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
384 return getLevelFromScreenX_SP(x);
385 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
386 return getLevelFromScreenX_MM(x);
388 return getLevelFromScreenX_RND(x);
391 int getLevelFromScreenY(int y)
393 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
394 return getLevelFromScreenY_EM(y);
395 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
396 return getLevelFromScreenY_SP(y);
397 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
398 return getLevelFromScreenY_MM(y);
400 return getLevelFromScreenY_RND(y);
403 int getScreenFieldSizeX(void)
405 return (tape.playing ? tape.scr_fieldx : SCR_FIELDX);
408 int getScreenFieldSizeY(void)
410 return (tape.playing ? tape.scr_fieldy : SCR_FIELDY);
413 void DumpTile(int x, int y)
420 Info("Field Info: SCREEN(%d, %d), LEVEL(%d, %d)", sx, sy, x, y);
423 if (!IN_LEV_FIELD(x, y))
425 Info("(not in level field)");
431 token_name = element_info[Tile[x][y]].token_name;
433 Info("Tile: %d\t['%s']", Tile[x][y], token_name);
434 Info("Back: %s", print_if_not_empty(Back[x][y]));
435 Info("Store: %s", print_if_not_empty(Store[x][y]));
436 Info("Store2: %s", print_if_not_empty(Store2[x][y]));
437 Info("StorePlayer: %s", print_if_not_empty(StorePlayer[x][y]));
438 Info("MovPos: %d", MovPos[x][y]);
439 Info("MovDir: %d", MovDir[x][y]);
440 Info("MovDelay: %d", MovDelay[x][y]);
441 Info("ChangeDelay: %d", ChangeDelay[x][y]);
442 Info("CustomValue: %d", CustomValue[x][y]);
443 Info("GfxElement: %d", GfxElement[x][y]);
444 Info("GfxAction: %d", GfxAction[x][y]);
445 Info("GfxFrame: %d [%d]", GfxFrame[x][y], FrameCounter);
446 Info("Player x/y: %d, %d", local_player->jx, local_player->jy);
450 void DumpTileFromScreen(int sx, int sy)
452 int lx = getLevelFromScreenX(sx);
453 int ly = getLevelFromScreenY(sy);
458 void SetDrawtoField(int mode)
460 if (mode == DRAW_TO_FIELDBUFFER)
466 BX2 = SCR_FIELDX + 1;
467 BY2 = SCR_FIELDY + 1;
469 drawto_field = fieldbuffer;
471 else // DRAW_TO_BACKBUFFER
477 BX2 = SCR_FIELDX - 1;
478 BY2 = SCR_FIELDY - 1;
480 drawto_field = backbuffer;
484 int GetDrawtoField(void)
486 return (drawto_field == fieldbuffer ? DRAW_TO_FIELDBUFFER : DRAW_TO_BACKBUFFER);
489 static void RedrawPlayfield_RND(void)
491 if (game.envelope_active)
494 DrawLevel(REDRAW_ALL);
498 void RedrawPlayfield(void)
500 if (game_status != GAME_MODE_PLAYING)
503 if (level.game_engine_type == GAME_ENGINE_TYPE_BD)
504 RedrawPlayfield_BD(TRUE);
505 else if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
506 RedrawPlayfield_EM(TRUE);
507 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
508 RedrawPlayfield_SP(TRUE);
509 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
510 RedrawPlayfield_MM();
511 else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
512 RedrawPlayfield_RND();
514 BlitScreenToBitmap(backbuffer);
516 BlitBitmap(drawto, window, gfx.sx, gfx.sy, gfx.sxsize, gfx.sysize,
520 static void DrawMaskedBorderExt_Rect(int x, int y, int width, int height,
523 Bitmap *src_bitmap = getGlobalBorderBitmapFromStatus(global.border_status);
524 Bitmap *dst_bitmap = gfx.masked_border_bitmap_ptr;
526 // may happen for "border.draw_masked.*" with undefined "global.border.*"
527 if (src_bitmap == NULL)
530 if (x == -1 && y == -1)
533 if (draw_target == DRAW_TO_SCREEN)
534 BlitToScreenMasked(src_bitmap, x, y, width, height, x, y);
536 BlitBitmapMasked(src_bitmap, dst_bitmap, x, y, width, height, x, y);
539 static void DrawMaskedBorderExt_FIELD(int draw_target)
541 if (global.border_status >= GAME_MODE_MAIN &&
542 global.border_status <= GAME_MODE_PLAYING &&
543 border.draw_masked[global.border_status])
544 DrawMaskedBorderExt_Rect(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
548 static void DrawMaskedBorderExt_DOOR_1(int draw_target)
550 // when drawing to backbuffer, never draw border over open doors
551 if (draw_target == DRAW_TO_BACKBUFFER &&
552 (GetDoorState() & DOOR_OPEN_1))
555 if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
556 (global.border_status != GAME_MODE_EDITOR ||
557 border.draw_masked[GFX_SPECIAL_ARG_EDITOR]))
558 DrawMaskedBorderExt_Rect(DX, DY, DXSIZE, DYSIZE, draw_target);
561 static void DrawMaskedBorderExt_DOOR_2(int draw_target)
563 // when drawing to backbuffer, never draw border over open doors
564 if (draw_target == DRAW_TO_BACKBUFFER &&
565 (GetDoorState() & DOOR_OPEN_2))
568 if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
569 global.border_status != GAME_MODE_EDITOR)
570 DrawMaskedBorderExt_Rect(VX, VY, VXSIZE, VYSIZE, draw_target);
573 static void DrawMaskedBorderExt_DOOR_3(int draw_target)
575 // currently not available
578 static void DrawMaskedBorderExt_ALL(int draw_target)
580 DrawMaskedBorderExt_FIELD(draw_target);
581 DrawMaskedBorderExt_DOOR_1(draw_target);
582 DrawMaskedBorderExt_DOOR_2(draw_target);
583 DrawMaskedBorderExt_DOOR_3(draw_target);
586 static void DrawMaskedBorderExt(int redraw_mask, int draw_target)
588 // never draw masked screen borders on borderless screens
589 if (global.border_status == GAME_MODE_LOADING ||
590 global.border_status == GAME_MODE_TITLE)
593 if (redraw_mask & REDRAW_ALL)
594 DrawMaskedBorderExt_ALL(draw_target);
597 if (redraw_mask & REDRAW_FIELD)
598 DrawMaskedBorderExt_FIELD(draw_target);
599 if (redraw_mask & REDRAW_DOOR_1)
600 DrawMaskedBorderExt_DOOR_1(draw_target);
601 if (redraw_mask & REDRAW_DOOR_2)
602 DrawMaskedBorderExt_DOOR_2(draw_target);
603 if (redraw_mask & REDRAW_DOOR_3)
604 DrawMaskedBorderExt_DOOR_3(draw_target);
608 void DrawMaskedBorder_FIELD(void)
610 DrawMaskedBorderExt_FIELD(DRAW_TO_BACKBUFFER);
613 void DrawMaskedBorder(int redraw_mask)
615 DrawMaskedBorderExt(redraw_mask, DRAW_TO_BACKBUFFER);
618 void DrawMaskedBorderToTarget(int draw_target)
620 if (draw_target == DRAW_TO_BACKBUFFER ||
621 draw_target == DRAW_TO_SCREEN)
623 DrawMaskedBorderExt(REDRAW_ALL, draw_target);
627 int last_border_status = global.border_status;
629 if (draw_target == DRAW_TO_FADE_SOURCE)
631 global.border_status = gfx.fade_border_source_status;
632 gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_source;
634 else if (draw_target == DRAW_TO_FADE_TARGET)
636 global.border_status = gfx.fade_border_target_status;
637 gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_target;
640 // always use global border for PLAYING when restarting the game
641 if (global.border_status == GAME_MODE_PSEUDO_RESTARTING)
642 global.border_status = GAME_MODE_PLAYING;
644 DrawMaskedBorderExt(REDRAW_ALL, draw_target);
646 global.border_status = last_border_status;
647 gfx.masked_border_bitmap_ptr = backbuffer;
651 void DrawTileCursor(int draw_target, int drawing_stage)
653 int tile_cursor_active = (game_status == GAME_MODE_PLAYING);
655 DrawTileCursor_MM(draw_target, drawing_stage, tile_cursor_active);
658 void BlitScreenToBitmapExt_RND(Bitmap *target_bitmap, int fx, int fy)
660 BlitBitmap(drawto_field, target_bitmap, fx, fy, SXSIZE, SYSIZE, SX, SY);
663 void BlitScreenToBitmap_RND(Bitmap *target_bitmap)
665 int fx = getFieldbufferOffsetX_RND(ScreenMovDir, ScreenGfxPos);
666 int fy = getFieldbufferOffsetY_RND(ScreenMovDir, ScreenGfxPos);
668 BlitScreenToBitmapExt_RND(target_bitmap, fx, fy);
671 void BlitScreenToBitmap(Bitmap *target_bitmap)
673 if (level.game_engine_type == GAME_ENGINE_TYPE_BD)
674 BlitScreenToBitmap_BD(target_bitmap);
675 else if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
676 BlitScreenToBitmap_EM(target_bitmap);
677 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
678 BlitScreenToBitmap_SP(target_bitmap);
679 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
680 BlitScreenToBitmap_MM(target_bitmap);
681 else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
682 BlitScreenToBitmap_RND(target_bitmap);
684 redraw_mask |= REDRAW_FIELD;
687 static void DrawFramesPerSecond(void)
690 int font_nr = FONT_TEXT_2;
691 int font_width = getFontWidth(font_nr);
692 int draw_deactivation_mask = GetDrawDeactivationMask();
693 boolean draw_masked = (draw_deactivation_mask == REDRAW_NONE);
695 // draw FPS with leading space (needed if field buffer deactivated)
696 sprintf(text, " %04.1f fps", global.frames_per_second);
698 // override draw deactivation mask (required for invisible warp mode)
699 SetDrawDeactivationMask(REDRAW_NONE);
701 // draw opaque FPS if field buffer deactivated, else draw masked FPS
702 DrawTextExt(backbuffer, SX + SXSIZE - font_width * strlen(text), SY, text,
703 font_nr, (draw_masked ? BLIT_MASKED : BLIT_OPAQUE));
705 // set draw deactivation mask to previous value
706 SetDrawDeactivationMask(draw_deactivation_mask);
708 // force full-screen redraw in this frame
709 redraw_mask = REDRAW_ALL;
713 static void PrintFrameTimeDebugging(void)
715 static unsigned int last_counter = 0;
716 unsigned int counter = Counter();
717 int diff_1 = counter - last_counter;
718 int diff_2 = diff_1 - GAME_FRAME_DELAY;
720 int diff_2_cut = MIN(ABS(diff_2), diff_2_max);
721 char diff_bar[2 * diff_2_max + 5];
725 diff_bar[pos++] = (diff_2 < -diff_2_max ? '<' : ' ');
727 for (i = 0; i < diff_2_max; i++)
728 diff_bar[pos++] = (diff_2 >= 0 ? ' ' :
729 i >= diff_2_max - diff_2_cut ? '-' : ' ');
731 diff_bar[pos++] = '|';
733 for (i = 0; i < diff_2_max; i++)
734 diff_bar[pos++] = (diff_2 <= 0 ? ' ' : i < diff_2_cut ? '+' : ' ');
736 diff_bar[pos++] = (diff_2 > diff_2_max ? '>' : ' ');
738 diff_bar[pos++] = '\0';
740 Debug("time:frame", "%06d [%02d] [%c%02d] %s",
743 (diff_2 < 0 ? '-' : diff_2 > 0 ? '+' : ' '), ABS(diff_2),
746 last_counter = counter;
750 static int unifiedRedrawMask(int mask)
752 if (mask & REDRAW_ALL)
755 if (mask & REDRAW_FIELD && mask & REDRAW_DOORS)
761 static boolean equalRedrawMasks(int mask_1, int mask_2)
763 return unifiedRedrawMask(mask_1) == unifiedRedrawMask(mask_2);
766 void BackToFront(void)
768 static int last_redraw_mask = REDRAW_NONE;
770 // force screen redraw in every frame to continue drawing global animations
771 // (but always use the last redraw mask to prevent unwanted side effects)
772 if (redraw_mask == REDRAW_NONE)
773 redraw_mask = last_redraw_mask;
775 last_redraw_mask = redraw_mask;
778 // masked border now drawn immediately when blitting backbuffer to window
780 // draw masked border to all viewports, if defined
781 DrawMaskedBorder(redraw_mask);
784 // draw frames per second (only if debug mode is enabled)
785 if (redraw_mask & REDRAW_FPS)
786 DrawFramesPerSecond();
788 // remove playfield redraw before potentially merging with doors redraw
789 if (DrawingDeactivated(REAL_SX, REAL_SY))
790 redraw_mask &= ~REDRAW_FIELD;
792 // redraw complete window if both playfield and (some) doors need redraw
793 if (redraw_mask & REDRAW_FIELD && redraw_mask & REDRAW_DOORS)
794 redraw_mask = REDRAW_ALL;
796 /* although redrawing the whole window would be fine for normal gameplay,
797 being able to only redraw the playfield is required for deactivating
798 certain drawing areas (mainly playfield) to work, which is needed for
799 warp-forward to be fast enough (by skipping redraw of most frames) */
801 if (redraw_mask & REDRAW_ALL)
803 BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
805 else if (redraw_mask & REDRAW_FIELD)
807 BlitBitmap(backbuffer, window,
808 REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
810 else if (redraw_mask & REDRAW_DOORS)
812 // merge door areas to prevent calling screen redraw more than once
818 if (redraw_mask & REDRAW_DOOR_1)
822 x2 = MAX(x2, DX + DXSIZE);
823 y2 = MAX(y2, DY + DYSIZE);
826 if (redraw_mask & REDRAW_DOOR_2)
830 x2 = MAX(x2, VX + VXSIZE);
831 y2 = MAX(y2, VY + VYSIZE);
834 if (redraw_mask & REDRAW_DOOR_3)
838 x2 = MAX(x2, EX + EXSIZE);
839 y2 = MAX(y2, EY + EYSIZE);
842 // make sure that at least one pixel is blitted, and inside the screen
843 // (else nothing is blitted, causing the animations not to be updated)
844 x1 = MIN(MAX(0, x1), WIN_XSIZE - 1);
845 y1 = MIN(MAX(0, y1), WIN_YSIZE - 1);
846 x2 = MIN(MAX(1, x2), WIN_XSIZE);
847 y2 = MIN(MAX(1, y2), WIN_YSIZE);
849 BlitBitmap(backbuffer, window, x1, y1, x2 - x1, y2 - y1, x1, y1);
852 redraw_mask = REDRAW_NONE;
855 PrintFrameTimeDebugging();
859 void BackToFront_WithFrameDelay(unsigned int frame_delay_value)
861 unsigned int frame_delay_value_old = GetVideoFrameDelay();
863 SetVideoFrameDelay(frame_delay_value);
867 SetVideoFrameDelay(frame_delay_value_old);
870 static int fade_type_skip = FADE_TYPE_NONE;
872 static void FadeExt(int fade_mask, int fade_mode, int fade_type)
874 void (*draw_border_function)(void) = NULL;
875 int x, y, width, height;
876 int fade_delay, post_delay;
878 if (fade_type == FADE_TYPE_FADE_OUT)
880 if (fade_type_skip != FADE_TYPE_NONE)
882 // skip all fade operations until specified fade operation
883 if (fade_type & fade_type_skip)
884 fade_type_skip = FADE_TYPE_NONE;
889 if (fading.fade_mode & FADE_TYPE_TRANSFORM)
893 redraw_mask |= fade_mask;
895 if (fade_type == FADE_TYPE_SKIP)
897 fade_type_skip = fade_mode;
902 fade_delay = fading.fade_delay;
903 post_delay = (fade_mode == FADE_MODE_FADE_OUT ? fading.post_delay : 0);
905 if (fade_type_skip != FADE_TYPE_NONE)
907 // skip all fade operations until specified fade operation
908 if (fade_type & fade_type_skip)
909 fade_type_skip = FADE_TYPE_NONE;
914 if (global.autoplay_leveldir)
919 if (fade_mask == REDRAW_FIELD)
924 height = FADE_SYSIZE;
926 if (border.draw_masked_when_fading)
927 draw_border_function = DrawMaskedBorder_FIELD; // update when fading
929 DrawMaskedBorder_FIELD(); // draw once
939 // when switching screens without fading, set fade delay to zero
940 if (!setup.fade_screens || fading.fade_mode == FADE_MODE_NONE)
943 // do not display black frame when fading out without fade delay
944 if (fade_mode == FADE_MODE_FADE_OUT && fade_delay == 0)
947 FadeRectangle(x, y, width, height, fade_mode, fade_delay, post_delay,
948 draw_border_function);
950 redraw_mask &= ~fade_mask;
952 ClearAutoRepeatKeyEvents();
955 static void SetScreenStates_BeforeFadingIn(void)
957 // temporarily set screen mode for animations to screen after fading in
958 global.anim_status = global.anim_status_next;
960 // store backbuffer with all animations that will be started after fading in
961 PrepareFadeBitmap(DRAW_TO_FADE_TARGET);
963 // set screen mode for animations back to fading
964 global.anim_status = GAME_MODE_PSEUDO_FADING;
967 static void SetScreenStates_AfterFadingIn(void)
969 // store new source screen (to use correct masked border for fading)
970 gfx.fade_border_source_status = global.border_status;
972 global.anim_status = global.anim_status_next;
975 static void SetScreenStates_BeforeFadingOut(void)
977 // store new target screen (to use correct masked border for fading)
978 gfx.fade_border_target_status = game_status;
980 // set screen mode for animations to fading
981 global.anim_status = GAME_MODE_PSEUDO_FADING;
983 // store backbuffer with all animations that will be stopped for fading out
984 PrepareFadeBitmap(DRAW_TO_FADE_SOURCE);
987 static void SetScreenStates_AfterFadingOut(void)
989 global.border_status = game_status;
991 // always use global border for PLAYING when restarting the game
992 if (global.border_status == GAME_MODE_PSEUDO_RESTARTING)
993 global.border_status = GAME_MODE_PLAYING;
996 void FadeIn(int fade_mask)
998 SetScreenStates_BeforeFadingIn();
1001 DrawMaskedBorder(REDRAW_ALL);
1004 if (fading.fade_mode & FADE_TYPE_TRANSFORM)
1005 FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_IN);
1007 FadeExt(fade_mask, FADE_MODE_FADE_IN, FADE_TYPE_FADE_IN);
1011 FADE_SXSIZE = FULL_SXSIZE;
1012 FADE_SYSIZE = FULL_SYSIZE;
1014 // activate virtual buttons depending on upcoming game status
1015 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS) &&
1016 game_status == GAME_MODE_PLAYING && !tape.playing)
1017 SetOverlayActive(TRUE);
1019 SetScreenStates_AfterFadingIn();
1021 // force update of global animation status in case of rapid screen changes
1022 redraw_mask = REDRAW_ALL;
1026 void FadeOut(int fade_mask)
1028 // update screen if areas covered by "fade_mask" and "redraw_mask" differ
1029 if (!equalRedrawMasks(fade_mask, redraw_mask) &&
1030 fade_type_skip != FADE_MODE_SKIP_FADE_OUT)
1033 // when using BD game engine, cover playfield before fading out after a game
1034 if (game_bd.cover_screen)
1037 SetScreenStates_BeforeFadingOut();
1039 SetTileCursorActive(FALSE);
1040 SetOverlayActive(FALSE);
1043 DrawMaskedBorder(REDRAW_ALL);
1046 if (fading.fade_mode & FADE_TYPE_TRANSFORM)
1047 FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_OUT);
1049 FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
1051 SetScreenStates_AfterFadingOut();
1054 static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
1056 static struct TitleFadingInfo fading_leave_stored;
1059 fading_leave_stored = fading_leave;
1061 fading = fading_leave_stored;
1064 void FadeSetEnterMenu(void)
1066 fading = menu.enter_menu;
1068 FadeSetLeaveNext(fading, TRUE); // (keep same fade mode)
1071 void FadeSetLeaveMenu(void)
1073 fading = menu.leave_menu;
1075 FadeSetLeaveNext(fading, TRUE); // (keep same fade mode)
1078 void FadeSetEnterScreen(void)
1080 fading = menu.enter_screen[game_status];
1082 FadeSetLeaveNext(menu.leave_screen[game_status], TRUE); // store
1085 void FadeSetNextScreen(void)
1087 fading = menu.next_screen[game_status];
1089 // (do not overwrite fade mode set by FadeSetEnterScreen)
1090 // FadeSetLeaveNext(fading, TRUE); // (keep same fade mode)
1093 void FadeSetLeaveScreen(void)
1095 FadeSetLeaveNext(menu.leave_screen[game_status], FALSE); // recall
1098 void FadeSetFromType(int type)
1100 if (type & TYPE_ENTER_SCREEN)
1101 FadeSetEnterScreen();
1102 else if (type & TYPE_ENTER)
1104 else if (type & TYPE_LEAVE)
1108 void FadeSetDisabled(void)
1110 static struct TitleFadingInfo fading_none = { FADE_MODE_NONE, -1, -1, -1 };
1112 fading = fading_none;
1115 void FadeSkipNextFadeIn(void)
1117 FadeExt(0, FADE_MODE_SKIP_FADE_IN, FADE_TYPE_SKIP);
1120 void FadeSkipNextFadeOut(void)
1122 FadeExt(0, FADE_MODE_SKIP_FADE_OUT, FADE_TYPE_SKIP);
1125 static int getGlobalGameStatus(int status)
1127 return (status == GAME_MODE_PSEUDO_TYPENAME ? GAME_MODE_MAIN :
1128 status == GAME_MODE_SCOREINFO ? GAME_MODE_SCORES :
1132 int getImageFromGraphicOrDefault(int graphic, int default_graphic)
1134 if (graphic == IMG_UNDEFINED)
1135 return IMG_UNDEFINED;
1137 boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
1139 return (graphic_info[graphic].bitmap != NULL || redefined ?
1140 graphic : default_graphic);
1143 static int getBackgroundImage(int graphic)
1145 return getImageFromGraphicOrDefault(graphic, IMG_BACKGROUND);
1148 static int getGlobalBorderImage(int graphic)
1150 return getImageFromGraphicOrDefault(graphic, IMG_GLOBAL_BORDER);
1153 Bitmap *getGlobalBorderBitmapFromStatus(int status_raw)
1155 int status = getGlobalGameStatus(status_raw);
1157 (status == GAME_MODE_MAIN ? IMG_GLOBAL_BORDER_MAIN :
1158 status == GAME_MODE_SCORES ? IMG_GLOBAL_BORDER_SCORES :
1159 status == GAME_MODE_EDITOR ? IMG_GLOBAL_BORDER_EDITOR :
1160 status == GAME_MODE_PLAYING ? IMG_GLOBAL_BORDER_PLAYING :
1162 int graphic_final = getGlobalBorderImage(graphic);
1164 return graphic_info[graphic_final].bitmap;
1167 void SetBackgroundImage(int graphic, int redraw_mask)
1169 struct GraphicInfo *g = &graphic_info[graphic];
1170 struct GraphicInfo g_undefined = { 0 };
1172 if (graphic == IMG_UNDEFINED)
1175 // always use original size bitmap for backgrounds, if existing
1176 Bitmap *bitmap = (g->bitmaps != NULL &&
1177 g->bitmaps[IMG_BITMAP_PTR_ORIGINAL] != NULL ?
1178 g->bitmaps[IMG_BITMAP_PTR_ORIGINAL] : g->bitmap);
1180 // remove every mask before setting mask for window, and
1181 // remove window area mask before setting mask for main or door area
1182 int remove_mask = (redraw_mask == REDRAW_ALL ? 0xffff : REDRAW_ALL);
1184 // (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!)
1185 SetBackgroundBitmap(NULL, remove_mask, 0, 0, 0, 0); // !!! FIX THIS !!!
1186 SetBackgroundBitmap(bitmap, redraw_mask,
1188 g->width, g->height);
1191 void SetWindowBackgroundImageIfDefined(int graphic)
1193 if (graphic_info[graphic].bitmap)
1194 SetBackgroundImage(graphic, REDRAW_ALL);
1197 void SetMainBackgroundImageIfDefined(int graphic)
1199 if (graphic_info[graphic].bitmap)
1200 SetBackgroundImage(graphic, REDRAW_FIELD);
1203 void SetDoorBackgroundImageIfDefined(int graphic)
1205 if (graphic_info[graphic].bitmap)
1206 SetBackgroundImage(graphic, REDRAW_DOOR_1);
1209 void SetWindowBackgroundImage(int graphic)
1211 SetBackgroundImage(getBackgroundImage(graphic), REDRAW_ALL);
1214 void SetMainBackgroundImage(int graphic)
1216 SetBackgroundImage(getBackgroundImage(graphic), REDRAW_FIELD);
1219 void SetDoorBackgroundImage(int graphic)
1221 SetBackgroundImage(getBackgroundImage(graphic), REDRAW_DOOR_1);
1224 void SetPanelBackground(void)
1226 SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
1229 void DrawBackground(int x, int y, int width, int height)
1231 // "drawto" might still point to playfield buffer here (hall of fame)
1232 ClearRectangleOnBackground(backbuffer, x, y, width, height);
1234 if (IN_GFX_FIELD_FULL(x, y))
1235 redraw_mask |= REDRAW_FIELD;
1236 else if (IN_GFX_DOOR_1(x, y))
1237 redraw_mask |= REDRAW_DOOR_1;
1238 else if (IN_GFX_DOOR_2(x, y))
1239 redraw_mask |= REDRAW_DOOR_2;
1240 else if (IN_GFX_DOOR_3(x, y))
1241 redraw_mask |= REDRAW_DOOR_3;
1244 void DrawBackgroundForFont(int x, int y, int width, int height, int font_nr)
1246 struct FontBitmapInfo *font = getFontBitmapInfo(font_nr);
1248 if (font->bitmap == NULL)
1251 DrawBackground(x, y, width, height);
1254 void DrawBackgroundForGraphic(int x, int y, int width, int height, int graphic)
1256 struct GraphicInfo *g = &graphic_info[graphic];
1258 if (g->bitmap == NULL)
1261 DrawBackground(x, y, width, height);
1264 static int game_status_last = -1;
1265 static Bitmap *global_border_bitmap_last = NULL;
1266 static Bitmap *global_border_bitmap = NULL;
1267 static int real_sx_last = -1, real_sy_last = -1;
1268 static int full_sxsize_last = -1, full_sysize_last = -1;
1269 static int dx_last = -1, dy_last = -1;
1270 static int dxsize_last = -1, dysize_last = -1;
1271 static int vx_last = -1, vy_last = -1;
1272 static int vxsize_last = -1, vysize_last = -1;
1273 static int ex_last = -1, ey_last = -1;
1274 static int exsize_last = -1, eysize_last = -1;
1276 boolean CheckIfGlobalBorderHasChanged(void)
1278 // if game status has not changed, global border has not changed either
1279 if (game_status == game_status_last)
1282 // determine and store new global border bitmap for current game status
1283 global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
1285 return (global_border_bitmap_last != global_border_bitmap);
1288 #define ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED 0
1290 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1291 static boolean CheckIfGlobalBorderRedrawIsNeeded(void)
1293 // if game status has not changed, nothing has to be redrawn
1294 if (game_status == game_status_last)
1297 // redraw if last screen was title screen
1298 if (game_status_last == GAME_MODE_TITLE)
1301 // redraw if global screen border has changed
1302 if (CheckIfGlobalBorderHasChanged())
1305 // redraw if position or size of playfield area has changed
1306 if (real_sx_last != REAL_SX || real_sy_last != REAL_SY ||
1307 full_sxsize_last != FULL_SXSIZE || full_sysize_last != FULL_SYSIZE)
1310 // redraw if position or size of door area has changed
1311 if (dx_last != DX || dy_last != DY ||
1312 dxsize_last != DXSIZE || dysize_last != DYSIZE)
1315 // redraw if position or size of tape area has changed
1316 if (vx_last != VX || vy_last != VY ||
1317 vxsize_last != VXSIZE || vysize_last != VYSIZE)
1320 // redraw if position or size of editor area has changed
1321 if (ex_last != EX || ey_last != EY ||
1322 exsize_last != EXSIZE || eysize_last != EYSIZE)
1329 static void RedrawGlobalBorderFromBitmap(Bitmap *bitmap)
1332 BlitBitmap(bitmap, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1334 ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
1337 void RedrawGlobalBorder(void)
1339 Bitmap *bitmap = getGlobalBorderBitmapFromStatus(game_status);
1341 RedrawGlobalBorderFromBitmap(bitmap);
1343 redraw_mask = REDRAW_ALL;
1346 static void RedrawGlobalBorderIfNeeded(void)
1348 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1349 if (game_status == game_status_last)
1353 // copy current draw buffer to later copy back areas that have not changed
1354 if (game_status_last != GAME_MODE_TITLE)
1355 BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
1357 #if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
1358 if (CheckIfGlobalBorderRedrawIsNeeded())
1360 // determine and store new global border bitmap for current game status
1361 global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
1364 // redraw global screen border (or clear, if defined to be empty)
1365 RedrawGlobalBorderFromBitmap(global_border_bitmap);
1367 if (game_status == GAME_MODE_EDITOR)
1368 DrawSpecialEditorDoor();
1370 // copy previous playfield and door areas, if they are defined on both
1371 // previous and current screen and if they still have the same size
1373 if (real_sx_last != -1 && real_sy_last != -1 &&
1374 REAL_SX != -1 && REAL_SY != -1 &&
1375 full_sxsize_last == FULL_SXSIZE && full_sysize_last == FULL_SYSIZE)
1376 BlitBitmap(bitmap_db_store_1, backbuffer,
1377 real_sx_last, real_sy_last, FULL_SXSIZE, FULL_SYSIZE,
1380 if (dx_last != -1 && dy_last != -1 &&
1381 DX != -1 && DY != -1 &&
1382 dxsize_last == DXSIZE && dysize_last == DYSIZE)
1383 BlitBitmap(bitmap_db_store_1, backbuffer,
1384 dx_last, dy_last, DXSIZE, DYSIZE, DX, DY);
1386 if (game_status != GAME_MODE_EDITOR)
1388 if (vx_last != -1 && vy_last != -1 &&
1389 VX != -1 && VY != -1 &&
1390 vxsize_last == VXSIZE && vysize_last == VYSIZE)
1391 BlitBitmap(bitmap_db_store_1, backbuffer,
1392 vx_last, vy_last, VXSIZE, VYSIZE, VX, VY);
1396 if (ex_last != -1 && ey_last != -1 &&
1397 EX != -1 && EY != -1 &&
1398 exsize_last == EXSIZE && eysize_last == EYSIZE)
1399 BlitBitmap(bitmap_db_store_1, backbuffer,
1400 ex_last, ey_last, EXSIZE, EYSIZE, EX, EY);
1403 redraw_mask = REDRAW_ALL;
1406 game_status_last = game_status;
1408 global_border_bitmap_last = global_border_bitmap;
1410 real_sx_last = REAL_SX;
1411 real_sy_last = REAL_SY;
1412 full_sxsize_last = FULL_SXSIZE;
1413 full_sysize_last = FULL_SYSIZE;
1416 dxsize_last = DXSIZE;
1417 dysize_last = DYSIZE;
1420 vxsize_last = VXSIZE;
1421 vysize_last = VYSIZE;
1424 exsize_last = EXSIZE;
1425 eysize_last = EYSIZE;
1428 void ClearField(void)
1430 RedrawGlobalBorderIfNeeded();
1432 // !!! "drawto" might still point to playfield buffer here (see above) !!!
1433 // (when entering hall of fame after playing)
1434 DrawBackground(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
1436 // !!! maybe this should be done before clearing the background !!!
1437 if (game_status == GAME_MODE_PLAYING)
1439 ClearRectangle(fieldbuffer, 0, 0, FXSIZE, FYSIZE);
1440 SetDrawtoField(DRAW_TO_FIELDBUFFER);
1444 SetDrawtoField(DRAW_TO_BACKBUFFER);
1448 void MarkTileDirty(int x, int y)
1450 redraw_mask |= REDRAW_FIELD;
1453 void SetBorderElement(void)
1457 BorderElement = EL_EMPTY;
1459 // only the R'n'D game engine may use an additional steelwall border
1460 if (level.game_engine_type != GAME_ENGINE_TYPE_RND)
1463 for (y = 0; y < lev_fieldy && BorderElement == EL_EMPTY; y++)
1465 for (x = 0; x < lev_fieldx; x++)
1467 if (!IS_INDESTRUCTIBLE(Tile[x][y]))
1468 BorderElement = EL_STEELWALL;
1470 if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
1476 void FloodFillLevelExt(int start_x, int start_y, int fill_element,
1477 int max_array_fieldx, int max_array_fieldy,
1478 short field[max_array_fieldx][max_array_fieldy],
1479 int max_fieldx, int max_fieldy)
1481 static struct XY stack_buffer[MAX_LEV_FIELDX * MAX_LEV_FIELDY];
1482 struct XY *check = xy_topdown;
1483 int old_element = field[start_x][start_y];
1486 // do nothing if start field already has the desired content
1487 if (old_element == fill_element)
1490 stack_buffer[stack_pos++] = (struct XY){ start_x, start_y };
1492 while (stack_pos > 0)
1494 struct XY current = stack_buffer[--stack_pos];
1497 field[current.x][current.y] = fill_element;
1499 for (i = 0; i < 4; i++)
1501 int x = current.x + check[i].x;
1502 int y = current.y + check[i].y;
1504 // check for stack buffer overflow (should not happen)
1505 if (stack_pos >= MAX_LEV_FIELDX * MAX_LEV_FIELDY)
1506 Fail("Stack buffer overflow in 'FloodFillLevelExt()'. Please debug.");
1508 if (IN_FIELD(x, y, max_fieldx, max_fieldy) && field[x][y] == old_element)
1509 stack_buffer[stack_pos++] = (struct XY){ x, y };
1514 void FloodFillLevel(int from_x, int from_y, int fill_element,
1515 short field[MAX_LEV_FIELDX][MAX_LEV_FIELDY],
1516 int max_fieldx, int max_fieldy)
1518 FloodFillLevelExt(from_x, from_y, fill_element,
1519 MAX_LEV_FIELDX, MAX_LEV_FIELDY, field,
1520 max_fieldx, max_fieldy);
1523 void SetRandomAnimationValue(int x, int y)
1525 gfx.anim_random_frame = GfxRandom[x][y];
1528 void SetAnimationFirstLevel(int first_level)
1530 gfx.anim_first_level = first_level;
1533 int getGraphicAnimationFrame(int graphic, int sync_frame)
1535 // animation synchronized with global frame counter, not move position
1536 if (graphic_info[graphic].anim_global_sync || sync_frame < 0)
1537 sync_frame = FrameCounter;
1538 else if (graphic_info[graphic].anim_global_anim_sync)
1539 sync_frame = getGlobalAnimSyncFrame();
1541 return getAnimationFrame(graphic_info[graphic].anim_frames,
1542 graphic_info[graphic].anim_delay,
1543 graphic_info[graphic].anim_mode,
1544 graphic_info[graphic].anim_start_frame,
1548 int getGraphicAnimationFrameXY(int graphic, int lx, int ly)
1550 if (graphic_info[graphic].anim_mode & ANIM_TILED)
1552 struct GraphicInfo *g = &graphic_info[graphic];
1553 int xsize = MAX(1, g->anim_frames_per_line);
1554 int ysize = MAX(1, g->anim_frames / xsize);
1555 int xoffset = g->anim_start_frame % xsize;
1556 int yoffset = g->anim_start_frame % ysize;
1557 // may be needed if screen field is significantly larger than playfield
1558 int x = (lx + xoffset + SCR_FIELDX * xsize) % xsize;
1559 int y = (ly + yoffset + SCR_FIELDY * ysize) % ysize;
1560 int sync_frame = y * xsize + x;
1562 return sync_frame % g->anim_frames;
1564 else if (graphic_info[graphic].anim_mode & ANIM_RANDOM_STATIC)
1566 struct GraphicInfo *g = &graphic_info[graphic];
1567 // may be needed if screen field is significantly larger than playfield
1568 int x = (lx + SCR_FIELDX * lev_fieldx) % lev_fieldx;
1569 int y = (ly + SCR_FIELDY * lev_fieldy) % lev_fieldy;
1570 int sync_frame = GfxRandomStatic[x][y];
1572 return sync_frame % g->anim_frames;
1576 int sync_frame = (IN_LEV_FIELD(lx, ly) ? GfxFrame[lx][ly] : -1);
1578 return getGraphicAnimationFrame(graphic, sync_frame);
1582 void getGraphicSourceBitmap(int graphic, int tilesize, Bitmap **bitmap)
1584 struct GraphicInfo *g = &graphic_info[graphic];
1585 int tilesize_capped = MIN(MAX(1, tilesize), TILESIZE);
1587 if (tilesize == gfx.standard_tile_size)
1588 *bitmap = g->bitmaps[IMG_BITMAP_STANDARD];
1589 else if (tilesize == game.tile_size)
1590 *bitmap = g->bitmaps[IMG_BITMAP_PTR_GAME];
1592 *bitmap = g->bitmaps[IMG_BITMAP_1x1 - log_2(tilesize_capped)];
1595 void getGraphicSourceXY(int graphic, int frame, int *x, int *y,
1596 boolean get_backside)
1598 struct GraphicInfo *g = &graphic_info[graphic];
1599 int src_x = g->src_x + (get_backside ? g->offset2_x : 0);
1600 int src_y = g->src_y + (get_backside ? g->offset2_y : 0);
1602 if (g->offset_y == 0) // frames are ordered horizontally
1604 int max_width = g->anim_frames_per_line * g->width;
1605 int pos = (src_y / g->height) * max_width + src_x + frame * g->offset_x;
1607 *x = pos % max_width;
1608 *y = src_y % g->height + pos / max_width * g->height;
1610 else if (g->offset_x == 0) // frames are ordered vertically
1612 int max_height = g->anim_frames_per_line * g->height;
1613 int pos = (src_x / g->width) * max_height + src_y + frame * g->offset_y;
1615 *x = src_x % g->width + pos / max_height * g->width;
1616 *y = pos % max_height;
1618 else // frames are ordered diagonally
1620 *x = src_x + frame * g->offset_x;
1621 *y = src_y + frame * g->offset_y;
1625 void getSizedGraphicSourceExt(int graphic, int frame, int tilesize,
1626 Bitmap **bitmap, int *x, int *y,
1627 boolean get_backside)
1629 struct GraphicInfo *g = &graphic_info[graphic];
1631 // if no graphics defined at all, use fallback graphics
1632 if (g->bitmaps == NULL)
1633 *g = graphic_info[IMG_CHAR_EXCLAM];
1635 // if no in-game graphics defined, always use standard graphic size
1636 if (g->bitmaps[IMG_BITMAP_PTR_GAME] == NULL)
1637 tilesize = TILESIZE;
1639 getGraphicSourceBitmap(graphic, tilesize, bitmap);
1640 getGraphicSourceXY(graphic, frame, x, y, get_backside);
1642 *x = *x * tilesize / g->tile_size;
1643 *y = *y * tilesize / g->tile_size;
1646 void getSizedGraphicSource(int graphic, int frame, int tilesize,
1647 Bitmap **bitmap, int *x, int *y)
1649 getSizedGraphicSourceExt(graphic, frame, tilesize, bitmap, x, y, FALSE);
1652 void getFixedGraphicSource(int graphic, int frame,
1653 Bitmap **bitmap, int *x, int *y)
1655 getSizedGraphicSourceExt(graphic, frame, TILESIZE, bitmap, x, y, FALSE);
1658 void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
1660 getSizedGraphicSource(graphic, 0, MINI_TILESIZE, bitmap, x, y);
1663 void getGlobalAnimGraphicSource(int graphic, int frame,
1664 Bitmap **bitmap, int *x, int *y)
1666 struct GraphicInfo *g = &graphic_info[graphic];
1668 // if no graphics defined at all, use fallback graphics
1669 if (g->bitmaps == NULL)
1670 *g = graphic_info[IMG_CHAR_EXCLAM];
1672 // use original size graphics, if existing, else use standard size graphics
1673 if (g->bitmaps[IMG_BITMAP_PTR_ORIGINAL])
1674 *bitmap = g->bitmaps[IMG_BITMAP_PTR_ORIGINAL];
1676 *bitmap = g->bitmaps[IMG_BITMAP_STANDARD];
1678 getGraphicSourceXY(graphic, frame, x, y, FALSE);
1681 static void getGraphicSourceExt(int graphic, int frame, Bitmap **bitmap,
1682 int *x, int *y, boolean get_backside)
1684 getSizedGraphicSourceExt(graphic, frame, TILESIZE_VAR, bitmap, x, y,
1688 void getGraphicSource(int graphic, int frame, Bitmap **bitmap, int *x, int *y)
1690 getGraphicSourceExt(graphic, frame, bitmap, x, y, FALSE);
1693 void DrawGraphic(int x, int y, int graphic, int frame)
1696 if (!IN_SCR_FIELD(x, y))
1698 Debug("draw:DrawGraphic", "x = %d, y = %d, graphic = %d", x, y, graphic);
1699 Debug("draw:DrawGraphic", "This should never happen!");
1705 DrawGraphicExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR, graphic,
1708 MarkTileDirty(x, y);
1711 void DrawFixedGraphic(int x, int y, int graphic, int frame)
1714 if (!IN_SCR_FIELD(x, y))
1716 Debug("draw:DrawFixedGraphic", "x = %d, y = %d, graphic = %d",
1718 Debug("draw:DrawFixedGraphic", "This should never happen!");
1724 DrawFixedGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic,
1726 MarkTileDirty(x, y);
1729 void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1735 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1737 BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX_VAR, TILEY_VAR, x, y);
1740 void DrawFixedGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic,
1746 getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1747 BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y);
1750 void DrawGraphicThruMask(int x, int y, int graphic, int frame)
1753 if (!IN_SCR_FIELD(x, y))
1755 Debug("draw:DrawGraphicThruMask", "x = %d, y = %d, graphic = %d",
1757 Debug("draw:DrawGraphicThruMask", "This should never happen!");
1763 DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
1766 MarkTileDirty(x, y);
1769 void DrawFixedGraphicThruMask(int x, int y, int graphic, int frame)
1772 if (!IN_SCR_FIELD(x, y))
1774 Debug("draw:DrawFixedGraphicThruMask", "x = %d, y = %d, graphic = %d",
1776 Debug("draw:DrawFixedGraphicThruMask", "This should never happen!");
1782 DrawFixedGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
1784 MarkTileDirty(x, y);
1787 void DrawGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y, int graphic,
1793 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1795 BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX_VAR, TILEY_VAR,
1799 void DrawFixedGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y,
1800 int graphic, int frame)
1805 getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1807 BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY,
1811 void DrawSizedGraphic(int x, int y, int graphic, int frame, int tilesize)
1813 DrawSizedGraphicExt(drawto, SX + x * tilesize, SY + y * tilesize, graphic,
1815 MarkTileDirty(x / tilesize, y / tilesize);
1818 void DrawSizedGraphicThruMask(int x, int y, int graphic, int frame,
1821 DrawSizedGraphicThruMaskExt(drawto, SX + x * tilesize, SY + y * tilesize,
1822 graphic, frame, tilesize);
1823 MarkTileDirty(x / tilesize, y / tilesize);
1826 void DrawSizedGraphicExt(DrawBuffer *d, int x, int y, int graphic, int frame,
1832 getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1833 BlitBitmap(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1836 void DrawSizedGraphicThruMaskExt(DrawBuffer *d, int x, int y, int graphic,
1837 int frame, int tilesize)
1842 getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y);
1843 BlitBitmapMasked(src_bitmap, d, src_x, src_y, tilesize, tilesize, x, y);
1846 void DrawMiniGraphic(int x, int y, int graphic)
1848 DrawMiniGraphicExt(drawto, SX + x * MINI_TILEX, SY + y * MINI_TILEY, graphic);
1849 MarkTileDirty(x / 2, y / 2);
1852 void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic)
1857 getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
1858 BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
1861 static void DrawGraphicShiftedNormal(int x, int y, int dx, int dy,
1862 int graphic, int frame,
1863 int cut_mode, int mask_mode)
1868 int width = TILEX, height = TILEY;
1871 if (dx || dy) // shifted graphic
1873 if (x < BX1) // object enters playfield from the left
1880 else if (x > BX2) // object enters playfield from the right
1886 else if (x == BX1 && dx < 0) // object leaves playfield to the left
1892 else if (x == BX2 && dx > 0) // object leaves playfield to the right
1894 else if (dx) // general horizontal movement
1895 MarkTileDirty(x + SIGN(dx), y);
1897 if (y < BY1) // object enters playfield from the top
1899 if (cut_mode == CUT_BELOW) // object completely above top border
1907 else if (y > BY2) // object enters playfield from the bottom
1913 else if (y == BY1 && dy < 0) // object leaves playfield to the top
1919 else if (dy > 0 && cut_mode == CUT_ABOVE)
1921 if (y == BY2) // object completely above bottom border
1927 MarkTileDirty(x, y + 1);
1928 } // object leaves playfield to the bottom
1929 else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
1931 else if (dy) // general vertical movement
1932 MarkTileDirty(x, y + SIGN(dy));
1936 if (!IN_SCR_FIELD(x, y))
1938 Debug("draw:DrawGraphicShiftedNormal", "x = %d, y = %d, graphic = %d",
1940 Debug("draw:DrawGraphicShiftedNormal", "This should never happen!");
1946 width = width * TILESIZE_VAR / TILESIZE;
1947 height = height * TILESIZE_VAR / TILESIZE;
1948 cx = cx * TILESIZE_VAR / TILESIZE;
1949 cy = cy * TILESIZE_VAR / TILESIZE;
1950 dx = dx * TILESIZE_VAR / TILESIZE;
1951 dy = dy * TILESIZE_VAR / TILESIZE;
1953 if (width > 0 && height > 0)
1955 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
1960 dst_x = FX + x * TILEX_VAR + dx;
1961 dst_y = FY + y * TILEY_VAR + dy;
1963 if (mask_mode == USE_MASKING)
1964 BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
1967 BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
1970 MarkTileDirty(x, y);
1974 static void DrawGraphicShiftedDouble(int x, int y, int dx, int dy,
1975 int graphic, int frame,
1976 int cut_mode, int mask_mode)
1981 int width = TILEX_VAR, height = TILEY_VAR;
1984 int x2 = x + SIGN(dx);
1985 int y2 = y + SIGN(dy);
1987 // movement with two-tile animations must be sync'ed with movement position,
1988 // not with current GfxFrame (which can be higher when using slow movement)
1989 int anim_pos = (dx ? ABS(dx) : ABS(dy));
1990 int anim_frames = graphic_info[graphic].anim_frames;
1992 // (we also need anim_delay here for movement animations with less frames)
1993 int anim_delay = graphic_info[graphic].anim_delay;
1994 int sync_frame = anim_pos * anim_frames * anim_delay / TILESIZE;
1996 boolean draw_start_tile = (cut_mode != CUT_ABOVE); // only for falling!
1997 boolean draw_end_tile = (cut_mode != CUT_BELOW); // only for falling!
1999 // re-calculate animation frame for two-tile movement animation
2000 frame = getGraphicAnimationFrame(graphic, sync_frame);
2002 // check if movement start graphic inside screen area and should be drawn
2003 if (draw_start_tile && IN_SCR_FIELD(x1, y1))
2005 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, TRUE);
2007 dst_x = FX + x1 * TILEX_VAR;
2008 dst_y = FY + y1 * TILEY_VAR;
2010 if (mask_mode == USE_MASKING)
2011 BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
2014 BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
2017 MarkTileDirty(x1, y1);
2020 // check if movement end graphic inside screen area and should be drawn
2021 if (draw_end_tile && IN_SCR_FIELD(x2, y2))
2023 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
2025 dst_x = FX + x2 * TILEX_VAR;
2026 dst_y = FY + y2 * TILEY_VAR;
2028 if (mask_mode == USE_MASKING)
2029 BlitBitmapMasked(src_bitmap, drawto_field, src_x, src_y, width, height,
2032 BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height,
2035 MarkTileDirty(x2, y2);
2039 static void DrawGraphicShifted(int x, int y, int dx, int dy,
2040 int graphic, int frame,
2041 int cut_mode, int mask_mode)
2045 DrawGraphic(x, y, graphic, frame);
2050 if (graphic_info[graphic].double_movement) // EM style movement images
2051 DrawGraphicShiftedDouble(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
2053 DrawGraphicShiftedNormal(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
2056 static void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy,
2057 int graphic, int frame, int cut_mode)
2059 DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, USE_MASKING);
2062 void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
2063 int cut_mode, int mask_mode)
2065 int lx = LEVELX(x), ly = LEVELY(y);
2069 if (IN_LEV_FIELD(lx, ly))
2071 if (element == EL_EMPTY)
2072 element = GfxElementEmpty[lx][ly];
2074 SetRandomAnimationValue(lx, ly);
2076 graphic = el_act_dir2img(element, GfxAction[lx][ly], GfxDir[lx][ly]);
2077 frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2079 // do not use double (EM style) movement graphic when not moving
2080 if (graphic_info[graphic].double_movement && !dx && !dy)
2082 graphic = el_act_dir2img(element, ACTION_DEFAULT, GfxDir[lx][ly]);
2083 frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2086 if (game.use_masked_elements && (dx || dy))
2087 mask_mode = USE_MASKING;
2089 else // border element
2091 graphic = el2img(element);
2092 frame = getGraphicAnimationFrameXY(graphic, lx, ly);
2095 if (element == EL_EXPANDABLE_WALL)
2097 boolean left_stopped = FALSE, right_stopped = FALSE;
2099 if (!IN_LEV_FIELD(lx - 1, ly) || IS_WALL(Tile[lx - 1][ly]))
2100 left_stopped = TRUE;
2101 if (!IN_LEV_FIELD(lx + 1, ly) || IS_WALL(Tile[lx + 1][ly]))
2102 right_stopped = TRUE;
2104 if (left_stopped && right_stopped)
2106 else if (left_stopped)
2108 graphic = IMG_EXPANDABLE_WALL_GROWING_RIGHT;
2109 frame = graphic_info[graphic].anim_frames - 1;
2111 else if (right_stopped)
2113 graphic = IMG_EXPANDABLE_WALL_GROWING_LEFT;
2114 frame = graphic_info[graphic].anim_frames - 1;
2119 DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode);
2120 else if (mask_mode == USE_MASKING)
2121 DrawGraphicThruMask(x, y, graphic, frame);
2123 DrawGraphic(x, y, graphic, frame);
2126 void DrawLevelElementExt(int x, int y, int dx, int dy, int element,
2127 int cut_mode, int mask_mode)
2129 if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2130 DrawScreenElementExt(SCREENX(x), SCREENY(y), dx, dy, element,
2131 cut_mode, mask_mode);
2134 void DrawScreenElementShifted(int x, int y, int dx, int dy, int element,
2137 DrawScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
2140 void DrawLevelElementShifted(int x, int y, int dx, int dy, int element,
2143 DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING);
2146 void DrawLevelElementThruMask(int x, int y, int element)
2148 DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
2151 void DrawLevelFieldThruMask(int x, int y)
2153 DrawLevelElementExt(x, y, 0, 0, Tile[x][y], NO_CUTTING, USE_MASKING);
2156 // !!! implementation of quicksand is totally broken !!!
2157 #define IS_CRUMBLED_TILE(x, y, e) \
2158 (GFX_CRUMBLED(e) && (!IN_LEV_FIELD(x, y) || \
2159 !IS_MOVING(x, y) || \
2160 (e) == EL_QUICKSAND_EMPTYING || \
2161 (e) == EL_QUICKSAND_FAST_EMPTYING))
2163 static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy,
2168 int width, height, cx, cy;
2169 int sx = SCREENX(x), sy = SCREENY(y);
2170 int crumbled_border_size = graphic_info[graphic].border_size;
2171 int crumbled_tile_size = graphic_info[graphic].tile_size;
2172 int crumbled_border_size_var =
2173 crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
2176 getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2178 for (i = 1; i < 4; i++)
2180 int dxx = (i & 1 ? dx : 0);
2181 int dyy = (i & 2 ? dy : 0);
2184 int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2187 // check if neighbour field is of same crumble type
2188 boolean same = (IS_CRUMBLED_TILE(xx, yy, element) &&
2189 graphic_info[graphic].class ==
2190 graphic_info[el_act2crm(element, ACTION_DEFAULT)].class);
2192 // return if check prevents inner corner
2193 if (same == (dxx == dx && dyy == dy))
2197 // if we reach this point, we have an inner corner
2199 getGraphicSource(graphic, 1, &src_bitmap, &src_x, &src_y);
2201 width = crumbled_border_size_var;
2202 height = crumbled_border_size_var;
2203 cx = (dx > 0 ? TILESIZE_VAR - width : 0);
2204 cy = (dy > 0 ? TILESIZE_VAR - height : 0);
2206 if (game.use_masked_elements)
2208 int graphic0 = el2img(EL_EMPTY);
2209 int frame0 = getGraphicAnimationFrameXY(graphic0, x, y);
2210 Bitmap *src_bitmap0;
2213 getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
2215 BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
2217 FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2219 BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2221 FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2224 BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2226 FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
2229 static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
2234 int width, height, bx, by, cx, cy;
2235 int sx = SCREENX(x), sy = SCREENY(y);
2236 int crumbled_border_size = graphic_info[graphic].border_size;
2237 int crumbled_tile_size = graphic_info[graphic].tile_size;
2238 int crumbled_border_size_var =
2239 crumbled_border_size * TILESIZE_VAR / crumbled_tile_size;
2240 int crumbled_border_pos_var = TILESIZE_VAR - crumbled_border_size_var;
2243 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2245 // only needed when using masked elements
2246 int graphic0 = el2img(EL_EMPTY);
2247 int frame0 = getGraphicAnimationFrameXY(graphic0, x, y);
2248 Bitmap *src_bitmap0;
2251 if (game.use_masked_elements)
2252 getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
2254 // draw simple, sloppy, non-corner-accurate crumbled border
2256 width = (dir == 1 || dir == 2 ? crumbled_border_size_var : TILESIZE_VAR);
2257 height = (dir == 0 || dir == 3 ? crumbled_border_size_var : TILESIZE_VAR);
2258 cx = (dir == 2 ? crumbled_border_pos_var : 0);
2259 cy = (dir == 3 ? crumbled_border_pos_var : 0);
2261 if (game.use_masked_elements)
2263 BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
2265 FX + sx * TILEX_VAR + cx,
2266 FY + sy * TILEY_VAR + cy);
2268 BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2270 FX + sx * TILEX_VAR + cx,
2271 FY + sy * TILEY_VAR + cy);
2274 BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
2276 FX + sx * TILEX_VAR + cx,
2277 FY + sy * TILEY_VAR + cy);
2279 // (remaining middle border part must be at least as big as corner part)
2280 if (!(graphic_info[graphic].style & STYLE_ACCURATE_BORDERS) ||
2281 crumbled_border_size_var >= TILESIZE_VAR / 3)
2284 // correct corners of crumbled border, if needed
2286 for (i = -1; i <= 1; i += 2)
2288 int xx = x + (dir == 0 || dir == 3 ? i : 0);
2289 int yy = y + (dir == 1 || dir == 2 ? i : 0);
2290 int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2293 // check if neighbour field is of same crumble type
2294 if (IS_CRUMBLED_TILE(xx, yy, element) &&
2295 graphic_info[graphic].class ==
2296 graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2298 // no crumbled corner, but continued crumbled border
2300 int c1 = (dir == 2 || dir == 3 ? crumbled_border_pos_var : 0);
2301 int c2 = (i == 1 ? crumbled_border_pos_var : 0);
2302 int b1 = (i == 1 ? crumbled_border_size_var :
2303 TILESIZE_VAR - 2 * crumbled_border_size_var);
2305 width = crumbled_border_size_var;
2306 height = crumbled_border_size_var;
2308 if (dir == 1 || dir == 2)
2323 if (game.use_masked_elements)
2325 BlitBitmap(src_bitmap0, drawto_field, src_x0 + bx, src_y0 + by,
2327 FX + sx * TILEX_VAR + cx,
2328 FY + sy * TILEY_VAR + cy);
2330 BlitBitmapMasked(src_bitmap, drawto_field, src_x + bx, src_y + by,
2332 FX + sx * TILEX_VAR + cx,
2333 FY + sy * TILEY_VAR + cy);
2336 BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
2338 FX + sx * TILEX_VAR + cx,
2339 FY + sy * TILEY_VAR + cy);
2344 static void DrawLevelFieldCrumbledExt(int x, int y, int graphic, int frame)
2346 int sx = SCREENX(x), sy = SCREENY(y);
2349 struct XY *xy = xy_topdown;
2351 if (!IN_LEV_FIELD(x, y))
2354 element = TILE_GFX_ELEMENT(x, y);
2356 if (IS_CRUMBLED_TILE(x, y, element)) // crumble field itself
2358 if (!IN_SCR_FIELD(sx, sy))
2361 // crumble field borders towards direct neighbour fields
2362 for (i = 0; i < 4; i++)
2364 int xx = x + xy[i].x;
2365 int yy = y + xy[i].y;
2367 element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
2370 // check if neighbour field is of same crumble type
2371 if (IS_CRUMBLED_TILE(xx, yy, element) &&
2372 graphic_info[graphic].class ==
2373 graphic_info[el_act2crm(element, ACTION_DEFAULT)].class)
2376 DrawLevelFieldCrumbledBorders(x, y, graphic, frame, i);
2379 // crumble inner field corners towards corner neighbour fields
2380 if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2381 graphic_info[graphic].anim_frames == 2)
2383 for (i = 0; i < 4; i++)
2385 int dx = (i & 1 ? +1 : -1);
2386 int dy = (i & 2 ? +1 : -1);
2388 DrawLevelFieldCrumbledInnerCorners(x, y, dx, dy, graphic);
2392 MarkTileDirty(sx, sy);
2394 else // center field is not crumbled -- crumble neighbour fields
2396 // crumble field borders of direct neighbour fields
2397 for (i = 0; i < 4; i++)
2399 int xx = x + xy[i].x;
2400 int yy = y + xy[i].y;
2401 int sxx = sx + xy[i].x;
2402 int syy = sy + xy[i].y;
2404 if (!IN_LEV_FIELD(xx, yy) ||
2405 !IN_SCR_FIELD(sxx, syy))
2408 // do not crumble fields that are being digged or snapped
2409 if (Tile[xx][yy] == EL_EMPTY ||
2410 Tile[xx][yy] == EL_ELEMENT_SNAPPING)
2413 element = TILE_GFX_ELEMENT(xx, yy);
2415 if (!IS_CRUMBLED_TILE(xx, yy, element))
2418 graphic = el_act2crm(element, ACTION_DEFAULT);
2420 DrawLevelFieldCrumbledBorders(xx, yy, graphic, 0, 3 - i);
2422 MarkTileDirty(sxx, syy);
2425 // crumble inner field corners of corner neighbour fields
2426 for (i = 0; i < 4; i++)
2428 int dx = (i & 1 ? +1 : -1);
2429 int dy = (i & 2 ? +1 : -1);
2435 if (!IN_LEV_FIELD(xx, yy) ||
2436 !IN_SCR_FIELD(sxx, syy))
2439 if (Tile[xx][yy] == EL_ELEMENT_SNAPPING)
2442 element = TILE_GFX_ELEMENT(xx, yy);
2444 if (!IS_CRUMBLED_TILE(xx, yy, element))
2447 graphic = el_act2crm(element, ACTION_DEFAULT);
2449 if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2450 graphic_info[graphic].anim_frames == 2)
2451 DrawLevelFieldCrumbledInnerCorners(xx, yy, -dx, -dy, graphic);
2453 MarkTileDirty(sxx, syy);
2458 void DrawLevelFieldCrumbled(int x, int y)
2462 if (!IN_LEV_FIELD(x, y))
2465 if (Tile[x][y] == EL_ELEMENT_SNAPPING &&
2466 GfxElement[x][y] != EL_UNDEFINED &&
2467 GFX_CRUMBLED(GfxElement[x][y]))
2469 DrawLevelFieldCrumbledDigging(x, y, GfxDir[x][y], GfxFrame[x][y]);
2474 graphic = el_act2crm(TILE_GFX_ELEMENT(x, y), ACTION_DEFAULT);
2476 DrawLevelFieldCrumbledExt(x, y, graphic, 0);
2479 void DrawLevelFieldCrumbledDigging(int x, int y, int direction,
2482 int graphic1 = el_act_dir2img(GfxElement[x][y], ACTION_DIGGING, direction);
2483 int graphic2 = el_act_dir2crm(GfxElement[x][y], ACTION_DIGGING, direction);
2484 int frame1 = getGraphicAnimationFrame(graphic1, step_frame);
2485 int frame2 = getGraphicAnimationFrame(graphic2, step_frame);
2486 int sx = SCREENX(x), sy = SCREENY(y);
2488 DrawScreenGraphic(sx, sy, graphic1, frame1);
2489 DrawLevelFieldCrumbledExt(x, y, graphic2, frame2);
2492 void DrawLevelFieldCrumbledNeighbours(int x, int y)
2494 int sx = SCREENX(x), sy = SCREENY(y);
2495 struct XY *xy = xy_topdown;
2498 // crumble direct neighbour fields (required for field borders)
2499 for (i = 0; i < 4; i++)
2501 int xx = x + xy[i].x;
2502 int yy = y + xy[i].y;
2503 int sxx = sx + xy[i].x;
2504 int syy = sy + xy[i].y;
2506 if (!IN_LEV_FIELD(xx, yy) ||
2507 !IN_SCR_FIELD(sxx, syy) ||
2508 !GFX_CRUMBLED(Tile[xx][yy]) ||
2512 DrawLevelField(xx, yy);
2515 // crumble corner neighbour fields (required for inner field corners)
2516 for (i = 0; i < 4; i++)
2518 int dx = (i & 1 ? +1 : -1);
2519 int dy = (i & 2 ? +1 : -1);
2525 if (!IN_LEV_FIELD(xx, yy) ||
2526 !IN_SCR_FIELD(sxx, syy) ||
2527 !GFX_CRUMBLED(Tile[xx][yy]) ||
2531 int element = TILE_GFX_ELEMENT(xx, yy);
2532 int graphic = el_act2crm(element, ACTION_DEFAULT);
2534 if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
2535 graphic_info[graphic].anim_frames == 2)
2536 DrawLevelField(xx, yy);
2540 static int getBorderElement(int x, int y)
2544 { EL_STEELWALL_TOPLEFT, EL_INVISIBLE_STEELWALL_TOPLEFT },
2545 { EL_STEELWALL_TOPRIGHT, EL_INVISIBLE_STEELWALL_TOPRIGHT },
2546 { EL_STEELWALL_BOTTOMLEFT, EL_INVISIBLE_STEELWALL_BOTTOMLEFT },
2547 { EL_STEELWALL_BOTTOMRIGHT, EL_INVISIBLE_STEELWALL_BOTTOMRIGHT },
2548 { EL_STEELWALL_VERTICAL, EL_INVISIBLE_STEELWALL_VERTICAL },
2549 { EL_STEELWALL_HORIZONTAL, EL_INVISIBLE_STEELWALL_HORIZONTAL },
2550 { EL_STEELWALL, EL_INVISIBLE_STEELWALL }
2552 int steel_type = (BorderElement == EL_STEELWALL ? 0 : 1);
2553 int steel_position = (x == -1 && y == -1 ? 0 :
2554 x == lev_fieldx && y == -1 ? 1 :
2555 x == -1 && y == lev_fieldy ? 2 :
2556 x == lev_fieldx && y == lev_fieldy ? 3 :
2557 x == -1 || x == lev_fieldx ? 4 :
2558 y == -1 || y == lev_fieldy ? 5 : 6);
2560 return border[steel_position][steel_type];
2563 void DrawScreenGraphic(int x, int y, int graphic, int frame)
2565 if (game.use_masked_elements)
2567 if (graphic != el2img(EL_EMPTY))
2568 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
2570 DrawGraphicThruMask(x, y, graphic, frame);
2574 DrawGraphic(x, y, graphic, frame);
2578 void DrawLevelGraphic(int x, int y, int graphic, int frame)
2580 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
2583 void DrawScreenElement(int x, int y, int element)
2585 int mask_mode = NO_MASKING;
2587 if (game.use_masked_elements)
2589 int lx = LEVELX(x), ly = LEVELY(y);
2591 if (IN_LEV_FIELD(lx, ly) && element != EL_EMPTY)
2593 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
2595 mask_mode = USE_MASKING;
2599 DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, mask_mode);
2600 DrawLevelFieldCrumbled(LEVELX(x), LEVELY(y));
2603 void DrawLevelElement(int x, int y, int element)
2605 if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2606 DrawScreenElement(SCREENX(x), SCREENY(y), element);
2609 void DrawScreenField(int x, int y)
2611 int lx = LEVELX(x), ly = LEVELY(y);
2612 int element, content;
2614 if (!IN_LEV_FIELD(lx, ly))
2616 if (lx < -1 || lx > lev_fieldx || ly < -1 || ly > lev_fieldy)
2619 element = getBorderElement(lx, ly);
2621 DrawScreenElement(x, y, element);
2626 element = Tile[lx][ly];
2627 content = Store[lx][ly];
2629 if (IS_MOVING(lx, ly))
2631 int horiz_move = (MovDir[lx][ly] == MV_LEFT || MovDir[lx][ly] == MV_RIGHT);
2632 boolean cut_mode = NO_CUTTING;
2634 if (element == EL_QUICKSAND_EMPTYING ||
2635 element == EL_QUICKSAND_FAST_EMPTYING ||
2636 element == EL_MAGIC_WALL_EMPTYING ||
2637 element == EL_BD_MAGIC_WALL_EMPTYING ||
2638 element == EL_DC_MAGIC_WALL_EMPTYING ||
2639 element == EL_AMOEBA_DROPPING)
2640 cut_mode = CUT_ABOVE;
2641 else if (element == EL_QUICKSAND_FILLING ||
2642 element == EL_QUICKSAND_FAST_FILLING ||
2643 element == EL_MAGIC_WALL_FILLING ||
2644 element == EL_BD_MAGIC_WALL_FILLING ||
2645 element == EL_DC_MAGIC_WALL_FILLING)
2646 cut_mode = CUT_BELOW;
2648 if (cut_mode == CUT_ABOVE)
2649 DrawScreenElement(x, y, element);
2651 DrawScreenElement(x, y, EL_EMPTY);
2653 if (cut_mode != CUT_BELOW && game.use_masked_elements)
2655 int dir = MovDir[lx][ly];
2656 int newx = x + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2657 int newy = y + (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
2659 if (IN_SCR_FIELD(newx, newy))
2660 DrawScreenElement(newx, newy, EL_EMPTY);
2664 DrawScreenElementShifted(x, y, MovPos[lx][ly], 0, element, NO_CUTTING);
2665 else if (cut_mode == NO_CUTTING)
2666 DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
2669 DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
2671 if (cut_mode == CUT_BELOW &&
2672 IN_LEV_FIELD(lx, ly + 1) && IN_SCR_FIELD(x, y + 1))
2673 DrawLevelElement(lx, ly + 1, element);
2676 if (content == EL_ACID)
2678 int dir = MovDir[lx][ly];
2679 int newlx = lx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2680 int newly = ly + (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
2682 DrawLevelElementThruMask(newlx, newly, EL_ACID);
2684 // prevent target field from being drawn again (but without masking)
2685 // (this would happen if target field is scanned after moving element)
2686 Stop[newlx][newly] = TRUE;
2689 else if (IS_BLOCKED(lx, ly))
2694 boolean cut_mode = NO_CUTTING;
2695 int element_old, content_old;
2697 Blocked2Moving(lx, ly, &oldx, &oldy);
2700 horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
2701 MovDir[oldx][oldy] == MV_RIGHT);
2703 element_old = Tile[oldx][oldy];
2704 content_old = Store[oldx][oldy];
2706 if (element_old == EL_QUICKSAND_EMPTYING ||
2707 element_old == EL_QUICKSAND_FAST_EMPTYING ||
2708 element_old == EL_MAGIC_WALL_EMPTYING ||
2709 element_old == EL_BD_MAGIC_WALL_EMPTYING ||
2710 element_old == EL_DC_MAGIC_WALL_EMPTYING ||
2711 element_old == EL_AMOEBA_DROPPING)
2712 cut_mode = CUT_ABOVE;
2714 DrawScreenElement(x, y, EL_EMPTY);
2717 DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old,
2719 else if (cut_mode == NO_CUTTING)
2720 DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old,
2723 DrawScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old,
2726 else if (IS_DRAWABLE(element))
2727 DrawScreenElement(x, y, element);
2729 DrawScreenElement(x, y, EL_EMPTY);
2732 void DrawLevelField(int x, int y)
2734 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2735 DrawScreenField(SCREENX(x), SCREENY(y));
2736 else if (IS_MOVING(x, y))
2740 Moving2Blocked(x, y, &newx, &newy);
2741 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
2742 DrawScreenField(SCREENX(newx), SCREENY(newy));
2744 else if (IS_BLOCKED(x, y))
2748 Blocked2Moving(x, y, &oldx, &oldy);
2749 if (IN_SCR_FIELD(SCREENX(oldx), SCREENY(oldy)))
2750 DrawScreenField(SCREENX(oldx), SCREENY(oldy));
2754 static void DrawSizedWallExt_MM(int dst_x, int dst_y, int element, int tilesize,
2755 int (*el2img_function)(int), boolean masked,
2756 int element_bits_draw)
2758 int element_base = map_mm_wall_element(element);
2759 int element_bits = (IS_DF_WALL(element) ?
2760 element - EL_DF_WALL_START :
2761 IS_MM_WALL(element) ?
2762 element - EL_MM_WALL_START : EL_EMPTY) & 0x000f;
2763 int graphic = el2img_function(element_base);
2764 int tilesize_draw = tilesize / 2;
2769 getSizedGraphicSource(graphic, 0, tilesize_draw, &src_bitmap, &src_x, &src_y);
2771 for (i = 0; i < 4; i++)
2773 int dst_draw_x = dst_x + (i % 2) * tilesize_draw;
2774 int dst_draw_y = dst_y + (i / 2) * tilesize_draw;
2776 if (!(element_bits_draw & (1 << i)))
2779 if (element_bits & (1 << i))
2782 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y,
2783 tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2785 BlitBitmap(src_bitmap, drawto, src_x, src_y,
2786 tilesize_draw, tilesize_draw, dst_draw_x, dst_draw_y);
2791 ClearRectangle(drawto, dst_draw_x, dst_draw_y,
2792 tilesize_draw, tilesize_draw);
2797 void DrawSizedWallParts_MM(int x, int y, int element, int tilesize,
2798 boolean masked, int element_bits_draw)
2800 DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2801 element, tilesize, el2edimg, masked, element_bits_draw);
2804 static void DrawSizedWall_MM(int dst_x, int dst_y, int element, int tilesize,
2805 int (*el2img_function)(int))
2807 DrawSizedWallExt_MM(dst_x, dst_y, element, tilesize, el2img_function, FALSE,
2811 static void DrawSizedElementExt(int x, int y, int element, int tilesize,
2814 if (IS_MM_WALL(element))
2816 DrawSizedWallExt_MM(SX + x * tilesize, SY + y * tilesize,
2817 element, tilesize, el2edimg, masked, 0x000f);
2821 int graphic = el2edimg(element);
2824 DrawSizedGraphicThruMask(x, y, graphic, 0, tilesize);
2826 DrawSizedGraphic(x, y, graphic, 0, tilesize);
2830 void DrawSizedElement(int x, int y, int element, int tilesize)
2832 DrawSizedElementExt(x, y, element, tilesize, FALSE);
2835 void DrawSizedElementThruMask(int x, int y, int element, int tilesize)
2837 DrawSizedElementExt(x, y, element, tilesize, TRUE);
2840 void DrawMiniElement(int x, int y, int element)
2844 graphic = el2edimg(element);
2845 DrawMiniGraphic(x, y, graphic);
2848 void DrawSizedElementOrWall(int sx, int sy, int scroll_x, int scroll_y,
2851 int x = sx + scroll_x, y = sy + scroll_y;
2853 if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2854 DrawSizedElement(sx, sy, EL_EMPTY, tilesize);
2855 else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2856 DrawSizedElement(sx, sy, Tile[x][y], tilesize);
2858 DrawSizedGraphic(sx, sy, el2edimg(getBorderElement(x, y)), 0, tilesize);
2861 void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y)
2863 int x = sx + scroll_x, y = sy + scroll_y;
2865 if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
2866 DrawMiniElement(sx, sy, EL_EMPTY);
2867 else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
2868 DrawMiniElement(sx, sy, Tile[x][y]);
2870 DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
2873 static void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
2874 int x, int y, int xsize, int ysize,
2875 int tile_width, int tile_height)
2879 int dst_x = startx + x * tile_width;
2880 int dst_y = starty + y * tile_height;
2881 int width = graphic_info[graphic].width;
2882 int height = graphic_info[graphic].height;
2883 int inner_width_raw = MAX(width - 2 * tile_width, tile_width);
2884 int inner_height_raw = MAX(height - 2 * tile_height, tile_height);
2885 int inner_width = inner_width_raw - (inner_width_raw % tile_width);
2886 int inner_height = inner_height_raw - (inner_height_raw % tile_height);
2887 int inner_sx = (width >= 3 * tile_width ? tile_width : 0);
2888 int inner_sy = (height >= 3 * tile_height ? tile_height : 0);
2889 boolean draw_masked = graphic_info[graphic].draw_masked;
2891 getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
2893 if (src_bitmap == NULL || width < tile_width || height < tile_height)
2895 ClearRectangle(drawto, dst_x, dst_y, tile_width, tile_height);
2899 src_x += (x == 0 ? 0 : x == xsize - 1 ? width - tile_width :
2900 inner_sx + (x - 1) * tile_width % inner_width);
2901 src_y += (y == 0 ? 0 : y == ysize - 1 ? height - tile_height :
2902 inner_sy + (y - 1) * tile_height % inner_height);
2905 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2908 BlitBitmap(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
2912 static void DrawEnvelopeBackground(int graphic, int startx, int starty,
2913 int x, int y, int xsize, int ysize,
2916 int font_width = getFontWidth(font_nr);
2917 int font_height = getFontHeight(font_nr);
2919 DrawEnvelopeBackgroundTiles(graphic, startx, starty, x, y, xsize, ysize,
2920 font_width, font_height);
2923 static void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
2925 int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2926 Bitmap *src_bitmap = graphic_info[graphic].bitmap;
2927 int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
2928 boolean ffwd_delay = (tape.playing && tape.fast_forward);
2929 boolean no_delay = (tape.warp_forward);
2930 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2931 int anim_delay_value = MAX(1, (no_delay ? 0 : frame_delay_value) / 2);
2932 DelayCounter anim_delay = { anim_delay_value };
2933 int font_nr = FONT_ENVELOPE_1 + envelope_nr;
2934 int font_width = getFontWidth(font_nr);
2935 int font_height = getFontHeight(font_nr);
2936 int max_xsize = level.envelope[envelope_nr].xsize;
2937 int max_ysize = level.envelope[envelope_nr].ysize;
2938 int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize : 0);
2939 int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize : 0);
2940 int xend = max_xsize;
2941 int yend = (anim_mode != ANIM_DEFAULT ? max_ysize : 0);
2942 int xstep = (xstart < xend ? 1 : 0);
2943 int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
2945 int end = MAX(xend - xstart, yend - ystart);
2948 for (i = start; i <= end; i++)
2950 int last_frame = end; // last frame of this "for" loop
2951 int x = xstart + i * xstep;
2952 int y = ystart + i * ystep;
2953 int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
2954 int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
2955 int sx = SX + (SXSIZE - xsize * font_width) / 2;
2956 int sy = SY + (SYSIZE - ysize * font_height) / 2;
2959 SetDrawtoField(DRAW_TO_FIELDBUFFER);
2961 BlitScreenToBitmap(backbuffer);
2963 SetDrawtoField(DRAW_TO_BACKBUFFER);
2965 for (yy = 0; yy < ysize; yy++)
2966 for (xx = 0; xx < xsize; xx++)
2967 DrawEnvelopeBackground(graphic, sx, sy, xx, yy, xsize, ysize, font_nr);
2969 DrawTextArea(sx + font_width, sy + font_height,
2970 level.envelope[envelope_nr].text, font_nr, max_xsize,
2971 xsize - 2, ysize - 2, 0, mask_mode,
2972 level.envelope[envelope_nr].autowrap,
2973 level.envelope[envelope_nr].centered, FALSE);
2975 redraw_mask |= REDRAW_FIELD;
2978 SkipUntilDelayReached(&anim_delay, &i, last_frame);
2981 ClearAutoRepeatKeyEvents();
2984 void ShowEnvelope(int envelope_nr)
2986 int element = EL_ENVELOPE_1 + envelope_nr;
2987 int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
2988 int sound_opening = element_info[element].sound[ACTION_OPENING];
2989 int sound_closing = element_info[element].sound[ACTION_CLOSING];
2990 boolean ffwd_delay = (tape.playing && tape.fast_forward);
2991 boolean no_delay = (tape.warp_forward);
2992 int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
2993 int wait_delay_value = (no_delay ? 0 : normal_delay_value);
2994 int anim_mode = graphic_info[graphic].anim_mode;
2995 int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
2996 anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
2997 boolean overlay_enabled = GetOverlayEnabled();
2999 game.envelope_active = TRUE; // needed for RedrawPlayfield() events
3001 SetOverlayEnabled(FALSE);
3004 PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
3006 if (anim_mode == ANIM_DEFAULT)
3007 AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
3009 AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
3012 Delay_WithScreenUpdates(wait_delay_value);
3014 WaitForEventToContinue();
3017 SetOverlayEnabled(overlay_enabled);
3019 PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
3021 if (anim_mode != ANIM_NONE)
3022 AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
3024 if (anim_mode == ANIM_DEFAULT)
3025 AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
3027 game.envelope_active = FALSE;
3029 SetDrawtoField(DRAW_TO_FIELDBUFFER);
3031 redraw_mask |= REDRAW_FIELD;
3035 static void PrepareEnvelopeRequestToScreen(Bitmap *bitmap, int sx, int sy,
3036 int xsize, int ysize)
3038 if (!global.use_envelope_request)
3041 if (request.bitmap == NULL ||
3042 xsize > request.xsize ||
3043 ysize > request.ysize)
3045 if (request.bitmap != NULL)
3046 FreeBitmap(request.bitmap);
3048 request.bitmap = CreateBitmap(xsize, ysize, DEFAULT_DEPTH);
3050 SDL_Surface *surface = request.bitmap->surface;
3052 if ((request.bitmap->surface_masked = SDLGetNativeSurface(surface)) == NULL)
3053 Fail("SDLGetNativeSurface() failed");
3056 BlitBitmap(bitmap, request.bitmap, sx, sy, xsize, ysize, 0, 0);
3058 // create masked surface for request bitmap, if needed
3059 if (graphic_info[IMG_BACKGROUND_REQUEST].draw_masked)
3061 SDL_Surface *surface = request.bitmap->surface;
3062 SDL_Surface *surface_masked = request.bitmap->surface_masked;
3064 SDLBlitSurface(surface, surface_masked, 0, 0, xsize, ysize, 0, 0);
3065 SDL_SetColorKey(surface_masked, SET_TRANSPARENT_PIXEL,
3066 SDL_MapRGB(surface_masked->format, 0x00, 0x00, 0x00));
3069 SDLFreeBitmapTextures(request.bitmap);
3070 SDLCreateBitmapTextures(request.bitmap);
3072 ResetBitmapAlpha(request.bitmap);
3074 // set envelope request run-time values
3077 request.xsize = xsize;
3078 request.ysize = ysize;
3081 void DrawEnvelopeRequestToScreen(int drawing_target)
3083 if (global.use_envelope_request &&
3084 game.request_active &&
3085 drawing_target == DRAW_TO_SCREEN)
3087 struct GraphicInfo *g = &graphic_info[IMG_BACKGROUND_REQUEST];
3089 SetBitmapAlphaNextBlit(request.bitmap, g->alpha);
3092 BlitToScreenMasked(request.bitmap, 0, 0, request.xsize, request.ysize,
3093 request.sx, request.sy);
3095 BlitToScreen(request.bitmap, 0, 0, request.xsize, request.ysize,
3096 request.sx, request.sy);
3100 static void setRequestBasePosition(int *x, int *y)
3102 int sx_base, sy_base;
3104 if (request.x != -1)
3105 sx_base = request.x;
3106 else if (request.align == ALIGN_LEFT)
3108 else if (request.align == ALIGN_RIGHT)
3109 sx_base = SX + SXSIZE;
3111 sx_base = SX + SXSIZE / 2;
3113 if (request.y != -1)
3114 sy_base = request.y;
3115 else if (request.valign == VALIGN_TOP)
3117 else if (request.valign == VALIGN_BOTTOM)
3118 sy_base = SY + SYSIZE;
3120 sy_base = SY + SYSIZE / 2;
3126 static void setRequestPositionExt(int *x, int *y, int width, int height,
3127 boolean add_border_size)
3129 int border_size = request.border_size;
3130 int sx_base, sy_base;
3133 setRequestBasePosition(&sx_base, &sy_base);
3135 if (request.align == ALIGN_LEFT)
3137 else if (request.align == ALIGN_RIGHT)
3138 sx = sx_base - width;
3140 sx = sx_base - width / 2;
3142 if (request.valign == VALIGN_TOP)
3144 else if (request.valign == VALIGN_BOTTOM)
3145 sy = sy_base - height;
3147 sy = sy_base - height / 2;
3149 sx = MAX(0, MIN(sx, WIN_XSIZE - width));
3150 sy = MAX(0, MIN(sy, WIN_YSIZE - height));
3152 if (add_border_size)
3162 static void setRequestPosition(int *x, int *y, boolean add_border_size)
3164 setRequestPositionExt(x, y, request.width, request.height, add_border_size);
3167 static void DrawEnvelopeRequestText(int sx, int sy, char *text)
3169 char *text_final = text;
3170 char *text_door_style = NULL;
3171 int graphic = IMG_BACKGROUND_REQUEST;
3172 Bitmap *src_bitmap = graphic_info[graphic].bitmap;
3173 int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
3174 int font_nr = FONT_REQUEST;
3175 int font_width = getFontWidth(font_nr);
3176 int font_height = getFontHeight(font_nr);
3177 int border_size = request.border_size;
3178 int line_spacing = request.line_spacing;
3179 int line_height = font_height + line_spacing;
3180 int max_text_width = request.width - 2 * border_size;
3181 int max_text_height = request.height - 2 * border_size;
3182 int line_length = max_text_width / font_width;
3183 int max_lines = max_text_height / line_height;
3184 int text_width = line_length * font_width;
3185 int sx_offset = border_size;
3186 int sy_offset = border_size;
3188 // force DOOR font inside door area
3189 SetFontStatus(GAME_MODE_PSEUDO_DOOR);
3191 if (request.centered)
3192 sx_offset = (request.width - text_width) / 2;
3194 if (request.wrap_single_words && !request.autowrap)
3196 char *src_text_ptr, *dst_text_ptr;
3198 if (maxWordLengthInRequestString(text) > line_length)
3200 font_nr = FONT_REQUEST_NARROW;
3201 font_width = getFontWidth(font_nr);
3202 line_length = max_text_width / font_width;
3205 text_door_style = checked_malloc(2 * strlen(text) + 1);
3207 src_text_ptr = text;
3208 dst_text_ptr = text_door_style;
3210 while (*src_text_ptr)
3212 if (*src_text_ptr == ' ' ||
3213 *src_text_ptr == '?' ||
3214 *src_text_ptr == '!')
3215 *dst_text_ptr++ = '\n';
3217 if (*src_text_ptr != ' ')
3218 *dst_text_ptr++ = *src_text_ptr;
3223 *dst_text_ptr = '\0';
3225 text_final = text_door_style;
3228 DrawTextBuffer(sx + sx_offset, sy + sy_offset, text_final, font_nr,
3229 line_length, -1, max_lines, line_spacing, mask_mode,
3230 request.autowrap, request.centered, FALSE);
3232 if (text_door_style)
3233 free(text_door_style);
3238 static void DrawEnvelopeRequest(char *text, unsigned int req_state)
3240 DrawBuffer *drawto_last = drawto;
3241 int graphic = IMG_BACKGROUND_REQUEST;
3242 int width = request.width;
3243 int height = request.height;
3244 int tile_size = MAX(request.step_offset, 1);
3245 int x_steps = width / tile_size;
3246 int y_steps = height / tile_size;
3250 setRequestPosition(&sx, &sy, FALSE);
3252 // draw complete envelope request to temporary bitmap
3253 drawto = bitmap_db_store_1;
3255 ClearRectangle(drawto, sx, sy, width, height);
3257 for (y = 0; y < y_steps; y++)
3258 for (x = 0; x < x_steps; x++)
3259 DrawEnvelopeBackgroundTiles(graphic, sx, sy,
3260 x, y, x_steps, y_steps,
3261 tile_size, tile_size);
3263 // write text for request
3264 DrawEnvelopeRequestText(sx, sy, text);
3266 MapToolButtons(req_state);
3268 // restore pointer to drawing buffer
3269 drawto = drawto_last;
3271 // prepare complete envelope request from temporary bitmap
3272 PrepareEnvelopeRequestToScreen(bitmap_db_store_1, sx, sy, width, height);
3275 static void AnimateEnvelopeRequest(int anim_mode, int action)
3277 boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
3278 int delay_value_normal = request.step_delay;
3279 int delay_value_fast = delay_value_normal / 2;
3280 boolean ffwd_delay = (tape.playing && tape.fast_forward);
3281 boolean no_delay = (tape.warp_forward);
3282 int delay_value = (ffwd_delay ? delay_value_fast : delay_value_normal);
3283 int anim_delay_value = MAX(1, (no_delay ? 0 : delay_value) / 2);
3284 DelayCounter anim_delay = { anim_delay_value };
3286 int tile_size = MAX(request.step_offset, 1);
3287 int max_xsize = request.width / tile_size;
3288 int max_ysize = request.height / tile_size;
3289 int max_xsize_inner = max_xsize - 2;
3290 int max_ysize_inner = max_ysize - 2;
3292 int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize_inner : 0);
3293 int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize_inner : 0);
3294 int xend = max_xsize_inner;
3295 int yend = (anim_mode != ANIM_DEFAULT ? max_ysize_inner : 0);
3296 int xstep = (xstart < xend ? 1 : 0);
3297 int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
3299 int end = MAX(xend - xstart, yend - ystart);
3302 if (setup.quick_doors)
3309 for (i = start; i <= end; i++)
3311 int last_frame = end; // last frame of this "for" loop
3312 int x = xstart + i * xstep;
3313 int y = ystart + i * ystep;
3314 int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2;
3315 int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2;
3316 int xsize_size_left = (xsize - 1) * tile_size;
3317 int ysize_size_top = (ysize - 1) * tile_size;
3318 int max_xsize_pos = (max_xsize - 1) * tile_size;
3319 int max_ysize_pos = (max_ysize - 1) * tile_size;
3320 int width = xsize * tile_size;
3321 int height = ysize * tile_size;
3327 HandleGameActions();
3329 setRequestPosition(&src_x, &src_y, FALSE);
3330 setRequestPositionExt(&dst_x, &dst_y, width, height, FALSE);
3332 for (yy = 0; yy < 2; yy++)
3334 for (xx = 0; xx < 2; xx++)
3336 int src_xx = src_x + xx * max_xsize_pos;
3337 int src_yy = src_y + yy * max_ysize_pos;
3338 int dst_xx = dst_x + xx * xsize_size_left;
3339 int dst_yy = dst_y + yy * ysize_size_top;
3340 int xx_size = (xx ? tile_size : xsize_size_left);
3341 int yy_size = (yy ? tile_size : ysize_size_top);
3343 // draw partial (animated) envelope request to temporary bitmap
3344 BlitBitmap(bitmap_db_store_1, bitmap_db_store_2,
3345 src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
3349 // prepare partial (animated) envelope request from temporary bitmap
3350 PrepareEnvelopeRequestToScreen(bitmap_db_store_2, dst_x, dst_y,
3353 redraw_mask |= REDRAW_FIELD;
3357 SkipUntilDelayReached(&anim_delay, &i, last_frame);
3360 ClearAutoRepeatKeyEvents();
3363 static void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
3365 int graphic = IMG_BACKGROUND_REQUEST;
3366 int sound_opening = SND_REQUEST_OPENING;
3367 int sound_closing = SND_REQUEST_CLOSING;
3368 int anim_mode_1 = request.anim_mode; // (higher priority)
3369 int anim_mode_2 = graphic_info[graphic].anim_mode; // (lower priority)
3370 int anim_mode = (anim_mode_1 != ANIM_DEFAULT ? anim_mode_1 : anim_mode_2);
3371 int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
3372 anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
3374 game.envelope_active = TRUE; // needed for RedrawPlayfield() events
3376 if (action == ACTION_OPENING)
3378 PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
3380 if (anim_mode == ANIM_DEFAULT)
3381 AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
3383 AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
3387 PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
3389 if (anim_mode != ANIM_NONE)
3390 AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
3392 if (anim_mode == ANIM_DEFAULT)
3393 AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
3396 game.envelope_active = FALSE;
3399 static Bitmap *GetPreviewTileBitmap(Bitmap *bitmap)
3401 if (level.game_engine_type == GAME_ENGINE_TYPE_BD)
3402 return GetPreviewTileBitmap_BD(bitmap);
3407 static void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
3409 if (IS_MM_WALL(element))
3411 DrawSizedWall_MM(dst_x, dst_y, element, tilesize, el2preimg);
3417 int graphic = el2preimg(element);
3419 getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
3421 // for BD style levels, maybe use bitmap with level-specific colors
3422 src_bitmap = GetPreviewTileBitmap(src_bitmap);
3424 BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize,
3429 void DrawLevel(int draw_background_mask)
3433 SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
3434 SetDrawBackgroundMask(draw_background_mask);
3438 for (x = BX1; x <= BX2; x++)
3439 for (y = BY1; y <= BY2; y++)
3440 DrawScreenField(x, y);
3442 redraw_mask |= REDRAW_FIELD;
3445 void DrawSizedLevel(int size_x, int size_y, int scroll_x, int scroll_y,
3450 for (x = 0; x < size_x; x++)
3451 for (y = 0; y < size_y; y++)
3452 DrawSizedElementOrWall(x, y, scroll_x, scroll_y, tilesize);
3454 redraw_mask |= REDRAW_FIELD;
3457 void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
3461 for (x = 0; x < size_x; x++)
3462 for (y = 0; y < size_y; y++)
3463 DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
3465 redraw_mask |= REDRAW_FIELD;
3468 static int getPreviewLevelWidth(void)
3470 if (level.game_engine_type == GAME_ENGINE_TYPE_BD)
3471 return (level.native_bd_level->cave->x2 - level.native_bd_level->cave->x1 + 1);
3476 static int getPreviewLevelHeight(void)
3478 if (level.game_engine_type == GAME_ENGINE_TYPE_BD)
3479 return (level.native_bd_level->cave->y2 - level.native_bd_level->cave->y1 + 1);
3484 static void DrawPreviewLevelPlayfield(int from_x, int from_y)
3486 boolean show_level_border = (BorderElement != EL_EMPTY);
3487 int level_xsize = getPreviewLevelWidth() + (show_level_border ? 2 : 0);
3488 int level_ysize = getPreviewLevelHeight() + (show_level_border ? 2 : 0);
3489 int tile_size = preview.tile_size;
3490 int preview_width = preview.xsize * tile_size;
3491 int preview_height = preview.ysize * tile_size;
3492 int real_preview_xsize = MIN(level_xsize, preview.xsize);
3493 int real_preview_ysize = MIN(level_ysize, preview.ysize);
3494 int real_preview_width = real_preview_xsize * tile_size;
3495 int real_preview_height = real_preview_ysize * tile_size;
3496 int dst_x = SX + ALIGNED_XPOS(preview.x, preview_width, preview.align);
3497 int dst_y = SY + ALIGNED_YPOS(preview.y, preview_height, preview.valign);
3500 if (!IN_GFX_FIELD_FULL(dst_x, dst_y + preview_height - 1))
3503 DrawBackground(dst_x, dst_y, preview_width, preview_height);
3505 dst_x += (preview_width - real_preview_width) / 2;
3506 dst_y += (preview_height - real_preview_height) / 2;
3508 for (x = 0; x < real_preview_xsize; x++)
3510 for (y = 0; y < real_preview_ysize; y++)
3512 int lx = from_x + x + (show_level_border ? -1 : 0);
3513 int ly = from_y + y + (show_level_border ? -1 : 0);
3514 int element = (IN_LEV_FIELD(lx, ly) ? level.field[lx][ly] :
3515 getBorderElement(lx, ly));
3517 DrawPreviewElement(dst_x + x * tile_size, dst_y + y * tile_size,
3518 element, tile_size);
3522 redraw_mask |= REDRAW_FIELD;
3525 #define MICROLABEL_EMPTY 0
3526 #define MICROLABEL_LEVEL_NAME 1
3527 #define MICROLABEL_LEVEL_AUTHOR_HEAD 2
3528 #define MICROLABEL_LEVEL_AUTHOR 3
3529 #define MICROLABEL_IMPORTED_FROM_HEAD 4
3530 #define MICROLABEL_IMPORTED_FROM 5
3531 #define MICROLABEL_IMPORTED_BY_HEAD 6
3532 #define MICROLABEL_IMPORTED_BY 7
3534 static int getMaxTextLength(struct TextPosInfo *pos, int font_nr)
3536 int max_text_width = SXSIZE;
3537 int font_width = getFontWidth(font_nr);
3539 if (pos->align == ALIGN_CENTER)
3540 max_text_width = (pos->x < SXSIZE / 2 ? pos->x * 2 : (SXSIZE - pos->x) * 2);
3541 else if (pos->align == ALIGN_RIGHT)
3542 max_text_width = pos->x;
3544 max_text_width = SXSIZE - pos->x;
3546 return max_text_width / font_width;
3549 static void DrawPreviewLevelLabelExt(int mode, struct TextPosInfo *pos)
3551 char label_text[MAX_OUTPUT_LINESIZE + 1];
3552 int max_len_label_text;
3553 int font_nr = pos->font;
3556 if (!IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3559 if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
3560 mode == MICROLABEL_IMPORTED_FROM_HEAD ||
3561 mode == MICROLABEL_IMPORTED_BY_HEAD)
3562 font_nr = pos->font_alt;
3564 max_len_label_text = getMaxTextLength(pos, font_nr);
3566 if (pos->size != -1)
3567 max_len_label_text = pos->size;
3569 for (i = 0; i < max_len_label_text; i++)
3570 label_text[i] = ' ';
3571 label_text[max_len_label_text] = '\0';
3573 if (strlen(label_text) > 0)
3574 DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3577 (mode == MICROLABEL_LEVEL_NAME ? level.name :
3578 mode == MICROLABEL_LEVEL_AUTHOR_HEAD ? "created by" :
3579 mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
3580 mode == MICROLABEL_IMPORTED_FROM_HEAD ? "imported from" :
3581 mode == MICROLABEL_IMPORTED_FROM ? leveldir_current->imported_from :
3582 mode == MICROLABEL_IMPORTED_BY_HEAD ? "imported by" :
3583 mode == MICROLABEL_IMPORTED_BY ? leveldir_current->imported_by :""),
3584 max_len_label_text);
3585 label_text[max_len_label_text] = '\0';
3587 if (strlen(label_text) > 0)
3588 DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3590 redraw_mask |= REDRAW_FIELD;
3593 static void DrawPreviewLevelLabel(int mode)
3595 DrawPreviewLevelLabelExt(mode, &menu.main.text.level_info_2);
3598 static void DrawPreviewLevelInfo(int mode)
3600 if (mode == MICROLABEL_LEVEL_NAME)
3601 DrawPreviewLevelLabelExt(mode, &menu.main.text.level_name);
3602 else if (mode == MICROLABEL_LEVEL_AUTHOR)
3603 DrawPreviewLevelLabelExt(mode, &menu.main.text.level_author);
3606 static void DrawPreviewLevelExt(boolean restart)
3608 static DelayCounter scroll_delay = { 0 };
3609 static DelayCounter label_delay = { 0 };
3610 static int from_x, from_y, scroll_direction;
3611 static int label_state, label_counter;
3612 boolean show_level_border = (BorderElement != EL_EMPTY);
3613 int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
3614 int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
3616 scroll_delay.value = preview.step_delay;
3617 label_delay.value = MICROLEVEL_LABEL_DELAY;
3624 if (preview.anim_mode == ANIM_CENTERED)
3626 if (level_xsize > preview.xsize)
3627 from_x = (level_xsize - preview.xsize) / 2;
3628 if (level_ysize > preview.ysize)
3629 from_y = (level_ysize - preview.ysize) / 2;
3632 from_x += preview.xoffset;
3633 from_y += preview.yoffset;
3635 scroll_direction = MV_RIGHT;
3639 DrawPreviewLevelPlayfield(from_x, from_y);
3640 DrawPreviewLevelLabel(label_state);
3642 DrawPreviewLevelInfo(MICROLABEL_LEVEL_NAME);
3643 DrawPreviewLevelInfo(MICROLABEL_LEVEL_AUTHOR);
3645 // initialize delay counters
3646 ResetDelayCounter(&scroll_delay);
3647 ResetDelayCounter(&label_delay);
3649 if (leveldir_current->name)
3651 struct TextPosInfo *pos = &menu.main.text.level_info_1;
3652 char label_text[MAX_OUTPUT_LINESIZE + 1];
3653 int font_nr = pos->font;
3654 int max_len_label_text = getMaxTextLength(pos, font_nr);
3656 if (pos->size != -1)
3657 max_len_label_text = pos->size;
3659 strncpy(label_text, leveldir_current->name, max_len_label_text);
3660 label_text[max_len_label_text] = '\0';
3662 if (IN_GFX_FIELD_FULL(pos->x, pos->y + getFontHeight(pos->font)))
3663 DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
3669 // scroll preview level, if needed
3670 if (preview.anim_mode != ANIM_NONE &&
3671 (level_xsize > preview.xsize || level_ysize > preview.ysize) &&
3672 DelayReached(&scroll_delay))
3674 switch (scroll_direction)
3679 from_x -= preview.step_offset;
3680 from_x = (from_x < 0 ? 0 : from_x);
3683 scroll_direction = MV_UP;
3687 if (from_x < level_xsize - preview.xsize)
3689 from_x += preview.step_offset;
3690 from_x = (from_x > level_xsize - preview.xsize ?
3691 level_xsize - preview.xsize : from_x);
3694 scroll_direction = MV_DOWN;
3700 from_y -= preview.step_offset;
3701 from_y = (from_y < 0 ? 0 : from_y);
3704 scroll_direction = MV_RIGHT;
3708 if (from_y < level_ysize - preview.ysize)
3710 from_y += preview.step_offset;
3711 from_y = (from_y > level_ysize - preview.ysize ?
3712 level_ysize - preview.ysize : from_y);
3715 scroll_direction = MV_LEFT;
3722 DrawPreviewLevelPlayfield(from_x, from_y);
3725 // !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!!
3726 // redraw micro level label, if needed
3727 if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
3728 !strEqual(level.author, ANONYMOUS_NAME) &&
3729 !strEqual(level.author, leveldir_current->name) &&
3730 DelayReached(&label_delay))
3732 int max_label_counter = 23;
3734 if (leveldir_current->imported_from != NULL &&
3735 strlen(leveldir_current->imported_from) > 0)
3736 max_label_counter += 14;
3737 if (leveldir_current->imported_by != NULL &&
3738 strlen(leveldir_current->imported_by) > 0)
3739 max_label_counter += 14;
3741 label_counter = (label_counter + 1) % max_label_counter;
3742 label_state = (label_counter >= 0 && label_counter <= 7 ?
3743 MICROLABEL_LEVEL_NAME :
3744 label_counter >= 9 && label_counter <= 12 ?
3745 MICROLABEL_LEVEL_AUTHOR_HEAD :
3746 label_counter >= 14 && label_counter <= 21 ?
3747 MICROLABEL_LEVEL_AUTHOR :
3748 label_counter >= 23 && label_counter <= 26 ?
3749 MICROLABEL_IMPORTED_FROM_HEAD :
3750 label_counter >= 28 && label_counter <= 35 ?
3751 MICROLABEL_IMPORTED_FROM :
3752 label_counter >= 37 && label_counter <= 40 ?
3753 MICROLABEL_IMPORTED_BY_HEAD :
3754 label_counter >= 42 && label_counter <= 49 ?
3755 MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
3757 if (leveldir_current->imported_from == NULL &&
3758 (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
3759 label_state == MICROLABEL_IMPORTED_FROM))
3760 label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
3761 MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
3763 DrawPreviewLevelLabel(label_state);
3767 void DrawPreviewPlayers(void)
3769 if (game_status != GAME_MODE_MAIN)
3772 // do not draw preview players if level preview redefined, but players aren't
3773 if (preview.redefined && !menu.main.preview_players.redefined)
3776 boolean player_found[MAX_PLAYERS];
3777 int num_players = 0;
3780 for (i = 0; i < MAX_PLAYERS; i++)
3781 player_found[i] = FALSE;
3783 // check which players can be found in the level (simple approach)
3784 for (x = 0; x < lev_fieldx; x++)
3786 for (y = 0; y < lev_fieldy; y++)
3788 int element = level.field[x][y];
3790 if (IS_PLAYER_ELEMENT(element))
3792 int player_nr = GET_PLAYER_NR(element);
3794 player_nr = MIN(MAX(0, player_nr), MAX_PLAYERS - 1);
3796 if (!player_found[player_nr])
3799 player_found[player_nr] = TRUE;
3804 struct TextPosInfo *pos = &menu.main.preview_players;
3805 int tile_size = pos->tile_size;
3806 int border_size = pos->border_size;
3807 int player_xoffset_raw = (pos->vertical ? 0 : tile_size + border_size);
3808 int player_yoffset_raw = (pos->vertical ? tile_size + border_size : 0);
3809 int player_xoffset = (pos->xoffset != -1 ? pos->xoffset : player_xoffset_raw);
3810 int player_yoffset = (pos->yoffset != -1 ? pos->yoffset : player_yoffset_raw);
3811 int max_players_width = (MAX_PLAYERS - 1) * player_xoffset + tile_size;
3812 int max_players_height = (MAX_PLAYERS - 1) * player_yoffset + tile_size;
3813 int all_players_width = (num_players - 1) * player_xoffset + tile_size;
3814 int all_players_height = (num_players - 1) * player_yoffset + tile_size;
3815 int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width, pos->align);
3816 int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
3817 int xpos = SX + ALIGNED_XPOS(pos->x, all_players_width, pos->align);
3818 int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
3820 // clear area in which the players will be drawn
3821 ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
3822 max_players_width, max_players_height);
3824 if (!network.enabled && !setup.team_mode)
3827 // only draw players if level is suited for team mode
3828 if (num_players < 2)
3831 // draw all players that were found in the level
3832 for (i = 0; i < MAX_PLAYERS; i++)
3834 if (player_found[i])
3836 int graphic = el2img(EL_PLAYER_1 + i);
3838 DrawSizedGraphicThruMaskExt(drawto, xpos, ypos, graphic, 0, tile_size);
3840 xpos += player_xoffset;
3841 ypos += player_yoffset;
3846 static void PreparePreviewTileBitmap(void)
3848 // check if special preview bitmap with level-specific colors should be created
3849 if (level.game_engine_type != GAME_ENGINE_TYPE_BD)
3852 // use original sized bitmap (else reduced color palette is lost by downscaling)
3853 int original_tilesize = MAX(MINI_TILESIZE, preview.tile_size);
3854 int scale_down_factor = original_tilesize / preview.tile_size;
3857 int element_template = EL_BD_GAME_GRAPHICS_COLOR_TEMPLATE;
3858 int graphic_template = el2preimg(element_template);
3859 int element_default = EL_BD_ROCK;
3860 int graphic_default = el2preimg(element_default);
3862 // create special preview bitmap and scale it down to preview tile size
3863 getSizedGraphicSource(graphic_template, 0, original_tilesize, &src_bitmap, &src_x, &src_y);
3864 PreparePreviewTileBitmap_BD(src_bitmap, scale_down_factor);
3866 // force using special preview bitmap to replace original preview bitmap
3867 getSizedGraphicSource(graphic_default, 0, preview.tile_size, &src_bitmap, &src_x, &src_y);
3868 SetPreviewTileBitmapReference_BD(src_bitmap);
3871 void DrawPreviewLevelInitial(void)
3873 PreparePreviewTileBitmap(); // only needed for native BD style levels
3875 DrawPreviewLevelExt(TRUE);
3876 DrawPreviewPlayers();
3879 void DrawPreviewLevelAnimation(void)
3881 DrawPreviewLevelExt(FALSE);
3884 static void DrawNetworkPlayer(int x, int y, int player_nr, int tile_size,
3885 int border_size, int font_nr)
3887 int graphic = el2img(EL_PLAYER_1 + player_nr);
3888 int font_height = getFontHeight(font_nr);
3889 int player_height = MAX(tile_size, font_height);
3890 int xoffset_text = tile_size + border_size;
3891 int yoffset_text = (player_height - font_height) / 2;
3892 int yoffset_graphic = (player_height - tile_size) / 2;
3893 char *player_name = getNetworkPlayerName(player_nr + 1);
3895 DrawSizedGraphicThruMaskExt(drawto, x, y + yoffset_graphic, graphic, 0,
3897 DrawText(x + xoffset_text, y + yoffset_text, player_name, font_nr);
3900 static void DrawNetworkPlayersExt(boolean force)
3902 if (game_status != GAME_MODE_MAIN)
3905 if (!network.connected && !force)
3908 // do not draw network players if level preview redefined, but players aren't
3909 if (preview.redefined && !menu.main.network_players.redefined)
3912 int num_players = 0;
3915 for (i = 0; i < MAX_PLAYERS; i++)
3916 if (stored_player[i].connected_network)
3919 struct TextPosInfo *pos = &menu.main.network_players;
3920 int tile_size = pos->tile_size;
3921 int border_size = pos->border_size;
3922 int xoffset_text = tile_size + border_size;
3923 int font_nr = pos->font;
3924 int font_width = getFontWidth(font_nr);
3925 int font_height = getFontHeight(font_nr);
3926 int player_height = MAX(tile_size, font_height);
3927 int player_yoffset = player_height + border_size;
3928 int max_players_width = xoffset_text + MAX_PLAYER_NAME_LEN * font_width;
3929 int max_players_height = MAX_PLAYERS * player_yoffset - border_size;
3930 int all_players_height = num_players * player_yoffset - border_size;
3931 int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width, pos->align);
3932 int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
3933 int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
3935 ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
3936 max_players_width, max_players_height);
3938 // first draw local network player ...
3939 for (i = 0; i < MAX_PLAYERS; i++)
3941 if (stored_player[i].connected_network &&
3942 stored_player[i].connected_locally)
3944 char *player_name = getNetworkPlayerName(i + 1);
3945 int player_width = xoffset_text + getTextWidth(player_name, font_nr);
3946 int xpos = SX + ALIGNED_XPOS(pos->x, player_width, pos->align);
3948 DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
3950 ypos += player_yoffset;
3954 // ... then draw all other network players
3955 for (i = 0; i < MAX_PLAYERS; i++)
3957 if (stored_player[i].connected_network &&
3958 !stored_player[i].connected_locally)
3960 char *player_name = getNetworkPlayerName(i + 1);
3961 int player_width = xoffset_text + getTextWidth(player_name, font_nr);
3962 int xpos = SX + ALIGNED_XPOS(pos->x, player_width, pos->align);
3964 DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
3966 ypos += player_yoffset;
3971 void DrawNetworkPlayers(void)
3973 DrawNetworkPlayersExt(FALSE);
3976 void ClearNetworkPlayers(void)
3978 DrawNetworkPlayersExt(TRUE);
3981 static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3982 int graphic, int lx, int ly,
3985 int frame = getGraphicAnimationFrameXY(graphic, lx, ly);
3987 if (mask_mode == USE_MASKING)
3988 DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
3990 DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
3993 void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
3994 int graphic, int sync_frame, int mask_mode)
3996 int frame = getGraphicAnimationFrame(graphic, sync_frame);
3998 if (mask_mode == USE_MASKING)
3999 DrawFixedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
4001 DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame);
4004 void DrawSizedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
4005 int graphic, int sync_frame, int tilesize,
4008 int frame = getGraphicAnimationFrame(graphic, sync_frame);
4010 if (mask_mode == USE_MASKING)
4011 DrawSizedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame, tilesize);
4013 DrawSizedGraphicExt(dst_bitmap, x, y, graphic, frame, tilesize);
4016 static void DrawGraphicAnimation(int x, int y, int graphic)
4018 int lx = LEVELX(x), ly = LEVELY(y);
4019 int mask_mode = NO_MASKING;
4021 if (!IN_SCR_FIELD(x, y))
4024 if (game.use_masked_elements)
4026 if (Tile[lx][ly] != EL_EMPTY)
4028 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
4030 mask_mode = USE_MASKING;
4034 DrawGraphicAnimationExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
4035 graphic, lx, ly, mask_mode);
4037 MarkTileDirty(x, y);
4040 void DrawFixedGraphicAnimation(int x, int y, int graphic)
4042 int lx = LEVELX(x), ly = LEVELY(y);
4043 int mask_mode = NO_MASKING;
4045 if (!IN_SCR_FIELD(x, y))
4048 if (game.use_masked_elements)
4050 if (Tile[lx][ly] != EL_EMPTY)
4052 DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
4054 mask_mode = USE_MASKING;
4058 DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
4059 graphic, lx, ly, mask_mode);
4061 MarkTileDirty(x, y);
4064 void DrawLevelGraphicAnimation(int x, int y, int graphic)
4066 DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
4069 void DrawLevelElementAnimation(int x, int y, int element)
4071 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
4073 DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
4076 void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
4078 int sx = SCREENX(x), sy = SCREENY(y);
4080 if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
4083 if (Tile[x][y] == EL_EMPTY)
4084 graphic = el2img(GfxElementEmpty[x][y]);
4086 if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
4089 if (ANIM_MODE(graphic) & (ANIM_TILED | ANIM_RANDOM_STATIC))
4092 DrawGraphicAnimation(sx, sy, graphic);
4095 if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
4096 DrawLevelFieldCrumbled(x, y);
4098 if (GFX_CRUMBLED(Tile[x][y]))
4099 DrawLevelFieldCrumbled(x, y);
4103 void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
4105 int sx = SCREENX(x), sy = SCREENY(y);
4108 if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
4111 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
4113 if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
4116 DrawGraphicAnimation(sx, sy, graphic);
4118 if (GFX_CRUMBLED(element))
4119 DrawLevelFieldCrumbled(x, y);
4122 static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
4124 if (player->use_murphy)
4126 // this works only because currently only one player can be "murphy" ...
4127 static int last_horizontal_dir = MV_LEFT;
4128 int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
4130 if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
4131 last_horizontal_dir = move_dir;
4133 if (graphic == IMG_SP_MURPHY) // undefined => use special graphic
4135 int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
4137 graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
4143 return el_act_dir2img(player->artwork_element, player->GfxAction, move_dir);
4146 static boolean equalGraphics(int graphic1, int graphic2)
4148 struct GraphicInfo *g1 = &graphic_info[graphic1];
4149 struct GraphicInfo *g2 = &graphic_info[graphic2];
4151 return (g1->bitmap == g2->bitmap &&
4152 g1->src_x == g2->src_x &&
4153 g1->src_y == g2->src_y &&
4154 g1->anim_frames == g2->anim_frames &&
4155 g1->anim_delay == g2->anim_delay &&
4156 g1->anim_mode == g2->anim_mode);
4159 #define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
4163 DRAW_PLAYER_STAGE_INIT = 0,
4164 DRAW_PLAYER_STAGE_LAST_FIELD,
4165 DRAW_PLAYER_STAGE_FIELD_UNDER_PLAYER,
4166 #if DRAW_PLAYER_OVER_PUSHED_ELEMENT
4167 DRAW_PLAYER_STAGE_ELEMENT_PUSHED,
4168 DRAW_PLAYER_STAGE_PLAYER,
4170 DRAW_PLAYER_STAGE_PLAYER,
4171 DRAW_PLAYER_STAGE_ELEMENT_PUSHED,
4173 DRAW_PLAYER_STAGE_ELEMENT_OVER_PLAYER,
4174 DRAW_PLAYER_STAGE_FIELD_OVER_PLAYER,
4176 NUM_DRAW_PLAYER_STAGES
4179 static void DrawPlayerExt(struct PlayerInfo *player, int drawing_stage)
4181 static int static_last_player_graphic[MAX_PLAYERS];
4182 static int static_last_player_frame[MAX_PLAYERS];
4183 static boolean static_player_is_opaque[MAX_PLAYERS];
4184 static boolean draw_player[MAX_PLAYERS];
4185 int pnr = player->index_nr;
4187 if (drawing_stage == DRAW_PLAYER_STAGE_INIT)
4189 static_last_player_graphic[pnr] = getPlayerGraphic(player, player->MovDir);
4190 static_last_player_frame[pnr] = player->Frame;
4191 static_player_is_opaque[pnr] = FALSE;
4193 draw_player[pnr] = TRUE;
4196 if (!draw_player[pnr])
4200 if (!IN_LEV_FIELD(player->jx, player->jy))
4202 Debug("draw:DrawPlayerExt", "x = %d, y = %d", player->jx, player->jy);
4203 Debug("draw:DrawPlayerExt", "This should never happen!");
4205 draw_player[pnr] = FALSE;
4211 int last_player_graphic = static_last_player_graphic[pnr];
4212 int last_player_frame = static_last_player_frame[pnr];
4213 boolean player_is_opaque = static_player_is_opaque[pnr];
4215 int jx = player->jx;
4216 int jy = player->jy;
4217 int move_dir = (player->is_waiting ? player->dir_waiting : player->MovDir);
4218 int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
4219 int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? +1 : 0);
4220 int last_jx = (player->is_moving ? jx - dx : jx);
4221 int last_jy = (player->is_moving ? jy - dy : jy);
4222 int next_jx = jx + dx;
4223 int next_jy = jy + dy;
4224 boolean player_is_moving = (player->MovPos != 0 ? TRUE : FALSE);
4225 int sx = SCREENX(jx);
4226 int sy = SCREENY(jy);
4227 int sxx = (move_dir == MV_LEFT || move_dir == MV_RIGHT ? player->GfxPos : 0);
4228 int syy = (move_dir == MV_UP || move_dir == MV_DOWN ? player->GfxPos : 0);
4229 int element = Tile[jx][jy];
4230 int last_element = Tile[last_jx][last_jy];
4231 int action = (player->is_pushing ? ACTION_PUSHING :
4232 player->is_digging ? ACTION_DIGGING :
4233 player->is_collecting ? ACTION_COLLECTING :
4234 player->is_moving ? ACTION_MOVING :
4235 player->is_snapping ? ACTION_SNAPPING :
4236 player->is_dropping ? ACTION_DROPPING :
4237 player->is_waiting ? player->action_waiting :
4240 if (drawing_stage == DRAW_PLAYER_STAGE_INIT)
4242 // ------------------------------------------------------------------------
4243 // initialize drawing the player
4244 // ------------------------------------------------------------------------
4246 draw_player[pnr] = FALSE;
4248 // GfxElement[][] is set to the element the player is digging or collecting;
4249 // remove also for off-screen player if the player is not moving anymore
4250 if (IN_LEV_FIELD(jx, jy) && !player_is_moving)
4251 GfxElement[jx][jy] = EL_UNDEFINED;
4253 if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
4256 if (element == EL_EXPLOSION)
4259 InitPlayerGfxAnimation(player, action, move_dir);
4261 draw_player[pnr] = TRUE;
4263 else if (drawing_stage == DRAW_PLAYER_STAGE_LAST_FIELD)
4265 // ------------------------------------------------------------------------
4266 // draw things in the field the player is leaving, if needed
4267 // ------------------------------------------------------------------------
4269 if (!IN_SCR_FIELD(sx, sy))
4270 draw_player[pnr] = FALSE;
4272 if (!player->is_moving)
4275 if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
4277 DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
4279 if (last_element == EL_DYNAMITE_ACTIVE ||
4280 last_element == EL_EM_DYNAMITE_ACTIVE ||
4281 last_element == EL_SP_DISK_RED_ACTIVE)
4282 DrawDynamite(last_jx, last_jy);
4284 DrawLevelFieldThruMask(last_jx, last_jy);
4286 else if (last_element == EL_DYNAMITE_ACTIVE ||
4287 last_element == EL_EM_DYNAMITE_ACTIVE ||
4288 last_element == EL_SP_DISK_RED_ACTIVE)
4289 DrawDynamite(last_jx, last_jy);
4291 DrawLevelField(last_jx, last_jy);
4293 else if (drawing_stage == DRAW_PLAYER_STAGE_FIELD_UNDER_PLAYER)
4295 // ------------------------------------------------------------------------
4296 // draw things behind the player, if needed
4297 // ------------------------------------------------------------------------
4301 DrawLevelElement(jx, jy, Back[jx][jy]);
4306 if (IS_ACTIVE_BOMB(element))
4308 DrawLevelElement(jx, jy, EL_EMPTY);
4313 if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
4315 int old_element = GfxElement[jx][jy];
4316 int old_graphic = el_act_dir2img(old_element, action, move_dir);
4317 int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
4319 if (GFX_CRUMBLED(old_element))
4320 DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
4322 DrawScreenGraphic(sx, sy, old_graphic, frame);
4324 if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
4325 static_player_is_opaque[pnr] = TRUE;
4329 GfxElement[jx][jy] = EL_UNDEFINED;
4331 // make sure that pushed elements are drawn with correct frame rate
4332 int graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
4334 if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
4335 GfxFrame[jx][jy] = player->StepFrame;
4337 DrawLevelField(jx, jy);
4340 else if (drawing_stage == DRAW_PLAYER_STAGE_ELEMENT_PUSHED)
4342 // ------------------------------------------------------------------------
4343 // draw things the player is pushing, if needed
4344 // ------------------------------------------------------------------------
4346 if (!player->is_pushing || !player->is_moving)
4349 if (Tile[next_jx][next_jy] == EL_EXPLOSION)
4352 int gfx_frame = GfxFrame[jx][jy];
4354 if (!IS_MOVING(jx, jy)) // push movement already finished
4356 element = Tile[next_jx][next_jy];
4357 gfx_frame = GfxFrame[next_jx][next_jy];
4360 int graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
4361 int sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
4362 int frame = getGraphicAnimationFrame(graphic, sync_frame);
4364 // draw background element under pushed element (like the Sokoban field)
4365 if (game.use_masked_pushing && IS_MOVING(jx, jy))
4367 // this allows transparent pushing animation over non-black background
4370 DrawLevelElement(jx, jy, Back[jx][jy]);
4372 DrawLevelElement(jx, jy, EL_EMPTY);
4375 if (Back[next_jx][next_jy])
4376 DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
4378 DrawLevelElement(next_jx, next_jy, EL_EMPTY);
4380 int px = SCREENX(jx), py = SCREENY(jy);
4381 int pxx = (TILEX - ABS(sxx)) * dx;
4382 int pyy = (TILEY - ABS(syy)) * dy;
4385 // do not draw (EM style) pushing animation when pushing is finished
4386 // (two-tile animations usually do not contain start and end frame)
4387 if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
4388 DrawLevelElement(next_jx, next_jy, Tile[next_jx][next_jy]);
4390 DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4392 // masked drawing is needed for EMC style (double) movement graphics
4393 // !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!!
4394 DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
4397 else if (drawing_stage == DRAW_PLAYER_STAGE_PLAYER)
4399 // ------------------------------------------------------------------------
4400 // draw player himself
4401 // ------------------------------------------------------------------------
4403 int graphic = getPlayerGraphic(player, move_dir);
4405 // in the case of changed player action or direction, prevent the current
4406 // animation frame from being restarted for identical animations
4407 if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
4408 player->Frame = last_player_frame;
4410 int frame = getGraphicAnimationFrame(graphic, player->Frame);
4412 if (player_is_opaque)
4413 DrawGraphicShifted(sx,sy, sxx,syy, graphic, frame, NO_CUTTING,NO_MASKING);
4415 DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4417 if (SHIELD_ON(player))
4419 graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
4420 IMG_SHIELD_NORMAL_ACTIVE);
4421 frame = getGraphicAnimationFrame(graphic, -1);
4423 DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
4426 else if (drawing_stage == DRAW_PLAYER_STAGE_ELEMENT_OVER_PLAYER)
4428 // ------------------------------------------------------------------------
4429 // draw things in front of player (active dynamite or dynabombs)
4430 // ------------------------------------------------------------------------
4432 if (IS_ACTIVE_BOMB(element))
4434 int graphic = el2img(element);
4435 int frame = getGraphicAnimationFrameXY(graphic, jx, jy);
4437 if (game.emulation == EMU_SUPAPLEX)
4438 DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
4440 DrawGraphicThruMask(sx, sy, graphic, frame);
4443 if (player_is_moving && last_element == EL_EXPLOSION)
4445 int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
4446 GfxElement[last_jx][last_jy] : EL_EMPTY);
4447 int graphic = el_act2img(element, ACTION_EXPLODING);
4448 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
4449 int phase = ExplodePhase[last_jx][last_jy] - 1;
4450 int frame = getGraphicAnimationFrame(graphic, phase - delay);
4453 DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
4456 else if (drawing_stage == DRAW_PLAYER_STAGE_FIELD_OVER_PLAYER)
4458 // ------------------------------------------------------------------------
4459 // draw elements the player is just walking/passing through/under
4460 // ------------------------------------------------------------------------
4462 if (player_is_moving)
4464 // handle the field the player is leaving ...
4465 if (IS_ACCESSIBLE_INSIDE(last_element))
4466 DrawLevelField(last_jx, last_jy);
4467 else if (IS_ACCESSIBLE_UNDER(last_element))
4468 DrawLevelFieldThruMask(last_jx, last_jy);
4471 // do not redraw accessible elements if the player is just pushing them
4472 if (!player_is_moving || !player->is_pushing)
4474 // ... and the field the player is entering
4475 if (IS_ACCESSIBLE_INSIDE(element))
4476 DrawLevelField(jx, jy);
4477 else if (IS_ACCESSIBLE_UNDER(element))
4478 DrawLevelFieldThruMask(jx, jy);
4481 MarkTileDirty(sx, sy);
4485 void DrawPlayer(struct PlayerInfo *player)
4489 for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4490 DrawPlayerExt(player, i);
4493 void DrawAllPlayers(void)
4497 for (i = 0; i < NUM_DRAW_PLAYER_STAGES; i++)
4498 for (j = 0; j < MAX_PLAYERS; j++)
4499 if (stored_player[j].active)
4500 DrawPlayerExt(&stored_player[j], i);
4503 void DrawPlayerField(int x, int y)
4505 if (!IS_PLAYER(x, y))
4508 DrawPlayer(PLAYERINFO(x, y));
4511 // ----------------------------------------------------------------------------
4513 void WaitForEventToContinue(void)
4515 boolean first_wait = TRUE;
4516 boolean still_wait = TRUE;
4518 if (program.headless)
4521 // simulate releasing mouse button over last gadget, if still pressed
4523 HandleGadgets(-1, -1, 0);
4525 button_status = MB_RELEASED;
4528 ClearPlayerAction();
4534 if (NextValidEvent(&event))
4538 case EVENT_BUTTONPRESS:
4539 case EVENT_FINGERPRESS:
4543 case EVENT_BUTTONRELEASE:
4544 case EVENT_FINGERRELEASE:
4545 still_wait = first_wait;
4548 case EVENT_KEYPRESS:
4549 case SDL_CONTROLLERBUTTONDOWN:
4550 case SDL_JOYBUTTONDOWN:
4555 HandleOtherEvents(&event);
4559 else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4564 if (!PendingEvent())
4569 static int RequestHandleEvents(unsigned int req_state, int draw_buffer_game)
4571 boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
4572 int draw_buffer_last = GetDrawtoField();
4573 int width = request.width;
4574 int height = request.height;
4578 setRequestPosition(&sx, &sy, FALSE);
4580 button_status = MB_RELEASED;
4582 request_gadget_id = -1;
4589 SetDrawtoField(draw_buffer_game);
4591 HandleGameActions();
4593 SetDrawtoField(DRAW_TO_BACKBUFFER);
4600 while (NextValidEvent(&event))
4604 case EVENT_BUTTONPRESS:
4605 case EVENT_BUTTONRELEASE:
4606 case EVENT_MOTIONNOTIFY:
4608 DrawBuffer *drawto_last = drawto;
4611 if (event.type == EVENT_MOTIONNOTIFY)
4616 motion_status = TRUE;
4617 mx = ((MotionEvent *) &event)->x;
4618 my = ((MotionEvent *) &event)->y;
4622 motion_status = FALSE;
4623 mx = ((ButtonEvent *) &event)->x;
4624 my = ((ButtonEvent *) &event)->y;
4625 if (event.type == EVENT_BUTTONPRESS)
4626 button_status = ((ButtonEvent *) &event)->button;
4628 button_status = MB_RELEASED;
4631 if (global.use_envelope_request)
4633 // draw changed button states to temporary bitmap
4634 drawto = bitmap_db_store_1;
4637 // this sets 'request_gadget_id'
4638 HandleGadgets(mx, my, button_status);
4640 if (global.use_envelope_request)
4642 // restore pointer to drawing buffer
4643 drawto = drawto_last;
4645 // prepare complete envelope request from temporary bitmap
4646 PrepareEnvelopeRequestToScreen(bitmap_db_store_1, sx, sy,
4650 switch (request_gadget_id)
4652 case TOOL_CTRL_ID_YES:
4653 case TOOL_CTRL_ID_TOUCH_YES:
4656 case TOOL_CTRL_ID_NO:
4657 case TOOL_CTRL_ID_TOUCH_NO:
4660 case TOOL_CTRL_ID_CONFIRM:
4661 case TOOL_CTRL_ID_TOUCH_CONFIRM:
4662 result = TRUE | FALSE;
4665 case TOOL_CTRL_ID_PLAYER_1:
4668 case TOOL_CTRL_ID_PLAYER_2:
4671 case TOOL_CTRL_ID_PLAYER_3:
4674 case TOOL_CTRL_ID_PLAYER_4:
4682 // only needed to handle clickable pointer animations here
4683 HandleGlobalAnimClicks(mx, my, button_status, FALSE);
4688 case SDL_WINDOWEVENT:
4689 HandleWindowEvent((WindowEvent *) &event);
4692 case SDL_APP_WILLENTERBACKGROUND:
4693 case SDL_APP_DIDENTERBACKGROUND:
4694 case SDL_APP_WILLENTERFOREGROUND:
4695 case SDL_APP_DIDENTERFOREGROUND:
4696 HandlePauseResumeEvent((PauseResumeEvent *) &event);
4699 case EVENT_KEYPRESS:
4701 Key key = GetEventKey((KeyEvent *)&event);
4706 if (req_state & REQ_CONFIRM)
4715 #if defined(KSYM_Rewind)
4716 case KSYM_Rewind: // for Amazon Fire TV remote
4725 #if defined(KSYM_FastForward)
4726 case KSYM_FastForward: // for Amazon Fire TV remote
4732 HandleKeysDebug(key, KEY_PRESSED);
4736 if (req_state & REQ_PLAYER)
4738 int old_player_nr = setup.network_player_nr;
4741 result = old_player_nr + 1;
4746 result = old_player_nr + 1;
4777 case EVENT_FINGERRELEASE:
4778 case EVENT_KEYRELEASE:
4779 ClearPlayerAction();
4782 case SDL_CONTROLLERBUTTONDOWN:
4783 switch (event.cbutton.button)
4785 case SDL_CONTROLLER_BUTTON_A:
4786 case SDL_CONTROLLER_BUTTON_X:
4787 case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
4788 case SDL_CONTROLLER_BUTTON_LEFTSTICK:
4792 case SDL_CONTROLLER_BUTTON_B:
4793 case SDL_CONTROLLER_BUTTON_Y:
4794 case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
4795 case SDL_CONTROLLER_BUTTON_RIGHTSTICK:
4796 case SDL_CONTROLLER_BUTTON_BACK:
4801 if (req_state & REQ_PLAYER)
4803 int old_player_nr = setup.network_player_nr;
4806 result = old_player_nr + 1;
4808 switch (event.cbutton.button)
4810 case SDL_CONTROLLER_BUTTON_DPAD_UP:
4811 case SDL_CONTROLLER_BUTTON_Y:
4815 case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
4816 case SDL_CONTROLLER_BUTTON_B:
4820 case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
4821 case SDL_CONTROLLER_BUTTON_A:
4825 case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
4826 case SDL_CONTROLLER_BUTTON_X:
4837 case SDL_CONTROLLERBUTTONUP:
4838 HandleJoystickEvent(&event);
4839 ClearPlayerAction();
4843 HandleOtherEvents(&event);
4848 else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
4850 int joy = AnyJoystick();
4852 if (joy & JOY_BUTTON_1)
4854 else if (joy & JOY_BUTTON_2)
4857 else if (AnyJoystick())
4859 int joy = AnyJoystick();
4861 if (req_state & REQ_PLAYER)
4865 else if (joy & JOY_RIGHT)
4867 else if (joy & JOY_DOWN)
4869 else if (joy & JOY_LEFT)
4877 SetDrawtoField(draw_buffer_last);
4882 static void DoRequestBefore(void)
4884 boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
4886 // when showing request dialog after game ended, deactivate game panel
4888 game.panel.active = FALSE;
4890 if (game_status == GAME_MODE_PLAYING)
4891 BlitScreenToBitmap(backbuffer);
4893 // disable deactivated drawing when quick-loading level tape recording
4894 if (tape.playing && tape.deactivate_display)
4895 TapeDeactivateDisplayOff(TRUE);
4897 SetMouseCursor(CURSOR_DEFAULT);
4899 // pause network game while waiting for request to answer
4900 if (network.enabled &&
4901 game_status == GAME_MODE_PLAYING &&
4902 !game.all_players_gone)
4903 SendToServer_PausePlaying();
4905 // simulate releasing mouse button over last gadget, if still pressed
4907 HandleGadgets(-1, -1, 0);
4912 static void DoRequestAfter(void)
4916 if (game_status == GAME_MODE_PLAYING)
4918 SetPanelBackground();
4919 SetDrawBackgroundMask(REDRAW_DOOR_1);
4923 SetDrawBackgroundMask(REDRAW_FIELD);
4926 // continue network game after request
4927 if (network.enabled &&
4928 game_status == GAME_MODE_PLAYING &&
4929 !game.all_players_gone)
4930 SendToServer_ContinuePlaying();
4932 // restore deactivated drawing when quick-loading level tape recording
4933 if (tape.playing && tape.deactivate_display)
4934 TapeDeactivateDisplayOn();
4937 static void setRequestDoorTextProperties(char *text,
4942 int *set_max_line_length)
4944 struct RectWithBorder *vp_door_1 = &viewport.door_1[game_status];
4945 struct TextPosInfo *pos = &request.button.confirm;
4946 int button_ypos = pos->y;
4947 int font_nr = FONT_TEXT_2;
4948 int font_width = getFontWidth(font_nr);
4949 int font_height = getFontHeight(font_nr);
4950 int line_height = font_height + line_spacing;
4951 int max_text_width = vp_door_1->width;
4952 int max_text_height = button_ypos - 2 * text_spacing;
4953 int max_line_length = max_text_width / font_width;
4954 int max_lines = max_text_height / line_height;
4956 if (maxWordLengthInRequestString(text) > max_line_length)
4958 font_nr = FONT_TEXT_1;
4959 font_width = getFontWidth(font_nr);
4960 max_line_length = max_text_width / font_width;
4963 *set_font_nr = font_nr;
4964 *set_max_lines = max_lines;
4965 *set_max_line_length = max_line_length;
4968 static void DrawRequestDoorText(char *text)
4970 char *text_ptr = text;
4971 int text_spacing = 8;
4972 int line_spacing = 2;
4973 int max_request_lines;
4974 int max_request_line_len;
4978 // force DOOR font inside door area
4979 SetFontStatus(GAME_MODE_PSEUDO_DOOR);
4981 setRequestDoorTextProperties(text, text_spacing, line_spacing, &font_nr,
4982 &max_request_lines, &max_request_line_len);
4984 for (text_ptr = text, ty = 0; ty < max_request_lines; ty++)
4986 char text_line[max_request_line_len + 1];
4992 for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
4994 tc = *(text_ptr + tx);
4995 if (!tc || tc == ' ' || tc == '?' || tc == '!')
4999 if ((tc == '?' || tc == '!') && tl == 0)
5009 strncpy(text_line, text_ptr, tl);
5012 DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2,
5013 DY + text_spacing + ty * (getFontHeight(font_nr) + line_spacing),
5014 text_line, font_nr);
5016 text_ptr += tl + (tc == ' ' ? 1 : 0);
5022 static int RequestDoor(char *text, unsigned int req_state)
5024 unsigned int old_door_state = GetDoorState();
5025 int draw_buffer_last = GetDrawtoField();
5028 if (old_door_state & DOOR_OPEN_1)
5030 CloseDoor(DOOR_CLOSE_1);
5032 // save old door content
5033 BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
5034 0, 0, DXSIZE, DYSIZE, DXSIZE, 0);
5037 SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
5038 SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
5040 // clear door drawing field
5041 DrawBackground(DX, DY, DXSIZE, DYSIZE);
5043 // write text for request
5044 DrawRequestDoorText(text);
5046 MapToolButtons(req_state);
5048 // copy request gadgets to door backbuffer
5049 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
5051 OpenDoor(DOOR_OPEN_1);
5053 // ---------- handle request buttons ----------
5054 result = RequestHandleEvents(req_state, draw_buffer_last);
5058 if (!(req_state & REQ_STAY_OPEN))
5060 CloseDoor(DOOR_CLOSE_1);
5062 if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
5063 (req_state & REQ_REOPEN))
5064 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
5070 static int RequestEnvelope(char *text, unsigned int req_state)
5072 int draw_buffer_last = GetDrawtoField();
5075 DrawEnvelopeRequest(text, req_state);
5076 ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
5078 // ---------- handle request buttons ----------
5079 result = RequestHandleEvents(req_state, draw_buffer_last);
5083 ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
5088 int Request(char *text, unsigned int req_state)
5090 boolean overlay_enabled = GetOverlayEnabled();
5093 game.request_active = TRUE;
5095 SetOverlayEnabled(FALSE);
5099 if (global.use_envelope_request)
5100 result = RequestEnvelope(text, req_state);
5102 result = RequestDoor(text, req_state);
5106 SetOverlayEnabled(overlay_enabled);
5108 game.request_active = FALSE;
5113 static int compareDoorPartOrderInfo(const void *object1, const void *object2)
5115 const struct DoorPartOrderInfo *dpo1 = (struct DoorPartOrderInfo *)object1;
5116 const struct DoorPartOrderInfo *dpo2 = (struct DoorPartOrderInfo *)object2;
5119 if (dpo1->sort_priority != dpo2->sort_priority)
5120 compare_result = dpo1->sort_priority - dpo2->sort_priority;
5122 compare_result = dpo1->nr - dpo2->nr;
5124 return compare_result;
5127 void InitGraphicCompatibilityInfo_Doors(void)
5133 struct DoorInfo *door;
5137 { DOOR_1, IMG_GFX_DOOR_1_PART_1, IMG_GFX_DOOR_1_PART_8, &door_1 },
5138 { DOOR_2, IMG_GFX_DOOR_2_PART_1, IMG_GFX_DOOR_2_PART_8, &door_2 },
5140 { -1, -1, -1, NULL }
5142 struct Rect door_rect_list[] =
5144 { DX, DY, DXSIZE, DYSIZE },
5145 { VX, VY, VXSIZE, VYSIZE }
5149 for (i = 0; doors[i].door_token != -1; i++)
5151 int door_token = doors[i].door_token;
5152 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5153 int part_1 = doors[i].part_1;
5154 int part_8 = doors[i].part_8;
5155 int part_2 = part_1 + 1;
5156 int part_3 = part_1 + 2;
5157 struct DoorInfo *door = doors[i].door;
5158 struct Rect *door_rect = &door_rect_list[door_index];
5159 boolean door_gfx_redefined = FALSE;
5161 // check if any door part graphic definitions have been redefined
5163 for (j = 0; door_part_controls[j].door_token != -1; j++)
5165 struct DoorPartControlInfo *dpc = &door_part_controls[j];
5166 struct FileInfo *fi = getImageListEntryFromImageID(dpc->graphic);
5168 if (dpc->door_token == door_token && fi->redefined)
5169 door_gfx_redefined = TRUE;
5172 // check for old-style door graphic/animation modifications
5174 if (!door_gfx_redefined)
5176 if (door->anim_mode & ANIM_STATIC_PANEL)
5178 door->panel.step_xoffset = 0;
5179 door->panel.step_yoffset = 0;
5182 if (door->anim_mode & (ANIM_HORIZONTAL | ANIM_VERTICAL))
5184 struct GraphicInfo *g_part_1 = &graphic_info[part_1];
5185 struct GraphicInfo *g_part_2 = &graphic_info[part_2];
5186 int num_door_steps, num_panel_steps;
5188 // remove door part graphics other than the two default wings
5190 for (j = 0; door_part_controls[j].door_token != -1; j++)
5192 struct DoorPartControlInfo *dpc = &door_part_controls[j];
5193 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5195 if (dpc->graphic >= part_3 &&
5196 dpc->graphic <= part_8)
5200 // set graphics and screen positions of the default wings
5202 g_part_1->width = door_rect->width;
5203 g_part_1->height = door_rect->height;
5204 g_part_2->width = door_rect->width;
5205 g_part_2->height = door_rect->height;
5206 g_part_2->src_x = door_rect->width;
5207 g_part_2->src_y = g_part_1->src_y;
5209 door->part_2.x = door->part_1.x;
5210 door->part_2.y = door->part_1.y;
5212 if (door->width != -1)
5214 g_part_1->width = door->width;
5215 g_part_2->width = door->width;
5217 // special treatment for graphics and screen position of right wing
5218 g_part_2->src_x += door_rect->width - door->width;
5219 door->part_2.x += door_rect->width - door->width;
5222 if (door->height != -1)
5224 g_part_1->height = door->height;
5225 g_part_2->height = door->height;
5227 // special treatment for graphics and screen position of bottom wing
5228 g_part_2->src_y += door_rect->height - door->height;
5229 door->part_2.y += door_rect->height - door->height;
5232 // set animation delays for the default wings and panels
5234 door->part_1.step_delay = door->step_delay;
5235 door->part_2.step_delay = door->step_delay;
5236 door->panel.step_delay = door->step_delay;
5238 // set animation draw order for the default wings
5240 door->part_1.sort_priority = 2; // draw left wing over ...
5241 door->part_2.sort_priority = 1; // ... right wing
5243 // set animation draw offset for the default wings
5245 if (door->anim_mode & ANIM_HORIZONTAL)
5247 door->part_1.step_xoffset = door->step_offset;
5248 door->part_1.step_yoffset = 0;
5249 door->part_2.step_xoffset = door->step_offset * -1;
5250 door->part_2.step_yoffset = 0;
5252 num_door_steps = g_part_1->width / door->step_offset;
5254 else // ANIM_VERTICAL
5256 door->part_1.step_xoffset = 0;
5257 door->part_1.step_yoffset = door->step_offset;
5258 door->part_2.step_xoffset = 0;
5259 door->part_2.step_yoffset = door->step_offset * -1;
5261 num_door_steps = g_part_1->height / door->step_offset;
5264 // set animation draw offset for the default panels
5266 if (door->step_offset > 1)
5268 num_panel_steps = 2 * door_rect->height / door->step_offset;
5269 door->panel.start_step = num_panel_steps - num_door_steps;
5270 door->panel.start_step_closing = door->panel.start_step;
5274 num_panel_steps = door_rect->height / door->step_offset;
5275 door->panel.start_step = num_panel_steps - num_door_steps / 2;
5276 door->panel.start_step_closing = door->panel.start_step;
5277 door->panel.step_delay *= 2;
5284 void InitDoors(void)
5288 for (i = 0; door_part_controls[i].door_token != -1; i++)
5290 struct DoorPartControlInfo *dpc = &door_part_controls[i];
5291 struct DoorPartOrderInfo *dpo = &door_part_order[i];
5293 // initialize "start_step_opening" and "start_step_closing", if needed
5294 if (dpc->pos->start_step_opening == 0 &&
5295 dpc->pos->start_step_closing == 0)
5297 // dpc->pos->start_step_opening = dpc->pos->start_step;
5298 dpc->pos->start_step_closing = dpc->pos->start_step;
5301 // fill structure for door part draw order (sorted below)
5303 dpo->sort_priority = dpc->pos->sort_priority;
5306 // sort door part controls according to sort_priority and graphic number
5307 qsort(door_part_order, MAX_DOOR_PARTS,
5308 sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
5311 unsigned int OpenDoor(unsigned int door_state)
5313 if (door_state & DOOR_COPY_BACK)
5315 if (door_state & DOOR_OPEN_1)
5316 BlitBitmap(bitmap_db_door_1, bitmap_db_door_1,
5317 1 * DXSIZE, 0, DXSIZE, DYSIZE, 0 * DXSIZE, 0);
5319 if (door_state & DOOR_OPEN_2)
5320 BlitBitmap(bitmap_db_door_2, bitmap_db_door_2,
5321 1 * VXSIZE, 0, VXSIZE, VYSIZE, 0 * VXSIZE, 0);
5323 door_state &= ~DOOR_COPY_BACK;
5326 return MoveDoor(door_state);
5329 unsigned int CloseDoor(unsigned int door_state)
5331 unsigned int old_door_state = GetDoorState();
5333 if (!(door_state & DOOR_NO_COPY_BACK))
5335 if (old_door_state & DOOR_OPEN_1)
5336 BlitBitmap(backbuffer, bitmap_db_door_1,
5337 DX, DY, DXSIZE, DYSIZE, 0, 0);
5339 if (old_door_state & DOOR_OPEN_2)
5340 BlitBitmap(backbuffer, bitmap_db_door_2,
5341 VX, VY, VXSIZE, VYSIZE, 0, 0);
5343 door_state &= ~DOOR_NO_COPY_BACK;
5346 return MoveDoor(door_state);
5349 unsigned int GetDoorState(void)
5351 return MoveDoor(DOOR_GET_STATE);
5354 unsigned int SetDoorState(unsigned int door_state)
5356 return MoveDoor(door_state | DOOR_SET_STATE);
5359 static int euclid(int a, int b)
5361 return (b ? euclid(b, a % b) : a);
5364 unsigned int MoveDoor(unsigned int door_state)
5366 struct Rect door_rect_list[] =
5368 { DX, DY, DXSIZE, DYSIZE },
5369 { VX, VY, VXSIZE, VYSIZE }
5371 static int door1 = DOOR_CLOSE_1;
5372 static int door2 = DOOR_CLOSE_2;
5373 DelayCounter door_delay = { 0 };
5376 if (door_state == DOOR_GET_STATE)
5377 return (door1 | door2);
5379 if (door_state & DOOR_SET_STATE)
5381 if (door_state & DOOR_ACTION_1)
5382 door1 = door_state & DOOR_ACTION_1;
5383 if (door_state & DOOR_ACTION_2)
5384 door2 = door_state & DOOR_ACTION_2;
5386 return (door1 | door2);
5389 if (!(door_state & DOOR_FORCE_REDRAW))
5391 if (door1 == DOOR_OPEN_1 && door_state & DOOR_OPEN_1)
5392 door_state &= ~DOOR_OPEN_1;
5393 else if (door1 == DOOR_CLOSE_1 && door_state & DOOR_CLOSE_1)
5394 door_state &= ~DOOR_CLOSE_1;
5395 if (door2 == DOOR_OPEN_2 && door_state & DOOR_OPEN_2)
5396 door_state &= ~DOOR_OPEN_2;
5397 else if (door2 == DOOR_CLOSE_2 && door_state & DOOR_CLOSE_2)
5398 door_state &= ~DOOR_CLOSE_2;
5401 if (global.autoplay_leveldir)
5403 door_state |= DOOR_NO_DELAY;
5404 door_state &= ~DOOR_CLOSE_ALL;
5407 if (game_status == GAME_MODE_EDITOR && !(door_state & DOOR_FORCE_ANIM))
5408 door_state |= DOOR_NO_DELAY;
5410 if (door_state & DOOR_ACTION)
5412 boolean game_ended = (game_status == GAME_MODE_PLAYING && checkGameEnded());
5413 boolean door_panel_drawn[NUM_DOORS];
5414 boolean panel_has_doors[NUM_DOORS];
5415 boolean door_part_skip[MAX_DOOR_PARTS];
5416 boolean door_part_done[MAX_DOOR_PARTS];
5417 boolean door_part_done_all;
5418 int num_steps[MAX_DOOR_PARTS];
5419 int max_move_delay = 0; // delay for complete animations of all doors
5420 int max_step_delay = 0; // delay (ms) between two animation frames
5421 int num_move_steps = 0; // number of animation steps for all doors
5422 int max_move_delay_doors_only = 0; // delay for doors only (no panel)
5423 int num_move_steps_doors_only = 0; // steps for doors only (no panel)
5427 for (i = 0; i < NUM_DOORS; i++)
5428 panel_has_doors[i] = FALSE;
5430 for (i = 0; i < MAX_DOOR_PARTS; i++)
5432 struct DoorPartControlInfo *dpc = &door_part_controls[i];
5433 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5434 int door_token = dpc->door_token;
5436 door_part_done[i] = FALSE;
5437 door_part_skip[i] = (!(door_state & door_token) ||
5441 for (i = 0; i < MAX_DOOR_PARTS; i++)
5443 int nr = door_part_order[i].nr;
5444 struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5445 struct DoorPartPosInfo *pos = dpc->pos;
5446 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5447 int door_token = dpc->door_token;
5448 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5449 boolean is_panel = DOOR_PART_IS_PANEL(nr);
5450 int step_xoffset = ABS(pos->step_xoffset);
5451 int step_yoffset = ABS(pos->step_yoffset);
5452 int step_delay = pos->step_delay;
5453 int current_door_state = door_state & door_token;
5454 boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
5455 boolean door_closing = ((current_door_state & DOOR_CLOSE) != 0);
5456 boolean part_opening = (is_panel ? door_closing : door_opening);
5457 int start_step = (part_opening ? pos->start_step_opening :
5458 pos->start_step_closing);
5459 float move_xsize = (step_xoffset ? g->width : 0);
5460 float move_ysize = (step_yoffset ? g->height : 0);
5461 int move_xsteps = (step_xoffset ? ceil(move_xsize / step_xoffset) : 0);
5462 int move_ysteps = (step_yoffset ? ceil(move_ysize / step_yoffset) : 0);
5463 int move_steps = (move_xsteps && move_ysteps ?
5464 MIN(move_xsteps, move_ysteps) :
5465 move_xsteps ? move_xsteps : move_ysteps) - start_step;
5466 int move_delay = move_steps * step_delay;
5468 if (door_part_skip[nr])
5471 max_move_delay = MAX(max_move_delay, move_delay);
5472 max_step_delay = (max_step_delay == 0 ? step_delay :
5473 euclid(max_step_delay, step_delay));
5474 num_steps[nr] = move_steps;
5478 max_move_delay_doors_only = MAX(max_move_delay_doors_only, move_delay);
5480 panel_has_doors[door_index] = TRUE;
5484 max_step_delay = MAX(1, max_step_delay); // prevent division by zero
5486 num_move_steps = max_move_delay / max_step_delay;
5487 num_move_steps_doors_only = max_move_delay_doors_only / max_step_delay;
5489 door_delay.value = max_step_delay;
5491 if ((door_state & DOOR_NO_DELAY) || setup.quick_doors)
5493 start = num_move_steps - 1;
5497 // opening door sound has priority over simultaneously closing door
5498 if (door_state & (DOOR_OPEN_1 | DOOR_OPEN_2))
5500 PlayMenuSoundStereo(SND_DOOR_OPENING, SOUND_MIDDLE);
5502 if (door_state & DOOR_OPEN_1)
5503 PlayMenuSoundStereo(SND_DOOR_1_OPENING, SOUND_MIDDLE);
5504 if (door_state & DOOR_OPEN_2)
5505 PlayMenuSoundStereo(SND_DOOR_2_OPENING, SOUND_MIDDLE);
5507 else if (door_state & (DOOR_CLOSE_1 | DOOR_CLOSE_2))
5509 PlayMenuSoundStereo(SND_DOOR_CLOSING, SOUND_MIDDLE);
5511 if (door_state & DOOR_CLOSE_1)
5512 PlayMenuSoundStereo(SND_DOOR_1_CLOSING, SOUND_MIDDLE);
5513 if (door_state & DOOR_CLOSE_2)
5514 PlayMenuSoundStereo(SND_DOOR_2_CLOSING, SOUND_MIDDLE);
5518 for (k = start; k < num_move_steps; k++)
5520 int last_frame = num_move_steps - 1; // last frame of this "for" loop
5522 door_part_done_all = TRUE;
5524 for (i = 0; i < NUM_DOORS; i++)
5525 door_panel_drawn[i] = FALSE;
5527 for (i = 0; i < MAX_DOOR_PARTS; i++)
5529 int nr = door_part_order[i].nr;
5530 struct DoorPartControlInfo *dpc = &door_part_controls[nr];
5531 struct DoorPartPosInfo *pos = dpc->pos;
5532 struct GraphicInfo *g = &graphic_info[dpc->graphic];
5533 int door_token = dpc->door_token;
5534 int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
5535 boolean is_panel = DOOR_PART_IS_PANEL(nr);
5536 boolean is_panel_and_door_has_closed = FALSE;
5537 struct Rect *door_rect = &door_rect_list[door_index];
5538 Bitmap *bitmap_db_door = (door_token == DOOR_1 ? bitmap_db_door_1 :
5540 Bitmap *bitmap = (is_panel ? bitmap_db_door : g->bitmap);
5541 int current_door_state = door_state & door_token;
5542 boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
5543 boolean door_closing = !door_opening;
5544 boolean part_opening = (is_panel ? door_closing : door_opening);
5545 boolean part_closing = !part_opening;
5546 int start_step = (part_opening ? pos->start_step_opening :
5547 pos->start_step_closing);
5548 int step_delay = pos->step_delay;
5549 int step_factor = step_delay / max_step_delay;
5550 int k1 = (step_factor ? k / step_factor + 1 : k);
5551 int k2 = (part_opening ? k1 + start_step : num_steps[nr] - k1);
5552 int kk = MAX(0, k2);
5555 int src_x, src_y, src_xx, src_yy;
5556 int dst_x, dst_y, dst_xx, dst_yy;
5559 if (door_part_skip[nr])
5562 if (!(door_state & door_token))
5570 int k2_door = (door_opening ? k : num_move_steps_doors_only - k - 1);
5571 int kk_door = MAX(0, k2_door);
5572 int sync_frame = kk_door * door_delay.value;
5573 int frame = getGraphicAnimationFrame(dpc->graphic, sync_frame);
5575 getFixedGraphicSource(dpc->graphic, frame, &bitmap,
5576 &g_src_x, &g_src_y);
5581 if (!door_panel_drawn[door_index])
5583 ClearRectangleOnBackground(drawto, door_rect->x, door_rect->y,
5584 door_rect->width, door_rect->height);
5586 door_panel_drawn[door_index] = TRUE;
5589 // draw opening or closing door parts
5591 if (pos->step_xoffset < 0) // door part on right side
5594 dst_xx = pos->x + ABS(kk * pos->step_xoffset);
5597 if (dst_xx + width > door_rect->width)
5598 width = door_rect->width - dst_xx;
5600 else // door part on left side
5603 dst_xx = pos->x - kk * pos->step_xoffset;
5607 src_xx = ABS(dst_xx);
5611 width = g->width - src_xx;
5613 if (width > door_rect->width)
5614 width = door_rect->width;
5616 // Debug("tools:MoveDoor", "k == %d [%d]", k, start_step);
5619 if (pos->step_yoffset < 0) // door part on bottom side
5622 dst_yy = pos->y + ABS(kk * pos->step_yoffset);
5625 if (dst_yy + height > door_rect->height)
5626 height = door_rect->height - dst_yy;
5628 else // door part on top side
5631 dst_yy = pos->y - kk * pos->step_yoffset;
5635 src_yy = ABS(dst_yy);
5639 height = g->height - src_yy;
5642 src_x = g_src_x + src_xx;
5643 src_y = g_src_y + src_yy;
5645 dst_x = door_rect->x + dst_xx;
5646 dst_y = door_rect->y + dst_yy;
5648 is_panel_and_door_has_closed =
5651 panel_has_doors[door_index] &&
5652 k >= num_move_steps_doors_only - 1);
5654 if (width >= 0 && width <= g->width &&
5655 height >= 0 && height <= g->height &&
5656 !is_panel_and_door_has_closed)
5658 if (is_panel || !pos->draw_masked)
5659 BlitBitmap(bitmap, drawto, src_x, src_y, width, height,
5662 BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height,
5666 redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
5668 if ((part_opening && (width < 0 || height < 0)) ||
5669 (part_closing && (width >= g->width && height >= g->height)))
5670 door_part_done[nr] = TRUE;
5672 // continue door part animations, but not panel after door has closed
5673 if (!door_part_done[nr] && !is_panel_and_door_has_closed)
5674 door_part_done_all = FALSE;
5677 if (!(door_state & DOOR_NO_DELAY))
5680 HandleGameActions();
5684 SkipUntilDelayReached(&door_delay, &k, last_frame);
5686 // prevent OS (Windows) from complaining about program not responding
5690 if (door_part_done_all)
5694 if (!(door_state & DOOR_NO_DELAY))
5696 // wait for specified door action post delay
5697 if (door_state & DOOR_ACTION_1 && door_state & DOOR_ACTION_2)
5698 door_delay.value = MAX(door_1.post_delay, door_2.post_delay);
5699 else if (door_state & DOOR_ACTION_1)
5700 door_delay.value = door_1.post_delay;
5701 else if (door_state & DOOR_ACTION_2)
5702 door_delay.value = door_2.post_delay;
5704 while (!DelayReached(&door_delay))
5707 HandleGameActions();
5714 if (door_state & DOOR_ACTION_1)
5715 door1 = door_state & DOOR_ACTION_1;
5716 if (door_state & DOOR_ACTION_2)
5717 door2 = door_state & DOOR_ACTION_2;
5719 // draw masked border over door area
5720 DrawMaskedBorder(REDRAW_DOOR_1);
5721 DrawMaskedBorder(REDRAW_DOOR_2);
5723 ClearAutoRepeatKeyEvents();
5725 return (door1 | door2);
5728 static boolean useSpecialEditorDoor(void)
5730 int graphic = IMG_GLOBAL_BORDER_EDITOR;
5731 boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
5733 // do not draw special editor door if editor border defined or redefined
5734 if (graphic_info[graphic].bitmap != NULL || redefined)
5737 // do not draw special editor door if global border defined to be empty
5738 if (graphic_info[IMG_GLOBAL_BORDER].bitmap == NULL)
5741 // do not draw special editor door if viewport definitions do not match
5745 EY + EYSIZE != VY + VYSIZE)
5751 void DrawSpecialEditorDoor(void)
5753 struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5754 int top_border_width = gfx1->width;
5755 int top_border_height = gfx1->height;
5756 int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5757 int ex = EX - outer_border;
5758 int ey = EY - outer_border;
5759 int vy = VY - outer_border;
5760 int exsize = EXSIZE + 2 * outer_border;
5762 if (!useSpecialEditorDoor())
5765 // draw bigger level editor toolbox window
5766 BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
5767 top_border_width, top_border_height, ex, ey - top_border_height);
5768 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
5769 exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
5771 redraw_mask |= REDRAW_ALL;
5774 void UndrawSpecialEditorDoor(void)
5776 struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
5777 int top_border_width = gfx1->width;
5778 int top_border_height = gfx1->height;
5779 int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
5780 int ex = EX - outer_border;
5781 int ey = EY - outer_border;
5782 int ey_top = ey - top_border_height;
5783 int exsize = EXSIZE + 2 * outer_border;
5784 int eysize = EYSIZE + 2 * outer_border;
5786 if (!useSpecialEditorDoor())
5789 // draw normal tape recorder window
5790 if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
5792 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5793 ex, ey_top, top_border_width, top_border_height,
5795 BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
5796 ex, ey, exsize, eysize, ex, ey);
5800 // if screen background is set to "[NONE]", clear editor toolbox window
5801 ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
5802 ClearRectangle(drawto, ex, ey, exsize, eysize);
5805 redraw_mask |= REDRAW_ALL;
5809 // ---------- new tool button stuff -------------------------------------------
5814 struct TextPosInfo *pos;
5816 boolean is_touch_button;
5818 } toolbutton_info[NUM_TOOL_BUTTONS] =
5821 IMG_GFX_REQUEST_BUTTON_YES, &request.button.yes,
5822 TOOL_CTRL_ID_YES, FALSE, "yes"
5825 IMG_GFX_REQUEST_BUTTON_NO, &request.button.no,
5826 TOOL_CTRL_ID_NO, FALSE, "no"
5829 IMG_GFX_REQUEST_BUTTON_CONFIRM, &request.button.confirm,
5830 TOOL_CTRL_ID_CONFIRM, FALSE, "confirm"
5833 IMG_GFX_REQUEST_BUTTON_PLAYER_1, &request.button.player_1,
5834 TOOL_CTRL_ID_PLAYER_1, FALSE, "player 1"
5837 IMG_GFX_REQUEST_BUTTON_PLAYER_2, &request.button.player_2,
5838 TOOL_CTRL_ID_PLAYER_2, FALSE, "player 2"
5841 IMG_GFX_REQUEST_BUTTON_PLAYER_3, &request.button.player_3,
5842 TOOL_CTRL_ID_PLAYER_3, FALSE, "player 3"
5845 IMG_GFX_REQUEST_BUTTON_PLAYER_4, &request.button.player_4,
5846 TOOL_CTRL_ID_PLAYER_4, FALSE, "player 4"
5849 IMG_GFX_REQUEST_BUTTON_TOUCH_YES, &request.button.touch_yes,
5850 TOOL_CTRL_ID_TOUCH_YES, TRUE, "yes"
5853 IMG_GFX_REQUEST_BUTTON_TOUCH_NO, &request.button.touch_no,
5854 TOOL_CTRL_ID_TOUCH_NO, TRUE, "no"
5857 IMG_GFX_REQUEST_BUTTON_TOUCH_CONFIRM, &request.button.touch_confirm,
5858 TOOL_CTRL_ID_TOUCH_CONFIRM, TRUE, "confirm"
5862 void CreateToolButtons(void)
5866 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5868 int graphic = toolbutton_info[i].graphic;
5869 struct GraphicInfo *gfx = &graphic_info[graphic];
5870 struct TextPosInfo *pos = toolbutton_info[i].pos;
5871 struct GadgetInfo *gi;
5872 Bitmap *deco_bitmap = None;
5873 int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
5874 unsigned int event_mask = GD_EVENT_RELEASED;
5875 boolean is_touch_button = toolbutton_info[i].is_touch_button;
5876 int base_x = (is_touch_button ? 0 : DX);
5877 int base_y = (is_touch_button ? 0 : DY);
5878 int gd_x = gfx->src_x;
5879 int gd_y = gfx->src_y;
5880 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
5881 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
5886 // do not use touch buttons if overlay touch buttons are disabled
5887 if (is_touch_button && !setup.touch.overlay_buttons)
5890 if (global.use_envelope_request && !is_touch_button)
5892 setRequestPosition(&base_x, &base_y, TRUE);
5894 // check if request buttons are outside of envelope and fix, if needed
5895 if (x < 0 || x + gfx->width > request.width ||
5896 y < 0 || y + gfx->height > request.height)
5898 if (id == TOOL_CTRL_ID_YES)
5901 y = request.height - 2 * request.border_size - gfx->height;
5903 else if (id == TOOL_CTRL_ID_NO)
5905 x = request.width - 2 * request.border_size - gfx->width;
5906 y = request.height - 2 * request.border_size - gfx->height;
5908 else if (id == TOOL_CTRL_ID_CONFIRM)
5910 x = (request.width - 2 * request.border_size - gfx->width) / 2;
5911 y = request.height - 2 * request.border_size - gfx->height;
5913 else if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
5915 int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5917 x = (request.width - 2 * request.border_size - gfx->width) / 2;
5918 y = request.height - 2 * request.border_size - gfx->height * 2;
5920 x += (player_nr == 3 ? -1 : player_nr == 1 ? +1 : 0) * gfx->width;
5921 y += (player_nr == 0 ? -1 : player_nr == 2 ? +1 : 0) * gfx->height;
5926 if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4 &&
5929 int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
5931 getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
5932 pos->size, &deco_bitmap, &deco_x, &deco_y);
5933 deco_xpos = (gfx->width - pos->size) / 2;
5934 deco_ypos = (gfx->height - pos->size) / 2;
5937 gi = CreateGadget(GDI_CUSTOM_ID, id,
5938 GDI_IMAGE_ID, graphic,
5939 GDI_INFO_TEXT, toolbutton_info[i].infotext,
5942 GDI_WIDTH, gfx->width,
5943 GDI_HEIGHT, gfx->height,
5944 GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
5945 GDI_STATE, GD_BUTTON_UNPRESSED,
5946 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
5947 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
5948 GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
5949 GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
5950 GDI_DECORATION_SIZE, pos->size, pos->size,
5951 GDI_DECORATION_SHIFTING, 1, 1,
5952 GDI_DIRECT_DRAW, FALSE,
5953 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
5954 GDI_EVENT_MASK, event_mask,
5955 GDI_CALLBACK_ACTION, HandleToolButtons,
5959 Fail("cannot create gadget");
5961 tool_gadget[id] = gi;
5965 void FreeToolButtons(void)
5969 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
5970 FreeGadget(tool_gadget[i]);
5973 static void MapToolButtons(unsigned int req_state)
5975 if (req_state & REQ_ASK)
5977 MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
5978 MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
5979 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_YES]);
5980 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_NO]);
5982 else if (req_state & REQ_CONFIRM)
5984 MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
5985 MapGadget(tool_gadget[TOOL_CTRL_ID_TOUCH_CONFIRM]);
5987 else if (req_state & REQ_PLAYER)
5989 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
5990 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
5991 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
5992 MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
5996 static void UnmapToolButtons(void)
6000 for (i = 0; i < NUM_TOOL_BUTTONS; i++)
6001 UnmapGadget(tool_gadget[i]);
6004 static void HandleToolButtons(struct GadgetInfo *gi)
6006 request_gadget_id = gi->custom_id;
6009 static struct Mapping_BD_to_RND_object
6012 boolean is_rnd_to_bd_mapping; // unique mapping BD <-> RND
6018 bd_object_mapping_list[] =
6020 // additional RND style elements mapped to BD style elements must be listed first
6036 EL_STEELWALL, -1, -1
6040 EL_BD_DIAMOND, -1, -1
6060 EL_EXIT_CLOSED, -1, -1
6063 // BD style elements with their corresponding RND style elements
6074 O_DIRT_SLOPED_UP_RIGHT, TRUE,
6075 EL_BD_SAND_SLOPED_UP_RIGHT, -1, -1
6078 O_DIRT_SLOPED_UP_LEFT, TRUE,
6079 EL_BD_SAND_SLOPED_UP_LEFT, -1, -1
6082 O_DIRT_SLOPED_DOWN_LEFT, TRUE,
6083 EL_BD_SAND_SLOPED_DOWN_LEFT, -1, -1
6086 O_DIRT_SLOPED_DOWN_RIGHT, TRUE,
6087 EL_BD_SAND_SLOPED_DOWN_RIGHT, -1, -1
6091 EL_BD_SAND_BALL, -1, -1
6094 O_DIRT_BALL_F, FALSE,
6095 EL_BD_SAND_BALL, ACTION_FALLING, -1
6099 EL_BD_SAND_LOOSE, -1, -1
6102 O_DIRT_LOOSE_F, FALSE,
6103 EL_BD_SAND_LOOSE, ACTION_FALLING, -1
6107 EL_BD_SAND_2, -1, -1
6114 O_BRICK_SLOPED_UP_RIGHT, TRUE,
6115 EL_BD_WALL_SLOPED_UP_RIGHT, -1, -1
6118 O_BRICK_SLOPED_UP_LEFT, TRUE,
6119 EL_BD_WALL_SLOPED_UP_LEFT, -1, -1
6122 O_BRICK_SLOPED_DOWN_LEFT, TRUE,
6123 EL_BD_WALL_SLOPED_DOWN_LEFT, -1, -1
6126 O_BRICK_SLOPED_DOWN_RIGHT, TRUE,
6127 EL_BD_WALL_SLOPED_DOWN_RIGHT, -1, -1
6130 O_BRICK_NON_SLOPED, TRUE,
6131 EL_BD_WALL_NON_SLOPED, -1, -1
6135 EL_BD_MAGIC_WALL, ACTION_ACTIVE, -1
6139 EL_BD_EXIT_CLOSED, -1, -1
6143 EL_BD_EXIT_OPEN, -1, -1
6146 O_PRE_INVIS_OUTBOX, TRUE,
6147 EL_BD_INVISIBLE_EXIT_CLOSED, -1, -1
6150 O_INVIS_OUTBOX, TRUE,
6151 EL_BD_INVISIBLE_EXIT_OPEN, -1, -1
6155 EL_BD_STEELWALL, -1, -1
6158 O_STEEL_SLOPED_UP_RIGHT, TRUE,
6159 EL_BD_STEELWALL_SLOPED_UP_RIGHT, -1, -1
6162 O_STEEL_SLOPED_UP_LEFT, TRUE,
6163 EL_BD_STEELWALL_SLOPED_UP_LEFT, -1, -1
6166 O_STEEL_SLOPED_DOWN_LEFT, TRUE,
6167 EL_BD_STEELWALL_SLOPED_DOWN_LEFT, -1, -1
6170 O_STEEL_SLOPED_DOWN_RIGHT, TRUE,
6171 EL_BD_STEELWALL_SLOPED_DOWN_RIGHT, -1, -1
6174 O_STEEL_EXPLODABLE, TRUE,
6175 EL_BD_STEELWALL_EXPLODABLE, -1, -1
6178 O_STEEL_EATABLE, TRUE,
6179 EL_BD_STEELWALL_DIGGABLE, -1, -1
6182 O_BRICK_EATABLE, TRUE,
6183 EL_BD_WALL_DIGGABLE, -1, -1
6191 EL_BD_ROCK, ACTION_FALLING, -1
6194 O_FLYING_STONE, TRUE,
6195 EL_BD_FLYING_ROCK, -1, -1
6198 O_FLYING_STONE_F, FALSE,
6199 EL_BD_FLYING_ROCK, ACTION_FALLING, -1
6203 EL_BD_MEGA_ROCK, -1, -1
6206 O_MEGA_STONE_F, FALSE,
6207 EL_BD_MEGA_ROCK, ACTION_FALLING, -1
6211 EL_BD_DIAMOND, -1, -1
6215 EL_BD_DIAMOND, ACTION_FALLING, -1
6218 O_FLYING_DIAMOND, TRUE,
6219 EL_BD_FLYING_DIAMOND, -1, -1
6222 O_FLYING_DIAMOND_F, FALSE,
6223 EL_BD_FLYING_DIAMOND, ACTION_FALLING, -1
6231 EL_BD_NUT, ACTION_FALLING, -1
6234 O_BLADDER_SPENDER, TRUE,
6235 EL_BD_BLADDER_SPENDER, -1, -1
6242 O_H_EXPANDING_WALL, TRUE,
6243 EL_BD_EXPANDABLE_WALL_HORIZONTAL, -1, -1
6246 O_V_EXPANDING_WALL, TRUE,
6247 EL_BD_EXPANDABLE_WALL_VERTICAL, -1, -1
6250 O_EXPANDING_WALL, TRUE,
6251 EL_BD_EXPANDABLE_WALL_ANY, -1, -1
6254 O_H_EXPANDING_STEEL_WALL, TRUE,
6255 EL_BD_EXPANDABLE_STEELWALL_HORIZONTAL, -1, -1
6258 O_V_EXPANDING_STEEL_WALL, TRUE,
6259 EL_BD_EXPANDABLE_STEELWALL_VERTICAL, -1, -1
6262 O_EXPANDING_STEEL_WALL, TRUE,
6263 EL_BD_EXPANDABLE_STEELWALL_ANY, -1, -1
6266 O_EXPANDING_WALL_SWITCH, TRUE,
6267 EL_BD_EXPANDABLE_WALL_SWITCH_HORIZONTAL, -1, -1
6270 O_CREATURE_SWITCH, TRUE,
6271 EL_BD_CREATURE_SWITCH, -1, -1
6274 O_BITER_SWITCH, TRUE,
6275 EL_BD_BITER_SWITCH_1, -1, -1
6278 O_REPLICATOR_SWITCH, TRUE,
6279 EL_BD_REPLICATOR_SWITCH, -1, -1
6282 O_CONVEYOR_SWITCH, TRUE,
6283 EL_BD_CONVEYOR_SWITCH, -1, -1
6286 O_CONVEYOR_DIR_SWITCH, TRUE,
6287 EL_BD_CONVEYOR_DIR_SWITCH_NORMAL, -1, -1
6294 O_FALLING_WALL, TRUE,
6295 EL_BD_FALLING_WALL, -1, -1
6298 O_FALLING_WALL_F, FALSE,
6299 EL_BD_FALLING_WALL, ACTION_FALLING, -1
6306 O_TIME_PENALTY, TRUE,
6307 EL_BD_TIME_PENALTY, -1, -1
6311 EL_BD_GRAVESTONE, -1, -1
6314 O_STONE_GLUED, TRUE,
6315 EL_BD_ROCK_GLUED, -1, -1
6318 O_DIAMOND_GLUED, TRUE,
6319 EL_BD_DIAMOND_GLUED, -1, -1
6322 O_DIAMOND_KEY, TRUE,
6323 EL_BD_DIAMOND_KEY, -1, -1
6326 O_TRAPPED_DIAMOND, TRUE,
6327 EL_BD_TRAPPED_DIAMOND, -1, -1
6335 EL_BD_SAND_GLUED, -1, -1
6351 EL_BD_GATE_1, -1, -1
6355 EL_BD_GATE_2, -1, -1
6359 EL_BD_GATE_3, -1, -1
6366 O_GRAVITY_SWITCH, TRUE,
6367 EL_BD_GRAVITY_SWITCH, -1, -1
6370 O_PNEUMATIC_HAMMER, TRUE,
6371 EL_BD_PNEUMATIC_HAMMER, -1, -1
6375 EL_BD_TELEPORTER, -1, -1
6379 EL_BD_SKELETON, -1, -1
6451 EL_BD_COW_LEFT, -1, -1
6455 EL_BD_COW_UP, -1, -1
6459 EL_BD_COW_RIGHT, -1, -1
6463 EL_BD_COW_DOWN, -1, -1
6466 O_COW_ENCLOSED_1, FALSE,
6467 EL_BD_COW_DOWN, -1, -1
6470 O_COW_ENCLOSED_2, FALSE,
6471 EL_BD_COW_DOWN, -1, -1
6474 O_COW_ENCLOSED_3, FALSE,
6475 EL_BD_COW_DOWN, -1, -1
6478 O_COW_ENCLOSED_4, FALSE,
6479 EL_BD_COW_DOWN, -1, -1
6482 O_COW_ENCLOSED_5, FALSE,
6483 EL_BD_COW_DOWN, -1, -1
6486 O_COW_ENCLOSED_6, FALSE,
6487 EL_BD_COW_DOWN, -1, -1
6490 O_COW_ENCLOSED_7, FALSE,
6491 EL_BD_COW_DOWN, -1, -1
6494 O_WALLED_DIAMOND, TRUE,
6495 EL_BD_WALL_DIAMOND, -1, -1
6498 O_WALLED_KEY_1, TRUE,
6499 EL_BD_WALL_KEY_1, -1, -1
6502 O_WALLED_KEY_2, TRUE,
6503 EL_BD_WALL_KEY_2, -1, -1
6506 O_WALLED_KEY_3, TRUE,
6507 EL_BD_WALL_KEY_3, -1, -1
6511 EL_BD_AMOEBA, -1, -1
6515 EL_BD_AMOEBA_2, -1, -1
6519 EL_BD_REPLICATOR, -1, -1
6522 O_CONVEYOR_LEFT, TRUE,
6523 EL_BD_CONVEYOR_LEFT, -1, -1
6526 O_CONVEYOR_RIGHT, TRUE,
6527 EL_BD_CONVEYOR_RIGHT, -1, -1
6539 EL_BD_VOODOO_DOLL, -1, -1
6547 EL_BD_BLADDER, -1, -1
6551 EL_BD_BLADDER, -1, -1
6555 EL_BD_BLADDER, -1, -1
6559 EL_BD_BLADDER, -1, -1
6563 EL_BD_BLADDER, -1, -1
6567 EL_BD_BLADDER, -1, -1
6571 EL_BD_BLADDER, -1, -1
6575 EL_BD_BLADDER, -1, -1
6579 EL_BD_BLADDER, -1, -1
6582 O_WAITING_STONE, TRUE,
6583 EL_BD_WAITING_ROCK, -1, -1
6586 O_CHASING_STONE, TRUE,
6587 EL_BD_CHASING_ROCK, -1, -1
6595 EL_BD_FIREFLY_LEFT, -1, -1
6599 EL_BD_FIREFLY_UP, -1, -1
6603 EL_BD_FIREFLY_RIGHT, -1, -1
6607 EL_BD_FIREFLY_DOWN, -1, -1
6610 O_ALT_FIREFLY_1, TRUE,
6611 EL_BD_FIREFLY_2_LEFT, -1, -1
6614 O_ALT_FIREFLY_2, TRUE,
6615 EL_BD_FIREFLY_2_UP, -1, -1
6618 O_ALT_FIREFLY_3, TRUE,
6619 EL_BD_FIREFLY_2_RIGHT, -1, -1
6622 O_ALT_FIREFLY_4, TRUE,
6623 EL_BD_FIREFLY_2_DOWN, -1, -1
6627 EL_BD_BUTTERFLY_LEFT, -1, -1
6631 EL_BD_BUTTERFLY_UP, -1, -1
6635 EL_BD_BUTTERFLY_RIGHT, -1, -1
6639 EL_BD_BUTTERFLY_DOWN, -1, -1
6642 O_ALT_BUTTER_1, TRUE,
6643 EL_BD_BUTTERFLY_2_LEFT, -1, -1
6646 O_ALT_BUTTER_2, TRUE,
6647 EL_BD_BUTTERFLY_2_UP, -1, -1
6650 O_ALT_BUTTER_3, TRUE,
6651 EL_BD_BUTTERFLY_2_RIGHT, -1, -1
6654 O_ALT_BUTTER_4, TRUE,
6655 EL_BD_BUTTERFLY_2_DOWN, -1, -1
6659 EL_BD_STONEFLY_LEFT, -1, -1
6663 EL_BD_STONEFLY_UP, -1, -1
6667 EL_BD_STONEFLY_RIGHT, -1, -1
6671 EL_BD_STONEFLY_DOWN, -1, -1
6675 EL_BD_BITER_UP, -1, -1
6679 EL_BD_BITER_RIGHT, -1, -1
6683 EL_BD_BITER_DOWN, -1, -1
6687 EL_BD_BITER_LEFT, -1, -1
6690 O_DRAGONFLY_1, TRUE,
6691 EL_BD_DRAGONFLY_LEFT, -1, -1
6694 O_DRAGONFLY_2, TRUE,
6695 EL_BD_DRAGONFLY_UP, -1, -1
6698 O_DRAGONFLY_3, TRUE,
6699 EL_BD_DRAGONFLY_RIGHT, -1, -1
6702 O_DRAGONFLY_4, TRUE,
6703 EL_BD_DRAGONFLY_DOWN, -1, -1
6707 EL_BD_PLAYER, ACTION_GROWING, -1
6711 EL_BD_PLAYER, ACTION_GROWING, -1
6715 EL_BD_PLAYER, ACTION_GROWING, -1
6719 EL_BD_PLAYER, -1, -1
6722 O_PLAYER_BOMB, TRUE,
6723 EL_BD_PLAYER_WITH_BOMB, -1, -1
6726 O_PLAYER_GLUED, TRUE,
6727 EL_BD_PLAYER_GLUED, -1, -1
6730 O_PLAYER_STIRRING, TRUE,
6731 EL_BD_PLAYER_STIRRING, -1, -1
6738 O_BOMB_TICK_1, FALSE,
6739 EL_BD_BOMB, ACTION_ACTIVE, -1
6742 O_BOMB_TICK_2, FALSE,
6743 EL_BD_BOMB, ACTION_ACTIVE, -1
6746 O_BOMB_TICK_3, FALSE,
6747 EL_BD_BOMB, ACTION_ACTIVE, -1
6750 O_BOMB_TICK_4, FALSE,
6751 EL_BD_BOMB, ACTION_ACTIVE, -1
6754 O_BOMB_TICK_5, FALSE,
6755 EL_BD_BOMB, ACTION_ACTIVE, -1
6758 O_BOMB_TICK_6, FALSE,
6759 EL_BD_BOMB, ACTION_ACTIVE, -1
6762 O_BOMB_TICK_7, FALSE,
6763 EL_BD_BOMB, ACTION_ACTIVE, -1
6767 EL_BD_NITRO_PACK, -1, -1
6770 O_NITRO_PACK_F, FALSE,
6771 EL_BD_NITRO_PACK, ACTION_FALLING, -1
6774 O_NITRO_PACK_EXPLODE, FALSE,
6775 EL_BD_NITRO_PACK, ACTION_EXPLODING, -1
6778 O_PRE_CLOCK_1, FALSE,
6779 EL_BD_CLOCK, ACTION_GROWING, -1
6782 O_PRE_CLOCK_2, FALSE,
6783 EL_BD_CLOCK, ACTION_GROWING, -1
6786 O_PRE_CLOCK_3, FALSE,
6787 EL_BD_CLOCK, ACTION_GROWING, -1
6790 O_PRE_CLOCK_4, FALSE,
6791 EL_BD_CLOCK, ACTION_GROWING, -1
6795 EL_BD_DIAMOND, ACTION_GROWING, -1
6799 EL_BD_DIAMOND, ACTION_GROWING, -1
6803 EL_BD_DIAMOND, ACTION_GROWING, -1
6807 EL_BD_DIAMOND, ACTION_GROWING, -1
6811 EL_BD_DIAMOND, ACTION_GROWING, -1
6815 EL_DEFAULT, ACTION_EXPLODING, -1
6819 EL_DEFAULT, ACTION_EXPLODING, -1
6823 EL_DEFAULT, ACTION_EXPLODING, -1
6827 EL_DEFAULT, ACTION_EXPLODING, -1
6831 EL_DEFAULT, ACTION_EXPLODING, -1
6834 O_PRE_STONE_1, FALSE,
6835 EL_BD_ROCK, ACTION_GROWING, -1
6838 O_PRE_STONE_2, FALSE,
6839 EL_BD_ROCK, ACTION_GROWING, -1
6842 O_PRE_STONE_3, FALSE,
6843 EL_BD_ROCK, ACTION_GROWING, -1
6846 O_PRE_STONE_4, FALSE,
6847 EL_BD_ROCK, ACTION_GROWING, -1
6850 O_PRE_STEEL_1, FALSE,
6851 EL_BD_STEELWALL, ACTION_GROWING, -1
6854 O_PRE_STEEL_2, FALSE,
6855 EL_BD_STEELWALL, ACTION_GROWING, -1
6858 O_PRE_STEEL_3, FALSE,
6859 EL_BD_STEELWALL, ACTION_GROWING, -1
6862 O_PRE_STEEL_4, FALSE,
6863 EL_BD_STEELWALL, ACTION_GROWING, -1
6866 O_GHOST_EXPL_1, FALSE,
6867 EL_BD_GHOST, ACTION_EXPLODING, -1
6870 O_GHOST_EXPL_2, FALSE,
6871 EL_BD_GHOST, ACTION_EXPLODING, -1
6874 O_GHOST_EXPL_3, FALSE,
6875 EL_BD_GHOST, ACTION_EXPLODING, -1
6878 O_GHOST_EXPL_4, FALSE,
6879 EL_BD_GHOST, ACTION_EXPLODING, -1
6882 O_BOMB_EXPL_1, FALSE,
6883 EL_BD_BOMB, ACTION_EXPLODING, -1
6886 O_BOMB_EXPL_2, FALSE,
6887 EL_BD_BOMB, ACTION_EXPLODING, -1
6890 O_BOMB_EXPL_3, FALSE,
6891 EL_BD_BOMB, ACTION_EXPLODING, -1
6894 O_BOMB_EXPL_4, FALSE,
6895 EL_BD_BOMB, ACTION_EXPLODING, -1
6898 O_NITRO_EXPL_1, FALSE,
6899 EL_BD_NITRO_PACK, ACTION_EXPLODING, -1
6902 O_NITRO_EXPL_2, FALSE,
6903 EL_BD_NITRO_PACK, ACTION_EXPLODING, -1
6906 O_NITRO_EXPL_3, FALSE,
6907 EL_BD_NITRO_PACK, ACTION_EXPLODING, -1
6910 O_NITRO_EXPL_4, FALSE,
6911 EL_BD_NITRO_PACK, ACTION_EXPLODING, -1
6914 O_AMOEBA_2_EXPL_1, FALSE,
6915 EL_BD_AMOEBA_2, ACTION_EXPLODING, -1
6918 O_AMOEBA_2_EXPL_2, FALSE,
6919 EL_BD_AMOEBA_2, ACTION_EXPLODING, -1
6922 O_AMOEBA_2_EXPL_3, FALSE,
6923 EL_BD_AMOEBA_2, ACTION_EXPLODING, -1
6926 O_AMOEBA_2_EXPL_4, FALSE,
6927 EL_BD_AMOEBA_2, ACTION_EXPLODING, -1
6930 O_NUT_EXPL_1, FALSE,
6931 EL_BD_NUT, ACTION_BREAKING, -1
6934 O_NUT_EXPL_2, FALSE,
6935 EL_BD_NUT, ACTION_BREAKING, -1
6938 O_NUT_EXPL_3, FALSE,
6939 EL_BD_NUT, ACTION_BREAKING, -1
6942 O_NUT_EXPL_4, FALSE,
6943 EL_BD_NUT, ACTION_BREAKING, -1
6946 O_PLAYER_PNEUMATIC_LEFT, FALSE,
6947 EL_BD_PLAYER, ACTION_HITTING, MV_BIT_LEFT
6950 O_PLAYER_PNEUMATIC_RIGHT, FALSE,
6951 EL_BD_PLAYER, ACTION_HITTING, MV_BIT_RIGHT
6954 O_PNEUMATIC_ACTIVE_LEFT, TRUE,
6955 EL_BD_PNEUMATIC_HAMMER, ACTION_HITTING, MV_BIT_LEFT
6958 O_PNEUMATIC_ACTIVE_RIGHT, TRUE,
6959 EL_BD_PNEUMATIC_HAMMER, ACTION_HITTING, MV_BIT_RIGHT
6962 // helper (runtime) elements
6965 O_FAKE_BONUS, FALSE,
6966 EL_BD_FAKE_BONUS, -1, -1
6969 O_INBOX_CLOSED, FALSE,
6973 O_INBOX_OPEN, FALSE,
6974 EL_BD_INBOX, ACTION_OPENING, -1
6977 O_OUTBOX_CLOSED, FALSE,
6978 EL_BD_EXIT_CLOSED, -1, -1
6981 O_OUTBOX_OPEN, FALSE,
6982 EL_BD_EXIT_OPEN, -1, -1
6986 EL_BD_COVERED, -1, -1
6989 O_PLAYER_LEFT, FALSE,
6990 EL_BD_PLAYER, ACTION_MOVING, MV_BIT_LEFT
6993 O_PLAYER_RIGHT, FALSE,
6994 EL_BD_PLAYER, ACTION_MOVING, MV_BIT_RIGHT
6997 O_PLAYER_BLINK, FALSE,
6998 EL_BD_PLAYER, ACTION_BORING_1, -1
7001 O_PLAYER_TAP, FALSE,
7002 EL_BD_PLAYER, ACTION_BORING_2, -1
7005 O_PLAYER_TAP_BLINK, FALSE,
7006 EL_BD_PLAYER, ACTION_BORING_3, -1
7009 O_CREATURE_SWITCH_ON, FALSE,
7010 EL_BD_CREATURE_SWITCH_ACTIVE, -1, -1
7013 O_EXPANDING_WALL_SWITCH_HORIZ, FALSE,
7014 EL_BD_EXPANDABLE_WALL_SWITCH_HORIZONTAL, -1, -1
7017 O_EXPANDING_WALL_SWITCH_VERT, FALSE,
7018 EL_BD_EXPANDABLE_WALL_SWITCH_VERTICAL, -1, -1
7021 O_GRAVITY_SWITCH_ACTIVE, FALSE,
7022 EL_BD_GRAVITY_SWITCH_ACTIVE, -1, -1
7025 O_REPLICATOR_SWITCH_OFF, FALSE,
7026 EL_BD_REPLICATOR_SWITCH, -1, -1
7029 O_REPLICATOR_SWITCH_ON, FALSE,
7030 EL_BD_REPLICATOR_SWITCH_ACTIVE, -1, -1
7033 O_CONVEYOR_DIR_NORMAL, FALSE,
7034 EL_BD_CONVEYOR_DIR_SWITCH_NORMAL, -1, -1
7037 O_CONVEYOR_DIR_CHANGED, FALSE,
7038 EL_BD_CONVEYOR_DIR_SWITCH_CHANGED, -1, -1
7041 O_CONVEYOR_SWITCH_OFF, FALSE,
7042 EL_BD_CONVEYOR_SWITCH, -1, -1
7045 O_CONVEYOR_SWITCH_ON, FALSE,
7046 EL_BD_CONVEYOR_SWITCH_ACTIVE, -1, -1
7049 O_MAGIC_WALL_ACTIVE, FALSE,
7050 EL_BD_MAGIC_WALL_ACTIVE, -1, -1
7053 O_REPLICATOR_ACTIVE, FALSE,
7054 EL_BD_REPLICATOR_ACTIVE, -1, -1
7057 O_CONVEYOR_LEFT_ACTIVE, FALSE,
7058 EL_BD_CONVEYOR_LEFT_ACTIVE, -1, -1
7061 O_CONVEYOR_RIGHT_ACTIVE, FALSE,
7062 EL_BD_CONVEYOR_RIGHT_ACTIVE, -1, -1
7065 O_BITER_SWITCH_1, FALSE,
7066 EL_BD_BITER_SWITCH_1, -1, -1
7069 O_BITER_SWITCH_2, FALSE,
7070 EL_BD_BITER_SWITCH_2, -1, -1
7073 O_BITER_SWITCH_3, FALSE,
7074 EL_BD_BITER_SWITCH_3, -1, -1
7077 O_BITER_SWITCH_4, FALSE,
7078 EL_BD_BITER_SWITCH_4, -1, -1
7087 int map_element_RND_to_BD_cave(int element_rnd)
7089 static unsigned short mapping_RND_to_BD[NUM_FILE_ELEMENTS];
7090 static boolean mapping_initialized = FALSE;
7092 if (!mapping_initialized)
7096 // return "O_UNKNOWN" for all undefined elements in mapping array
7097 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
7098 mapping_RND_to_BD[i] = O_UNKNOWN;
7100 for (i = 0; bd_object_mapping_list[i].element_bd != -1; i++)
7101 if (bd_object_mapping_list[i].is_rnd_to_bd_mapping)
7102 mapping_RND_to_BD[bd_object_mapping_list[i].element_rnd] =
7103 bd_object_mapping_list[i].element_bd;
7105 mapping_initialized = TRUE;
7108 if (element_rnd < 0 || element_rnd >= NUM_FILE_ELEMENTS)
7110 Warn("invalid RND element %d", element_rnd);
7115 return mapping_RND_to_BD[element_rnd];
7118 int map_element_BD_to_RND_cave(int element_bd)
7120 static unsigned short mapping_BD_to_RND[O_MAX_ALL];
7121 static boolean mapping_initialized = FALSE;
7123 if (!mapping_initialized)
7127 // return "EL_UNKNOWN" for all undefined elements in mapping array
7128 for (i = 0; i < O_MAX_ALL; i++)
7129 mapping_BD_to_RND[i] = EL_UNKNOWN;
7131 for (i = 0; bd_object_mapping_list[i].element_bd != -1; i++)
7132 if (bd_object_mapping_list[i].is_rnd_to_bd_mapping)
7133 mapping_BD_to_RND[bd_object_mapping_list[i].element_bd] =
7134 bd_object_mapping_list[i].element_rnd;
7136 mapping_initialized = TRUE;
7139 if (element_bd < 0 || element_bd >= O_MAX_ALL)
7141 Warn("invalid BD element %d", element_bd);
7146 return mapping_BD_to_RND[element_bd];
7149 int map_element_BD_to_RND_game(int element_bd)
7151 static unsigned short mapping_BD_to_RND[O_MAX_ALL];
7152 static boolean mapping_initialized = FALSE;
7154 if (!mapping_initialized)
7158 // return "EL_UNKNOWN" for all undefined elements in mapping array
7159 for (i = 0; i < O_MAX_ALL; i++)
7160 mapping_BD_to_RND[i] = EL_UNKNOWN;
7162 for (i = 0; bd_object_mapping_list[i].element_bd != -1; i++)
7163 mapping_BD_to_RND[bd_object_mapping_list[i].element_bd] =
7164 bd_object_mapping_list[i].element_rnd;
7166 mapping_initialized = TRUE;
7169 if (element_bd < 0 || element_bd >= O_MAX_ALL)
7171 Warn("invalid BD element %d", element_bd);
7176 return mapping_BD_to_RND[element_bd];
7179 static struct Mapping_EM_to_RND_object
7182 boolean is_rnd_to_em_mapping; // unique mapping EM <-> RND
7183 boolean is_backside; // backside of moving element
7189 em_object_mapping_list[GAME_TILE_MAX + 1] =
7192 Zborder, FALSE, FALSE,
7196 Zplayer, FALSE, FALSE,
7205 Ztank, FALSE, FALSE,
7209 Zeater, FALSE, FALSE,
7213 Zdynamite, FALSE, FALSE,
7217 Zboom, FALSE, FALSE,
7222 Xchain, FALSE, FALSE,
7223 EL_DEFAULT, ACTION_EXPLODING, -1
7226 Xboom_bug, FALSE, FALSE,
7227 EL_BUG, ACTION_EXPLODING, -1
7230 Xboom_tank, FALSE, FALSE,
7231 EL_SPACESHIP, ACTION_EXPLODING, -1
7234 Xboom_android, FALSE, FALSE,
7235 EL_EMC_ANDROID, ACTION_OTHER, -1
7238 Xboom_1, FALSE, FALSE,
7239 EL_DEFAULT, ACTION_EXPLODING, -1
7242 Xboom_2, FALSE, FALSE,
7243 EL_DEFAULT, ACTION_EXPLODING, -1
7247 Xblank, TRUE, FALSE,
7252 Xsplash_e, FALSE, FALSE,
7253 EL_ACID_SPLASH_RIGHT, -1, -1
7256 Xsplash_w, FALSE, FALSE,
7257 EL_ACID_SPLASH_LEFT, -1, -1
7261 Xplant, TRUE, FALSE,
7262 EL_EMC_PLANT, -1, -1
7265 Yplant, FALSE, FALSE,
7266 EL_EMC_PLANT, -1, -1
7270 Xacid_1, TRUE, FALSE,
7274 Xacid_2, FALSE, FALSE,
7278 Xacid_3, FALSE, FALSE,
7282 Xacid_4, FALSE, FALSE,
7286 Xacid_5, FALSE, FALSE,
7290 Xacid_6, FALSE, FALSE,
7294 Xacid_7, FALSE, FALSE,
7298 Xacid_8, FALSE, FALSE,
7303 Xfake_acid_1, TRUE, FALSE,
7304 EL_EMC_FAKE_ACID, -1, -1
7307 Xfake_acid_2, FALSE, FALSE,
7308 EL_EMC_FAKE_ACID, -1, -1
7311 Xfake_acid_3, FALSE, FALSE,
7312 EL_EMC_FAKE_ACID, -1, -1
7315 Xfake_acid_4, FALSE, FALSE,
7316 EL_EMC_FAKE_ACID, -1, -1
7319 Xfake_acid_5, FALSE, FALSE,
7320 EL_EMC_FAKE_ACID, -1, -1
7323 Xfake_acid_6, FALSE, FALSE,
7324 EL_EMC_FAKE_ACID, -1, -1
7327 Xfake_acid_7, FALSE, FALSE,
7328 EL_EMC_FAKE_ACID, -1, -1
7331 Xfake_acid_8, FALSE, FALSE,
7332 EL_EMC_FAKE_ACID, -1, -1
7336 Xfake_acid_1_player, FALSE, FALSE,
7337 EL_EMC_FAKE_ACID, -1, -1
7340 Xfake_acid_2_player, FALSE, FALSE,
7341 EL_EMC_FAKE_ACID, -1, -1
7344 Xfake_acid_3_player, FALSE, FALSE,
7345 EL_EMC_FAKE_ACID, -1, -1
7348 Xfake_acid_4_player, FALSE, FALSE,
7349 EL_EMC_FAKE_ACID, -1, -1
7352 Xfake_acid_5_player, FALSE, FALSE,
7353 EL_EMC_FAKE_ACID, -1, -1
7356 Xfake_acid_6_player, FALSE, FALSE,
7357 EL_EMC_FAKE_ACID, -1, -1
7360 Xfake_acid_7_player, FALSE, FALSE,
7361 EL_EMC_FAKE_ACID, -1, -1
7364 Xfake_acid_8_player, FALSE, FALSE,
7365 EL_EMC_FAKE_ACID, -1, -1
7369 Xgrass, TRUE, FALSE,
7370 EL_EMC_GRASS, -1, -1
7373 Ygrass_nB, FALSE, FALSE,
7374 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_UP
7377 Ygrass_eB, FALSE, FALSE,
7378 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_RIGHT
7381 Ygrass_sB, FALSE, FALSE,
7382 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_DOWN
7385 Ygrass_wB, FALSE, FALSE,
7386 EL_EMC_GRASS, ACTION_DIGGING, MV_BIT_LEFT
7394 Ydirt_nB, FALSE, FALSE,
7395 EL_SAND, ACTION_DIGGING, MV_BIT_UP
7398 Ydirt_eB, FALSE, FALSE,
7399 EL_SAND, ACTION_DIGGING, MV_BIT_RIGHT
7402 Ydirt_sB, FALSE, FALSE,
7403 EL_SAND, ACTION_DIGGING, MV_BIT_DOWN
7406 Ydirt_wB, FALSE, FALSE,
7407 EL_SAND, ACTION_DIGGING, MV_BIT_LEFT
7411 Xandroid, TRUE, FALSE,
7412 EL_EMC_ANDROID, ACTION_ACTIVE, -1
7415 Xandroid_1_n, FALSE, FALSE,
7416 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
7419 Xandroid_2_n, FALSE, FALSE,
7420 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_UP
7423 Xandroid_1_e, FALSE, FALSE,
7424 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
7427 Xandroid_2_e, FALSE, FALSE,
7428 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_RIGHT
7431 Xandroid_1_w, FALSE, FALSE,
7432 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
7435 Xandroid_2_w, FALSE, FALSE,
7436 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_LEFT
7439 Xandroid_1_s, FALSE, FALSE,
7440 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
7443 Xandroid_2_s, FALSE, FALSE,
7444 EL_EMC_ANDROID, ACTION_ACTIVE, MV_BIT_DOWN
7447 Yandroid_n, FALSE, FALSE,
7448 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
7451 Yandroid_nB, FALSE, TRUE,
7452 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_UP
7455 Yandroid_ne, FALSE, FALSE,
7456 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPRIGHT
7459 Yandroid_neB, FALSE, TRUE,
7460 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPRIGHT
7463 Yandroid_e, FALSE, FALSE,
7464 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
7467 Yandroid_eB, FALSE, TRUE,
7468 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_RIGHT
7471 Yandroid_se, FALSE, FALSE,
7472 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNRIGHT
7475 Yandroid_seB, FALSE, TRUE,
7476 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNRIGHT
7479 Yandroid_s, FALSE, FALSE,
7480 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
7483 Yandroid_sB, FALSE, TRUE,
7484 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_DOWN
7487 Yandroid_sw, FALSE, FALSE,
7488 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_DOWNLEFT
7491 Yandroid_swB, FALSE, TRUE,
7492 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_DOWNLEFT
7495 Yandroid_w, FALSE, FALSE,
7496 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
7499 Yandroid_wB, FALSE, TRUE,
7500 EL_EMC_ANDROID, ACTION_MOVING, MV_BIT_LEFT
7503 Yandroid_nw, FALSE, FALSE,
7504 EL_EMC_ANDROID, ACTION_GROWING, MV_BIT_UPLEFT
7507 Yandroid_nwB, FALSE, TRUE,
7508 EL_EMC_ANDROID, ACTION_SHRINKING, MV_BIT_UPLEFT
7512 Xeater_n, TRUE, FALSE,
7513 EL_YAMYAM_UP, -1, -1
7516 Xeater_e, TRUE, FALSE,
7517 EL_YAMYAM_RIGHT, -1, -1
7520 Xeater_w, TRUE, FALSE,
7521 EL_YAMYAM_LEFT, -1, -1
7524 Xeater_s, TRUE, FALSE,
7525 EL_YAMYAM_DOWN, -1, -1
7528 Yeater_n, FALSE, FALSE,
7529 EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
7532 Yeater_nB, FALSE, TRUE,
7533 EL_YAMYAM, ACTION_MOVING, MV_BIT_UP
7536 Yeater_e, FALSE, FALSE,
7537 EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
7540 Yeater_eB, FALSE, TRUE,
7541 EL_YAMYAM, ACTION_MOVING, MV_BIT_RIGHT
7544 Yeater_s, FALSE, FALSE,
7545 EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
7548 Yeater_sB, FALSE, TRUE,
7549 EL_YAMYAM, ACTION_MOVING, MV_BIT_DOWN
7552 Yeater_w, FALSE, FALSE,
7553 EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
7556 Yeater_wB, FALSE, TRUE,
7557 EL_YAMYAM, ACTION_MOVING, MV_BIT_LEFT
7560 Yeater_stone, FALSE, FALSE,
7561 EL_YAMYAM, ACTION_SMASHED_BY_ROCK, -1
7564 Yeater_spring, FALSE, FALSE,
7565 EL_YAMYAM, ACTION_SMASHED_BY_SPRING, -1
7569 Xalien, TRUE, FALSE,
7573 Xalien_pause, FALSE, FALSE,
7577 Yalien_n, FALSE, FALSE,
7578 EL_ROBOT, ACTION_MOVING, MV_BIT_UP
7581 Yalien_nB, FALSE, TRUE,
7582 EL_ROBOT, ACTION_MOVING, MV_BIT_UP
7585 Yalien_e, FALSE, FALSE,
7586 EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
7589 Yalien_eB, FALSE, TRUE,
7590 EL_ROBOT, ACTION_MOVING, MV_BIT_RIGHT
7593 Yalien_s, FALSE, FALSE,
7594 EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
7597 Yalien_sB, FALSE, TRUE,
7598 EL_ROBOT, ACTION_MOVING, MV_BIT_DOWN
7601 Yalien_w, FALSE, FALSE,
7602 EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
7605 Yalien_wB, FALSE, TRUE,
7606 EL_ROBOT, ACTION_MOVING, MV_BIT_LEFT
7609 Yalien_stone, FALSE, FALSE,
7610 EL_ROBOT, ACTION_SMASHED_BY_ROCK, -1
7613 Yalien_spring, FALSE, FALSE,
7614 EL_ROBOT, ACTION_SMASHED_BY_SPRING, -1
7618 Xbug_1_n, TRUE, FALSE,
7622 Xbug_1_e, TRUE, FALSE,
7623 EL_BUG_RIGHT, -1, -1
7626 Xbug_1_s, TRUE, FALSE,
7630 Xbug_1_w, TRUE, FALSE,
7634 Xbug_2_n, FALSE, FALSE,
7638 Xbug_2_e, FALSE, FALSE,
7639 EL_BUG_RIGHT, -1, -1
7642 Xbug_2_s, FALSE, FALSE,
7646 Xbug_2_w, FALSE, FALSE,
7650 Ybug_n, FALSE, FALSE,
7651 EL_BUG, ACTION_MOVING, MV_BIT_UP
7654 Ybug_nB, FALSE, TRUE,
7655 EL_BUG, ACTION_MOVING, MV_BIT_UP
7658 Ybug_e, FALSE, FALSE,
7659 EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
7662 Ybug_eB, FALSE, TRUE,
7663 EL_BUG, ACTION_MOVING, MV_BIT_RIGHT
7666 Ybug_s, FALSE, FALSE,
7667 EL_BUG, ACTION_MOVING, MV_BIT_DOWN
7670 Ybug_sB, FALSE, TRUE,
7671 EL_BUG, ACTION_MOVING, MV_BIT_DOWN
7674 Ybug_w, FALSE, FALSE,
7675 EL_BUG, ACTION_MOVING, MV_BIT_LEFT
7678 Ybug_wB, FALSE, TRUE,
7679 EL_BUG, ACTION_MOVING, MV_BIT_LEFT
7682 Ybug_w_n, FALSE, FALSE,
7683 EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
7686 Ybug_n_e, FALSE, FALSE,
7687 EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
7690 Ybug_e_s, FALSE, FALSE,
7691 EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
7694 Ybug_s_w, FALSE, FALSE,
7695 EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
7698 Ybug_e_n, FALSE, FALSE,
7699 EL_BUG, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
7702 Ybug_s_e, FALSE, FALSE,
7703 EL_BUG, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
7706 Ybug_w_s, FALSE, FALSE,
7707 EL_BUG, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
7710 Ybug_n_w, FALSE, FALSE,
7711 EL_BUG, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
7714 Ybug_stone, FALSE, FALSE,
7715 EL_BUG, ACTION_SMASHED_BY_ROCK, -1
7718 Ybug_spring, FALSE, FALSE,
7719 EL_BUG, ACTION_SMASHED_BY_SPRING, -1
7723 Xtank_1_n, TRUE, FALSE,
7724 EL_SPACESHIP_UP, -1, -1
7727 Xtank_1_e, TRUE, FALSE,
7728 EL_SPACESHIP_RIGHT, -1, -1
7731 Xtank_1_s, TRUE, FALSE,
7732 EL_SPACESHIP_DOWN, -1, -1
7735 Xtank_1_w, TRUE, FALSE,
7736 EL_SPACESHIP_LEFT, -1, -1
7739 Xtank_2_n, FALSE, FALSE,
7740 EL_SPACESHIP_UP, -1, -1
7743 Xtank_2_e, FALSE, FALSE,
7744 EL_SPACESHIP_RIGHT, -1, -1
7747 Xtank_2_s, FALSE, FALSE,
7748 EL_SPACESHIP_DOWN, -1, -1
7751 Xtank_2_w, FALSE, FALSE,
7752 EL_SPACESHIP_LEFT, -1, -1
7755 Ytank_n, FALSE, FALSE,
7756 EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
7759 Ytank_nB, FALSE, TRUE,
7760 EL_SPACESHIP, ACTION_MOVING, MV_BIT_UP
7763 Ytank_e, FALSE, FALSE,
7764 EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
7767 Ytank_eB, FALSE, TRUE,
7768 EL_SPACESHIP, ACTION_MOVING, MV_BIT_RIGHT
7771 Ytank_s, FALSE, FALSE,
7772 EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
7775 Ytank_sB, FALSE, TRUE,
7776 EL_SPACESHIP, ACTION_MOVING, MV_BIT_DOWN
7779 Ytank_w, FALSE, FALSE,
7780 EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
7783 Ytank_wB, FALSE, TRUE,
7784 EL_SPACESHIP, ACTION_MOVING, MV_BIT_LEFT
7787 Ytank_w_n, FALSE, FALSE,
7788 EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_UP
7791 Ytank_n_e, FALSE, FALSE,
7792 EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_RIGHT
7795 Ytank_e_s, FALSE, FALSE,
7796 EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_DOWN
7799 Ytank_s_w, FALSE, FALSE,
7800 EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_LEFT
7803 Ytank_e_n, FALSE, FALSE,
7804 EL_SPACESHIP, ACTION_TURNING_FROM_RIGHT, MV_BIT_UP
7807 Ytank_s_e, FALSE, FALSE,
7808 EL_SPACESHIP, ACTION_TURNING_FROM_DOWN, MV_BIT_RIGHT
7811 Ytank_w_s, FALSE, FALSE,
7812 EL_SPACESHIP, ACTION_TURNING_FROM_LEFT, MV_BIT_DOWN
7815 Ytank_n_w, FALSE, FALSE,
7816 EL_SPACESHIP, ACTION_TURNING_FROM_UP, MV_BIT_LEFT
7819 Ytank_stone, FALSE, FALSE,
7820 EL_SPACESHIP, ACTION_SMASHED_BY_ROCK, -1
7823 Ytank_spring, FALSE, FALSE,
7824 EL_SPACESHIP, ACTION_SMASHED_BY_SPRING, -1
7828 Xemerald, TRUE, FALSE,
7832 Xemerald_pause, FALSE, FALSE,
7836 Xemerald_fall, FALSE, FALSE,
7840 Xemerald_shine, FALSE, FALSE,
7841 EL_EMERALD, ACTION_TWINKLING, -1
7844 Yemerald_s, FALSE, FALSE,
7845 EL_EMERALD, ACTION_FALLING, -1
7848 Yemerald_sB, FALSE, TRUE,
7849 EL_EMERALD, ACTION_FALLING, -1
7852 Yemerald_e, FALSE, FALSE,
7853 EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
7856 Yemerald_eB, FALSE, TRUE,
7857 EL_EMERALD, ACTION_MOVING, MV_BIT_RIGHT
7860 Yemerald_w, FALSE, FALSE,
7861 EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
7864 Yemerald_wB, FALSE, TRUE,
7865 EL_EMERALD, ACTION_MOVING, MV_BIT_LEFT
7868 Yemerald_blank, FALSE, FALSE,
7869 EL_EMERALD, ACTION_COLLECTING, -1
7873 Xdiamond, TRUE, FALSE,
7877 Xdiamond_pause, FALSE, FALSE,
7881 Xdiamond_fall, FALSE, FALSE,
7885 Xdiamond_shine, FALSE, FALSE,
7886 EL_DIAMOND, ACTION_TWINKLING, -1
7889 Ydiamond_s, FALSE, FALSE,
7890 EL_DIAMOND, ACTION_FALLING, -1
7893 Ydiamond_sB, FALSE, TRUE,
7894 EL_DIAMOND, ACTION_FALLING, -1
7897 Ydiamond_e, FALSE, FALSE,
7898 EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
7901 Ydiamond_eB, FALSE, TRUE,
7902 EL_DIAMOND, ACTION_MOVING, MV_BIT_RIGHT
7905 Ydiamond_w, FALSE, FALSE,
7906 EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
7909 Ydiamond_wB, FALSE, TRUE,
7910 EL_DIAMOND, ACTION_MOVING, MV_BIT_LEFT
7913 Ydiamond_blank, FALSE, FALSE,
7914 EL_DIAMOND, ACTION_COLLECTING, -1
7917 Ydiamond_stone, FALSE, FALSE,
7918 EL_DIAMOND, ACTION_SMASHED_BY_ROCK, -1
7922 Xstone, TRUE, FALSE,
7926 Xstone_pause, FALSE, FALSE,
7930 Xstone_fall, FALSE, FALSE,
7934 Ystone_s, FALSE, FALSE,
7935 EL_ROCK, ACTION_FALLING, -1
7938 Ystone_sB, FALSE, TRUE,
7939 EL_ROCK, ACTION_FALLING, -1
7942 Ystone_e, FALSE, FALSE,
7943 EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
7946 Ystone_eB, FALSE, TRUE,
7947 EL_ROCK, ACTION_MOVING, MV_BIT_RIGHT
7950 Ystone_w, FALSE, FALSE,
7951 EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
7954 Ystone_wB, FALSE, TRUE,
7955 EL_ROCK, ACTION_MOVING, MV_BIT_LEFT
7963 Xbomb_pause, FALSE, FALSE,
7967 Xbomb_fall, FALSE, FALSE,
7971 Ybomb_s, FALSE, FALSE,
7972 EL_BOMB, ACTION_FALLING, -1
7975 Ybomb_sB, FALSE, TRUE,
7976 EL_BOMB, ACTION_FALLING, -1
7979 Ybomb_e, FALSE, FALSE,
7980 EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
7983 Ybomb_eB, FALSE, TRUE,
7984 EL_BOMB, ACTION_MOVING, MV_BIT_RIGHT
7987 Ybomb_w, FALSE, FALSE,
7988 EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
7991 Ybomb_wB, FALSE, TRUE,
7992 EL_BOMB, ACTION_MOVING, MV_BIT_LEFT
7995 Ybomb_blank, FALSE, FALSE,
7996 EL_BOMB, ACTION_ACTIVATING, -1
8004 Xnut_pause, FALSE, FALSE,
8008 Xnut_fall, FALSE, FALSE,
8012 Ynut_s, FALSE, FALSE,
8013 EL_NUT, ACTION_FALLING, -1
8016 Ynut_sB, FALSE, TRUE,
8017 EL_NUT, ACTION_FALLING, -1
8020 Ynut_e, FALSE, FALSE,
8021 EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
8024 Ynut_eB, FALSE, TRUE,
8025 EL_NUT, ACTION_MOVING, MV_BIT_RIGHT
8028 Ynut_w, FALSE, FALSE,
8029 EL_NUT, ACTION_MOVING, MV_BIT_LEFT
8032 Ynut_wB, FALSE, TRUE,
8033 EL_NUT, ACTION_MOVING, MV_BIT_LEFT
8036 Ynut_stone, FALSE, FALSE,
8037 EL_NUT, ACTION_BREAKING, -1
8041 Xspring, TRUE, FALSE,
8045 Xspring_pause, FALSE, FALSE,
8049 Xspring_e, TRUE, FALSE,
8050 EL_SPRING_RIGHT, -1, -1
8053 Xspring_w, TRUE, FALSE,
8054 EL_SPRING_LEFT, -1, -1
8057 Xspring_fall, FALSE, FALSE,
8061 Yspring_s, FALSE, FALSE,
8062 EL_SPRING, ACTION_FALLING, -1
8065 Yspring_sB, FALSE, TRUE,
8066 EL_SPRING, ACTION_FALLING, -1
8069 Yspring_e, FALSE, FALSE,
8070 EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
8073 Yspring_eB, FALSE, TRUE,
8074 EL_SPRING, ACTION_MOVING, MV_BIT_RIGHT
8077 Yspring_w, FALSE, FALSE,
8078 EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
8081 Yspring_wB, FALSE, TRUE,
8082 EL_SPRING, ACTION_MOVING, MV_BIT_LEFT
8085 Yspring_alien_e, FALSE, FALSE,
8086 EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
8089 Yspring_alien_eB, FALSE, TRUE,
8090 EL_SPRING, ACTION_EATING, MV_BIT_RIGHT
8093 Yspring_alien_w, FALSE, FALSE,
8094 EL_SPRING, ACTION_EATING, MV_BIT_LEFT
8097 Yspring_alien_wB, FALSE, TRUE,
8098 EL_SPRING, ACTION_EATING, MV_BIT_LEFT
8102 Xpush_emerald_e, FALSE, FALSE,
8103 EL_EMERALD, -1, MV_BIT_RIGHT
8106 Xpush_emerald_w, FALSE, FALSE,
8107 EL_EMERALD, -1, MV_BIT_LEFT
8110 Xpush_diamond_e, FALSE, FALSE,
8111 EL_DIAMOND, -1, MV_BIT_RIGHT
8114 Xpush_diamond_w, FALSE, FALSE,
8115 EL_DIAMOND, -1, MV_BIT_LEFT
8118 Xpush_stone_e, FALSE, FALSE,
8119 EL_ROCK, -1, MV_BIT_RIGHT
8122 Xpush_stone_w, FALSE, FALSE,
8123 EL_ROCK, -1, MV_BIT_LEFT
8126 Xpush_bomb_e, FALSE, FALSE,
8127 EL_BOMB, -1, MV_BIT_RIGHT
8130 Xpush_bomb_w, FALSE, FALSE,
8131 EL_BOMB, -1, MV_BIT_LEFT
8134 Xpush_nut_e, FALSE, FALSE,
8135 EL_NUT, -1, MV_BIT_RIGHT
8138 Xpush_nut_w, FALSE, FALSE,
8139 EL_NUT, -1, MV_BIT_LEFT
8142 Xpush_spring_e, FALSE, FALSE,
8143 EL_SPRING_RIGHT, -1, MV_BIT_RIGHT
8146 Xpush_spring_w, FALSE, FALSE,
8147 EL_SPRING_LEFT, -1, MV_BIT_LEFT
8151 Xdynamite, TRUE, FALSE,
8152 EL_EM_DYNAMITE, -1, -1
8155 Ydynamite_blank, FALSE, FALSE,
8156 EL_EM_DYNAMITE, ACTION_COLLECTING, -1
8159 Xdynamite_1, TRUE, FALSE,
8160 EL_EM_DYNAMITE_ACTIVE, -1, -1
8163 Xdynamite_2, FALSE, FALSE,
8164 EL_EM_DYNAMITE_ACTIVE, -1, -1
8167 Xdynamite_3, FALSE, FALSE,
8168 EL_EM_DYNAMITE_ACTIVE, -1, -1
8171 Xdynamite_4, FALSE, FALSE,
8172 EL_EM_DYNAMITE_ACTIVE, -1, -1
8176 Xkey_1, TRUE, FALSE,
8180 Xkey_2, TRUE, FALSE,
8184 Xkey_3, TRUE, FALSE,
8188 Xkey_4, TRUE, FALSE,
8192 Xkey_5, TRUE, FALSE,
8193 EL_EMC_KEY_5, -1, -1
8196 Xkey_6, TRUE, FALSE,
8197 EL_EMC_KEY_6, -1, -1
8200 Xkey_7, TRUE, FALSE,
8201 EL_EMC_KEY_7, -1, -1
8204 Xkey_8, TRUE, FALSE,
8205 EL_EMC_KEY_8, -1, -1
8209 Xdoor_1, TRUE, FALSE,
8210 EL_EM_GATE_1, -1, -1
8213 Xdoor_2, TRUE, FALSE,
8214 EL_EM_GATE_2, -1, -1
8217 Xdoor_3, TRUE, FALSE,
8218 EL_EM_GATE_3, -1, -1
8221 Xdoor_4, TRUE, FALSE,
8222 EL_EM_GATE_4, -1, -1
8225 Xdoor_5, TRUE, FALSE,
8226 EL_EMC_GATE_5, -1, -1
8229 Xdoor_6, TRUE, FALSE,
8230 EL_EMC_GATE_6, -1, -1
8233 Xdoor_7, TRUE, FALSE,
8234 EL_EMC_GATE_7, -1, -1
8237 Xdoor_8, TRUE, FALSE,
8238 EL_EMC_GATE_8, -1, -1
8242 Xfake_door_1, TRUE, FALSE,
8243 EL_EM_GATE_1_GRAY, -1, -1
8246 Xfake_door_2, TRUE, FALSE,
8247 EL_EM_GATE_2_GRAY, -1, -1
8250 Xfake_door_3, TRUE, FALSE,
8251 EL_EM_GATE_3_GRAY, -1, -1
8254 Xfake_door_4, TRUE, FALSE,
8255 EL_EM_GATE_4_GRAY, -1, -1
8258 Xfake_door_5, TRUE, FALSE,
8259 EL_EMC_GATE_5_GRAY, -1, -1
8262 Xfake_door_6, TRUE, FALSE,
8263 EL_EMC_GATE_6_GRAY, -1, -1
8266 Xfake_door_7, TRUE, FALSE,
8267 EL_EMC_GATE_7_GRAY, -1, -1
8270 Xfake_door_8, TRUE, FALSE,
8271 EL_EMC_GATE_8_GRAY, -1, -1
8275 Xballoon, TRUE, FALSE,
8279 Yballoon_n, FALSE, FALSE,
8280 EL_BALLOON, ACTION_MOVING, MV_BIT_UP
8283 Yballoon_nB, FALSE, TRUE,
8284 EL_BALLOON, ACTION_MOVING, MV_BIT_UP
8287 Yballoon_e, FALSE, FALSE,
8288 EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
8291 Yballoon_eB, FALSE, TRUE,
8292 EL_BALLOON, ACTION_MOVING, MV_BIT_RIGHT
8295 Yballoon_s, FALSE, FALSE,
8296 EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
8299 Yballoon_sB, FALSE, TRUE,
8300 EL_BALLOON, ACTION_MOVING, MV_BIT_DOWN
8303 Yballoon_w, FALSE, FALSE,
8304 EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
8307 Yballoon_wB, FALSE, TRUE,
8308 EL_BALLOON, ACTION_MOVING, MV_BIT_LEFT
8312 Xball_1, TRUE, FALSE,
8313 EL_EMC_MAGIC_BALL, -1, -1
8316 Yball_1, FALSE, FALSE,
8317 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
8320 Xball_2, FALSE, FALSE,
8321 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
8324 Yball_2, FALSE, FALSE,
8325 EL_EMC_MAGIC_BALL, ACTION_ACTIVE, -1
8328 Yball_blank, FALSE, FALSE,
8329 EL_EMC_MAGIC_BALL, ACTION_DROPPING, -1
8333 Xamoeba_1, TRUE, FALSE,
8334 EL_AMOEBA_DRY, ACTION_OTHER, -1
8337 Xamoeba_2, FALSE, FALSE,
8338 EL_AMOEBA_DRY, ACTION_OTHER, -1
8341 Xamoeba_3, FALSE, FALSE,
8342 EL_AMOEBA_DRY, ACTION_OTHER, -1
8345 Xamoeba_4, FALSE, FALSE,
8346 EL_AMOEBA_DRY, ACTION_OTHER, -1
8349 Xamoeba_5, TRUE, FALSE,
8350 EL_AMOEBA_WET, ACTION_OTHER, -1
8353 Xamoeba_6, FALSE, FALSE,
8354 EL_AMOEBA_WET, ACTION_OTHER, -1
8357 Xamoeba_7, FALSE, FALSE,
8358 EL_AMOEBA_WET, ACTION_OTHER, -1
8361 Xamoeba_8, FALSE, FALSE,
8362 EL_AMOEBA_WET, ACTION_OTHER, -1
8367 EL_AMOEBA_DROP, ACTION_GROWING, -1
8370 Xdrip_fall, FALSE, FALSE,
8371 EL_AMOEBA_DROP, -1, -1
8374 Xdrip_stretch, FALSE, FALSE,
8375 EL_AMOEBA_DROP, ACTION_FALLING, -1
8378 Xdrip_stretchB, FALSE, TRUE,
8379 EL_AMOEBA_DROP, ACTION_FALLING, -1
8382 Ydrip_1_s, FALSE, FALSE,
8383 EL_AMOEBA_DROP, ACTION_FALLING, -1
8386 Ydrip_1_sB, FALSE, TRUE,
8387 EL_AMOEBA_DROP, ACTION_FALLING, -1
8390 Ydrip_2_s, FALSE, FALSE,
8391 EL_AMOEBA_DROP, ACTION_FALLING, -1
8394 Ydrip_2_sB, FALSE, TRUE,
8395 EL_AMOEBA_DROP, ACTION_FALLING, -1
8399 Xwonderwall, TRUE, FALSE,
8400 EL_MAGIC_WALL, -1, -1
8403 Ywonderwall, FALSE, FALSE,
8404 EL_MAGIC_WALL, ACTION_ACTIVE, -1
8408 Xwheel, TRUE, FALSE,
8409 EL_ROBOT_WHEEL, -1, -1
8412 Ywheel, FALSE, FALSE,
8413 EL_ROBOT_WHEEL, ACTION_ACTIVE, -1
8417 Xswitch, TRUE, FALSE,
8418 EL_EMC_MAGIC_BALL_SWITCH, -1, -1
8421 Yswitch, FALSE, FALSE,
8422 EL_EMC_MAGIC_BALL_SWITCH, ACTION_ACTIVE, -1
8426 Xbumper, TRUE, FALSE,
8427 EL_EMC_SPRING_BUMPER, -1, -1
8430 Ybumper, FALSE, FALSE,
8431 EL_EMC_SPRING_BUMPER, ACTION_ACTIVE, -1
8435 Xacid_nw, TRUE, FALSE,
8436 EL_ACID_POOL_TOPLEFT, -1, -1
8439 Xacid_ne, TRUE, FALSE,
8440 EL_ACID_POOL_TOPRIGHT, -1, -1
8443 Xacid_sw, TRUE, FALSE,
8444 EL_ACID_POOL_BOTTOMLEFT, -1, -1
8447 Xacid_s, TRUE, FALSE,
8448 EL_ACID_POOL_BOTTOM, -1, -1
8451 Xacid_se, TRUE, FALSE,
8452 EL_ACID_POOL_BOTTOMRIGHT, -1, -1
8456 Xfake_blank, TRUE, FALSE,
8457 EL_INVISIBLE_WALL, -1, -1
8460 Yfake_blank, FALSE, FALSE,
8461 EL_INVISIBLE_WALL, ACTION_ACTIVE, -1
8465 Xfake_grass, TRUE, FALSE,
8466 EL_EMC_FAKE_GRASS, -1, -1
8469 Yfake_grass, FALSE, FALSE,
8470 EL_EMC_FAKE_GRASS, ACTION_ACTIVE, -1
8474 Xfake_amoeba, TRUE, FALSE,
8475 EL_EMC_DRIPPER, -1, -1
8478 Yfake_amoeba, FALSE, FALSE,
8479 EL_EMC_DRIPPER, ACTION_ACTIVE, -1
8483 Xlenses, TRUE, FALSE,
8484 EL_EMC_LENSES, -1, -1
8488 Xmagnify, TRUE, FALSE,
8489 EL_EMC_MAGNIFIER, -1, -1
8494 EL_QUICKSAND_EMPTY, -1, -1
8497 Xsand_stone, TRUE, FALSE,
8498 EL_QUICKSAND_FULL, -1, -1
8501 Xsand_stonein_1, FALSE, TRUE,
8502 EL_ROCK, ACTION_FILLING, -1
8505 Xsand_stonein_2, FALSE, TRUE,
8506 EL_ROCK, ACTION_FILLING, -1
8509 Xsand_stonein_3, FALSE, TRUE,
8510 EL_ROCK, ACTION_FILLING, -1
8513 Xsand_stonein_4, FALSE, TRUE,
8514 EL_ROCK, ACTION_FILLING, -1
8517 Xsand_sandstone_1, FALSE, FALSE,
8518 EL_QUICKSAND_FILLING, -1, -1
8521 Xsand_sandstone_2, FALSE, FALSE,
8522 EL_QUICKSAND_FILLING, -1, -1
8525 Xsand_sandstone_3, FALSE, FALSE,
8526 EL_QUICKSAND_FILLING, -1, -1
8529 Xsand_sandstone_4, FALSE, FALSE,
8530 EL_QUICKSAND_FILLING, -1, -1
8533 Xsand_stonesand_1, FALSE, FALSE,
8534 EL_QUICKSAND_EMPTYING, -1, -1
8537 Xsand_stonesand_2, FALSE, FALSE,
8538 EL_QUICKSAND_EMPTYING, -1, -1
8541 Xsand_stonesand_3, FALSE, FALSE,
8542 EL_QUICKSAND_EMPTYING, -1, -1
8545 Xsand_stonesand_4, FALSE, FALSE,
8546 EL_QUICKSAND_EMPTYING, -1, -1
8549 Xsand_stoneout_1, FALSE, FALSE,
8550 EL_ROCK, ACTION_EMPTYING, -1
8553 Xsand_stoneout_2, FALSE, FALSE,
8554 EL_ROCK, ACTION_EMPTYING, -1
8557 Xsand_stonesand_quickout_1, FALSE, FALSE,
8558 EL_QUICKSAND_EMPTYING, -1, -1
8561 Xsand_stonesand_quickout_2, FALSE, FALSE,
8562 EL_QUICKSAND_EMPTYING, -1, -1
8566 Xslide_ns, TRUE, FALSE,
8567 EL_EXPANDABLE_WALL_VERTICAL, -1, -1
8570 Yslide_ns_blank, FALSE, FALSE,
8571 EL_EXPANDABLE_WALL_VERTICAL, ACTION_GROWING, -1
8574 Xslide_ew, TRUE, FALSE,
8575 EL_EXPANDABLE_WALL_HORIZONTAL, -1, -1
8578 Yslide_ew_blank, FALSE, FALSE,
8579 EL_EXPANDABLE_WALL_HORIZONTAL, ACTION_GROWING, -1
8583 Xwind_n, TRUE, FALSE,
8584 EL_BALLOON_SWITCH_UP, -1, -1
8587 Xwind_e, TRUE, FALSE,
8588 EL_BALLOON_SWITCH_RIGHT, -1, -1
8591 Xwind_s, TRUE, FALSE,
8592 EL_BALLOON_SWITCH_DOWN, -1, -1
8595 Xwind_w, TRUE, FALSE,
8596 EL_BALLOON_SWITCH_LEFT, -1, -1
8599 Xwind_any, TRUE, FALSE,
8600 EL_BALLOON_SWITCH_ANY, -1, -1
8603 Xwind_stop, TRUE, FALSE,
8604 EL_BALLOON_SWITCH_NONE, -1, -1
8609 EL_EM_EXIT_CLOSED, -1, -1
8612 Xexit_1, TRUE, FALSE,
8613 EL_EM_EXIT_OPEN, -1, -1
8616 Xexit_2, FALSE, FALSE,
8617 EL_EM_EXIT_OPEN, -1, -1
8620 Xexit_3, FALSE, FALSE,
8621 EL_EM_EXIT_OPEN, -1, -1
8625 Xpause, FALSE, FALSE,
8630 Xwall_1, TRUE, FALSE,
8634 Xwall_2, TRUE, FALSE,
8635 EL_EMC_WALL_14, -1, -1
8638 Xwall_3, TRUE, FALSE,
8639 EL_EMC_WALL_15, -1, -1
8642 Xwall_4, TRUE, FALSE,
8643 EL_EMC_WALL_16, -1, -1
8647 Xroundwall_1, TRUE, FALSE,
8648 EL_WALL_SLIPPERY, -1, -1
8651 Xroundwall_2, TRUE, FALSE,
8652 EL_EMC_WALL_SLIPPERY_2, -1, -1
8655 Xroundwall_3, TRUE, FALSE,
8656 EL_EMC_WALL_SLIPPERY_3, -1, -1
8659 Xroundwall_4, TRUE, FALSE,
8660 EL_EMC_WALL_SLIPPERY_4, -1, -1
8664 Xsteel_1, TRUE, FALSE,
8665 EL_STEELWALL, -1, -1
8668 Xsteel_2, TRUE, FALSE,
8669 EL_EMC_STEELWALL_2, -1, -1
8672 Xsteel_3, TRUE, FALSE,
8673 EL_EMC_STEELWALL_3, -1, -1
8676 Xsteel_4, TRUE, FALSE,
8677 EL_EMC_STEELWALL_4, -1, -1
8681 Xdecor_1, TRUE, FALSE,
8682 EL_EMC_WALL_8, -1, -1
8685 Xdecor_2, TRUE, FALSE,
8686 EL_EMC_WALL_6, -1, -1
8689 Xdecor_3, TRUE, FALSE,
8690 EL_EMC_WALL_4, -1, -1
8693 Xdecor_4, TRUE, FALSE,
8694 EL_EMC_WALL_7, -1, -1
8697 Xdecor_5, TRUE, FALSE,
8698 EL_EMC_WALL_5, -1, -1
8701 Xdecor_6, TRUE, FALSE,
8702 EL_EMC_WALL_9, -1, -1
8705 Xdecor_7, TRUE, FALSE,
8706 EL_EMC_WALL_10, -1, -1
8709 Xdecor_8, TRUE, FALSE,
8710 EL_EMC_WALL_1, -1, -1
8713 Xdecor_9, TRUE, FALSE,
8714 EL_EMC_WALL_2, -1, -1
8717 Xdecor_10, TRUE, FALSE,
8718 EL_EMC_WALL_3, -1, -1
8721 Xdecor_11, TRUE, FALSE,
8722 EL_EMC_WALL_11, -1, -1
8725 Xdecor_12, TRUE, FALSE,
8726 EL_EMC_WALL_12, -1, -1
8730 Xalpha_0, TRUE, FALSE,
8731 EL_CHAR('0'), -1, -1
8734 Xalpha_1, TRUE, FALSE,
8735 EL_CHAR('1'), -1, -1
8738 Xalpha_2, TRUE, FALSE,
8739 EL_CHAR('2'), -1, -1
8742 Xalpha_3, TRUE, FALSE,
8743 EL_CHAR('3'), -1, -1
8746 Xalpha_4, TRUE, FALSE,
8747 EL_CHAR('4'), -1, -1
8750 Xalpha_5, TRUE, FALSE,
8751 EL_CHAR('5'), -1, -1
8754 Xalpha_6, TRUE, FALSE,
8755 EL_CHAR('6'), -1, -1
8758 Xalpha_7, TRUE, FALSE,
8759 EL_CHAR('7'), -1, -1
8762 Xalpha_8, TRUE, FALSE,
8763 EL_CHAR('8'), -1, -1
8766 Xalpha_9, TRUE, FALSE,
8767 EL_CHAR('9'), -1, -1
8770 Xalpha_excla, TRUE, FALSE,
8771 EL_CHAR('!'), -1, -1
8774 Xalpha_apost, TRUE, FALSE,
8775 EL_CHAR('\''), -1, -1
8778 Xalpha_comma, TRUE, FALSE,
8779 EL_CHAR(','), -1, -1
8782 Xalpha_minus, TRUE, FALSE,
8783 EL_CHAR('-'), -1, -1
8786 Xalpha_perio, TRUE, FALSE,
8787 EL_CHAR('.'), -1, -1
8790 Xalpha_colon, TRUE, FALSE,
8791 EL_CHAR(':'), -1, -1
8794 Xalpha_quest, TRUE, FALSE,
8795 EL_CHAR('?'), -1, -1
8798 Xalpha_a, TRUE, FALSE,
8799 EL_CHAR('A'), -1, -1
8802 Xalpha_b, TRUE, FALSE,
8803 EL_CHAR('B'), -1, -1
8806 Xalpha_c, TRUE, FALSE,
8807 EL_CHAR('C'), -1, -1
8810 Xalpha_d, TRUE, FALSE,
8811 EL_CHAR('D'), -1, -1
8814 Xalpha_e, TRUE, FALSE,
8815 EL_CHAR('E'), -1, -1
8818 Xalpha_f, TRUE, FALSE,
8819 EL_CHAR('F'), -1, -1
8822 Xalpha_g, TRUE, FALSE,
8823 EL_CHAR('G'), -1, -1
8826 Xalpha_h, TRUE, FALSE,
8827 EL_CHAR('H'), -1, -1
8830 Xalpha_i, TRUE, FALSE,
8831 EL_CHAR('I'), -1, -1
8834 Xalpha_j, TRUE, FALSE,
8835 EL_CHAR('J'), -1, -1
8838 Xalpha_k, TRUE, FALSE,
8839 EL_CHAR('K'), -1, -1
8842 Xalpha_l, TRUE, FALSE,
8843 EL_CHAR('L'), -1, -1
8846 Xalpha_m, TRUE, FALSE,
8847 EL_CHAR('M'), -1, -1
8850 Xalpha_n, TRUE, FALSE,
8851 EL_CHAR('N'), -1, -1
8854 Xalpha_o, TRUE, FALSE,
8855 EL_CHAR('O'), -1, -1
8858 Xalpha_p, TRUE, FALSE,
8859 EL_CHAR('P'), -1, -1
8862 Xalpha_q, TRUE, FALSE,
8863 EL_CHAR('Q'), -1, -1
8866 Xalpha_r, TRUE, FALSE,
8867 EL_CHAR('R'), -1, -1
8870 Xalpha_s, TRUE, FALSE,
8871 EL_CHAR('S'), -1, -1
8874 Xalpha_t, TRUE, FALSE,
8875 EL_CHAR('T'), -1, -1
8878 Xalpha_u, TRUE, FALSE,
8879 EL_CHAR('U'), -1, -1
8882 Xalpha_v, TRUE, FALSE,
8883 EL_CHAR('V'), -1, -1
8886 Xalpha_w, TRUE, FALSE,
8887 EL_CHAR('W'), -1, -1
8890 Xalpha_x, TRUE, FALSE,
8891 EL_CHAR('X'), -1, -1
8894 Xalpha_y, TRUE, FALSE,
8895 EL_CHAR('Y'), -1, -1
8898 Xalpha_z, TRUE, FALSE,
8899 EL_CHAR('Z'), -1, -1
8902 Xalpha_arrow_e, TRUE, FALSE,
8903 EL_CHAR('>'), -1, -1
8906 Xalpha_arrow_w, TRUE, FALSE,
8907 EL_CHAR('<'), -1, -1
8910 Xalpha_copyr, TRUE, FALSE,
8911 EL_CHAR(CHAR_BYTE_COPYRIGHT), -1, -1
8915 Ykey_1_blank, FALSE, FALSE,
8916 EL_EM_KEY_1, ACTION_COLLECTING, -1
8919 Ykey_2_blank, FALSE, FALSE,
8920 EL_EM_KEY_2, ACTION_COLLECTING, -1
8923 Ykey_3_blank, FALSE, FALSE,
8924 EL_EM_KEY_3, ACTION_COLLECTING, -1
8927 Ykey_4_blank, FALSE, FALSE,
8928 EL_EM_KEY_4, ACTION_COLLECTING, -1
8931 Ykey_5_blank, FALSE, FALSE,
8932 EL_EMC_KEY_5, ACTION_COLLECTING, -1
8935 Ykey_6_blank, FALSE, FALSE,
8936 EL_EMC_KEY_6, ACTION_COLLECTING, -1
8939 Ykey_7_blank, FALSE, FALSE,
8940 EL_EMC_KEY_7, ACTION_COLLECTING, -1
8943 Ykey_8_blank, FALSE, FALSE,
8944 EL_EMC_KEY_8, ACTION_COLLECTING, -1
8947 Ylenses_blank, FALSE, FALSE,
8948 EL_EMC_LENSES, ACTION_COLLECTING, -1
8951 Ymagnify_blank, FALSE, FALSE,
8952 EL_EMC_MAGNIFIER, ACTION_COLLECTING, -1
8955 Ygrass_blank, FALSE, FALSE,
8956 EL_EMC_GRASS, ACTION_SNAPPING, -1
8959 Ydirt_blank, FALSE, FALSE,
8960 EL_SAND, ACTION_SNAPPING, -1
8969 static struct Mapping_EM_to_RND_player
8978 em_player_mapping_list[MAX_PLAYERS * PLY_MAX + 1] =
8982 EL_PLAYER_1, ACTION_MOVING, MV_BIT_UP,
8986 EL_PLAYER_1, ACTION_MOVING, MV_BIT_RIGHT,
8990 EL_PLAYER_1, ACTION_MOVING, MV_BIT_DOWN,
8994 EL_PLAYER_1, ACTION_MOVING, MV_BIT_LEFT,
8998 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_UP,
9002 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_RIGHT,
9006 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_DOWN,
9010 EL_PLAYER_1, ACTION_PUSHING, MV_BIT_LEFT,
9014 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_UP,
9018 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_RIGHT,
9022 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_DOWN,
9026 EL_PLAYER_1, ACTION_SNAPPING, MV_BIT_LEFT,
9030 EL_PLAYER_2, ACTION_MOVING, MV_BIT_UP,
9034 EL_PLAYER_2, ACTION_MOVING, MV_BIT_RIGHT,
9038 EL_PLAYER_2, ACTION_MOVING, MV_BIT_DOWN,
9042 EL_PLAYER_2, ACTION_MOVING, MV_BIT_LEFT,
9046 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_UP,
9050 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_RIGHT,
9054 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_DOWN,
9058 EL_PLAYER_2, ACTION_PUSHING, MV_BIT_LEFT,
9062 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_UP,
9066 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_RIGHT,
9070 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_DOWN,
9074 EL_PLAYER_2, ACTION_SNAPPING, MV_BIT_LEFT,
9078 EL_PLAYER_1, ACTION_DEFAULT, -1,
9082 EL_PLAYER_2, ACTION_DEFAULT, -1,
9086 EL_PLAYER_3, ACTION_MOVING, MV_BIT_UP,
9090 EL_PLAYER_3, ACTION_MOVING, MV_BIT_RIGHT,
9094 EL_PLAYER_3, ACTION_MOVING, MV_BIT_DOWN,
9098 EL_PLAYER_3, ACTION_MOVING, MV_BIT_LEFT,
9102 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_UP,
9106 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_RIGHT,
9110 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_DOWN,
9114 EL_PLAYER_3, ACTION_PUSHING, MV_BIT_LEFT,
9118 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_UP,
9122 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_RIGHT,
9126 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_DOWN,
9130 EL_PLAYER_3, ACTION_SNAPPING, MV_BIT_LEFT,
9134 EL_PLAYER_4, ACTION_MOVING, MV_BIT_UP,
9138 EL_PLAYER_4, ACTION_MOVING, MV_BIT_RIGHT,
9142 EL_PLAYER_4, ACTION_MOVING, MV_BIT_DOWN,
9146 EL_PLAYER_4, ACTION_MOVING, MV_BIT_LEFT,
9150 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_UP,
9154 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_RIGHT,
9158 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_DOWN,
9162 EL_PLAYER_4, ACTION_PUSHING, MV_BIT_LEFT,
9166 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_UP,
9170 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_RIGHT,
9174 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_DOWN,
9178 EL_PLAYER_4, ACTION_SNAPPING, MV_BIT_LEFT,
9182 EL_PLAYER_3, ACTION_DEFAULT, -1,
9186 EL_PLAYER_4, ACTION_DEFAULT, -1,
9195 int map_element_RND_to_EM_cave(int element_rnd)
9197 static unsigned short mapping_RND_to_EM[NUM_FILE_ELEMENTS];
9198 static boolean mapping_initialized = FALSE;
9200 if (!mapping_initialized)
9204 // return "Xalpha_quest" for all undefined elements in mapping array
9205 for (i = 0; i < NUM_FILE_ELEMENTS; i++)
9206 mapping_RND_to_EM[i] = Xalpha_quest;
9208 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
9209 if (em_object_mapping_list[i].is_rnd_to_em_mapping)
9210 mapping_RND_to_EM[em_object_mapping_list[i].element_rnd] =
9211 em_object_mapping_list[i].element_em;
9213 mapping_initialized = TRUE;
9216 if (element_rnd < 0 || element_rnd >= NUM_FILE_ELEMENTS)
9218 Warn("invalid RND level element %d", element_rnd);
9223 return map_em_element_X_to_C(mapping_RND_to_EM[element_rnd]);
9226 int map_element_EM_to_RND_cave(int element_em_cave)
9228 static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
9229 static boolean mapping_initialized = FALSE;
9231 if (!mapping_initialized)
9235 // return "EL_UNKNOWN" for all undefined elements in mapping array
9236 for (i = 0; i < GAME_TILE_MAX; i++)
9237 mapping_EM_to_RND[i] = EL_UNKNOWN;
9239 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
9240 mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
9241 em_object_mapping_list[i].element_rnd;
9243 mapping_initialized = TRUE;
9246 if (element_em_cave < 0 || element_em_cave >= CAVE_TILE_MAX)
9248 Warn("invalid EM cave element %d", element_em_cave);
9253 return mapping_EM_to_RND[map_em_element_C_to_X(element_em_cave)];
9256 int map_element_EM_to_RND_game(int element_em_game)
9258 static unsigned short mapping_EM_to_RND[GAME_TILE_MAX];
9259 static boolean mapping_initialized = FALSE;
9261 if (!mapping_initialized)
9265 // return "EL_UNKNOWN" for all undefined elements in mapping array
9266 for (i = 0; i < GAME_TILE_MAX; i++)
9267 mapping_EM_to_RND[i] = EL_UNKNOWN;
9269 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
9270 mapping_EM_to_RND[em_object_mapping_list[i].element_em] =
9271 em_object_mapping_list[i].element_rnd;
9273 mapping_initialized = TRUE;
9276 if (element_em_game < 0 || element_em_game >= GAME_TILE_MAX)
9278 Warn("invalid EM game element %d", element_em_game);
9283 return mapping_EM_to_RND[element_em_game];
9286 void map_android_clone_elements_RND_to_EM(struct LevelInfo *level)
9288 struct LevelInfo_EM *level_em = level->native_em_level;
9289 struct CAVE *cav = level_em->cav;
9292 for (i = 0; i < GAME_TILE_MAX; i++)
9293 cav->android_array[i] = Cblank;
9295 for (i = 0; i < level->num_android_clone_elements; i++)
9297 int element_rnd = level->android_clone_element[i];
9298 int element_em_cave = map_element_RND_to_EM_cave(element_rnd);
9300 for (j = 0; em_object_mapping_list[j].element_em != -1; j++)
9301 if (em_object_mapping_list[j].element_rnd == element_rnd)
9302 cav->android_array[em_object_mapping_list[j].element_em] =
9307 void map_android_clone_elements_EM_to_RND(struct LevelInfo *level)
9309 struct LevelInfo_EM *level_em = level->native_em_level;
9310 struct CAVE *cav = level_em->cav;
9313 level->num_android_clone_elements = 0;
9315 for (i = 0; i < GAME_TILE_MAX; i++)
9317 int element_em_cave = cav->android_array[i];
9319 boolean element_found = FALSE;
9321 if (element_em_cave == Cblank)
9324 element_rnd = map_element_EM_to_RND_cave(element_em_cave);
9326 for (j = 0; j < level->num_android_clone_elements; j++)
9327 if (level->android_clone_element[j] == element_rnd)
9328 element_found = TRUE;
9332 level->android_clone_element[level->num_android_clone_elements++] =
9335 if (level->num_android_clone_elements == MAX_ANDROID_ELEMENTS)
9340 if (level->num_android_clone_elements == 0)
9342 level->num_android_clone_elements = 1;
9343 level->android_clone_element[0] = EL_EMPTY;
9347 int map_direction_RND_to_EM(int direction)
9349 return (direction == MV_UP ? 0 :
9350 direction == MV_RIGHT ? 1 :
9351 direction == MV_DOWN ? 2 :
9352 direction == MV_LEFT ? 3 :
9356 int map_direction_EM_to_RND(int direction)
9358 return (direction == 0 ? MV_UP :
9359 direction == 1 ? MV_RIGHT :
9360 direction == 2 ? MV_DOWN :
9361 direction == 3 ? MV_LEFT :
9365 int map_element_RND_to_SP(int element_rnd)
9367 int element_sp = 0x20; // map unknown elements to yellow "hardware"
9369 if (element_rnd >= EL_SP_START &&
9370 element_rnd <= EL_SP_END)
9371 element_sp = element_rnd - EL_SP_START;
9372 else if (element_rnd == EL_EMPTY_SPACE)
9374 else if (element_rnd == EL_INVISIBLE_WALL)
9380 int map_element_SP_to_RND(int element_sp)
9382 int element_rnd = EL_UNKNOWN;
9384 if (element_sp >= 0x00 &&
9386 element_rnd = EL_SP_START + element_sp;
9387 else if (element_sp == 0x28)
9388 element_rnd = EL_INVISIBLE_WALL;
9393 int map_action_SP_to_RND(int action_sp)
9397 case actActive: return ACTION_ACTIVE;
9398 case actImpact: return ACTION_IMPACT;
9399 case actExploding: return ACTION_EXPLODING;
9400 case actDigging: return ACTION_DIGGING;
9401 case actSnapping: return ACTION_SNAPPING;
9402 case actCollecting: return ACTION_COLLECTING;
9403 case actPassing: return ACTION_PASSING;
9404 case actPushing: return ACTION_PUSHING;
9405 case actDropping: return ACTION_DROPPING;
9407 default: return ACTION_DEFAULT;
9411 int map_element_RND_to_MM(int element_rnd)
9413 return (element_rnd >= EL_MM_START_1 &&
9414 element_rnd <= EL_MM_END_1 ?
9415 EL_MM_START_1_NATIVE + element_rnd - EL_MM_START_1 :
9417 element_rnd >= EL_MM_START_2 &&
9418 element_rnd <= EL_MM_END_2 ?
9419 EL_MM_START_2_NATIVE + element_rnd - EL_MM_START_2 :
9421 element_rnd >= EL_MM_START_3 &&
9422 element_rnd <= EL_MM_END_3 ?
9423 EL_MM_START_3_NATIVE + element_rnd - EL_MM_START_3 :
9425 element_rnd >= EL_CHAR_START &&
9426 element_rnd <= EL_CHAR_END ?
9427 EL_MM_CHAR_START_NATIVE + element_rnd - EL_CHAR_START :
9429 element_rnd >= EL_MM_RUNTIME_START &&
9430 element_rnd <= EL_MM_RUNTIME_END ?
9431 EL_MM_RUNTIME_START_NATIVE + element_rnd - EL_MM_RUNTIME_START :
9433 EL_MM_EMPTY_NATIVE);
9436 int map_element_MM_to_RND(int element_mm)
9438 return (element_mm == EL_MM_EMPTY_NATIVE ||
9439 element_mm == EL_DF_EMPTY_NATIVE ?
9442 element_mm >= EL_MM_START_1_NATIVE &&
9443 element_mm <= EL_MM_END_1_NATIVE ?
9444 EL_MM_START_1 + element_mm - EL_MM_START_1_NATIVE :
9446 element_mm >= EL_MM_START_2_NATIVE &&
9447 element_mm <= EL_MM_END_2_NATIVE ?
9448 EL_MM_START_2 + element_mm - EL_MM_START_2_NATIVE :
9450 element_mm >= EL_MM_START_3_NATIVE &&
9451 element_mm <= EL_MM_END_3_NATIVE ?
9452 EL_MM_START_3 + element_mm - EL_MM_START_3_NATIVE :
9454 element_mm >= EL_MM_CHAR_START_NATIVE &&
9455 element_mm <= EL_MM_CHAR_END_NATIVE ?
9456 EL_CHAR_START + element_mm - EL_MM_CHAR_START_NATIVE :
9458 element_mm >= EL_MM_RUNTIME_START_NATIVE &&
9459 element_mm <= EL_MM_RUNTIME_END_NATIVE ?
9460 EL_MM_RUNTIME_START + element_mm - EL_MM_RUNTIME_START_NATIVE :
9465 int map_action_MM_to_RND(int action_mm)
9467 // all MM actions are defined to exactly match their RND counterparts
9471 int map_sound_MM_to_RND(int sound_mm)
9475 case SND_MM_GAME_LEVELTIME_CHARGING:
9476 return SND_GAME_LEVELTIME_CHARGING;
9478 case SND_MM_GAME_HEALTH_CHARGING:
9479 return SND_GAME_HEALTH_CHARGING;
9482 return SND_UNDEFINED;
9486 int map_mm_wall_element(int element)
9488 return (element >= EL_MM_STEEL_WALL_START &&
9489 element <= EL_MM_STEEL_WALL_END ?
9492 element >= EL_MM_WOODEN_WALL_START &&
9493 element <= EL_MM_WOODEN_WALL_END ?
9496 element >= EL_MM_ICE_WALL_START &&
9497 element <= EL_MM_ICE_WALL_END ?
9500 element >= EL_MM_AMOEBA_WALL_START &&
9501 element <= EL_MM_AMOEBA_WALL_END ?
9504 element >= EL_DF_STEEL_WALL_START &&
9505 element <= EL_DF_STEEL_WALL_END ?
9508 element >= EL_DF_WOODEN_WALL_START &&
9509 element <= EL_DF_WOODEN_WALL_END ?
9515 int map_mm_wall_element_editor(int element)
9519 case EL_MM_STEEL_WALL: return EL_MM_STEEL_WALL_START;
9520 case EL_MM_WOODEN_WALL: return EL_MM_WOODEN_WALL_START;
9521 case EL_MM_ICE_WALL: return EL_MM_ICE_WALL_START;
9522 case EL_MM_AMOEBA_WALL: return EL_MM_AMOEBA_WALL_START;
9523 case EL_DF_STEEL_WALL: return EL_DF_STEEL_WALL_START;
9524 case EL_DF_WOODEN_WALL: return EL_DF_WOODEN_WALL_START;
9526 default: return element;
9530 int get_next_element(int element)
9534 case EL_QUICKSAND_FILLING: return EL_QUICKSAND_FULL;
9535 case EL_QUICKSAND_EMPTYING: return EL_QUICKSAND_EMPTY;
9536 case EL_QUICKSAND_FAST_FILLING: return EL_QUICKSAND_FAST_FULL;
9537 case EL_QUICKSAND_FAST_EMPTYING: return EL_QUICKSAND_FAST_EMPTY;
9538 case EL_MAGIC_WALL_FILLING: return EL_MAGIC_WALL_FULL;
9539 case EL_MAGIC_WALL_EMPTYING: return EL_MAGIC_WALL_ACTIVE;
9540 case EL_BD_MAGIC_WALL_FILLING: return EL_BD_MAGIC_WALL_FULL;
9541 case EL_BD_MAGIC_WALL_EMPTYING: return EL_BD_MAGIC_WALL_ACTIVE;
9542 case EL_DC_MAGIC_WALL_FILLING: return EL_DC_MAGIC_WALL_FULL;
9543 case EL_DC_MAGIC_WALL_EMPTYING: return EL_DC_MAGIC_WALL_ACTIVE;
9544 case EL_AMOEBA_DROPPING: return EL_AMOEBA_WET;
9546 default: return element;
9550 int el2img_mm(int element_mm)
9552 return el2img(map_element_MM_to_RND(element_mm));
9555 int el_act2img_mm(int element_mm, int action)
9557 return el_act2img(map_element_MM_to_RND(element_mm), action);
9560 int el_act_dir2img(int element, int action, int direction)
9562 element = GFX_ELEMENT(element);
9563 direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
9565 // direction_graphic[][] == graphic[] for undefined direction graphics
9566 return element_info[element].direction_graphic[action][direction];
9569 static int el_act_dir2crm(int element, int action, int direction)
9571 element = GFX_ELEMENT(element);
9572 direction = MV_DIR_TO_BIT(direction); // default: MV_NONE => MV_DOWN
9574 // direction_graphic[][] == graphic[] for undefined direction graphics
9575 return element_info[element].direction_crumbled[action][direction];
9578 int el_act2img(int element, int action)
9580 element = GFX_ELEMENT(element);
9582 return element_info[element].graphic[action];
9585 int el_act2crm(int element, int action)
9587 element = GFX_ELEMENT(element);
9589 return element_info[element].crumbled[action];
9592 int el_dir2img(int element, int direction)
9594 element = GFX_ELEMENT(element);
9596 return el_act_dir2img(element, ACTION_DEFAULT, direction);
9599 int el2baseimg(int element)
9601 return element_info[element].graphic[ACTION_DEFAULT];
9604 int el2img(int element)
9606 element = GFX_ELEMENT(element);
9608 return element_info[element].graphic[ACTION_DEFAULT];
9611 int el2edimg(int element)
9613 element = GFX_ELEMENT(element);
9615 return element_info[element].special_graphic[GFX_SPECIAL_ARG_EDITOR];
9618 int el2preimg(int element)
9620 element = GFX_ELEMENT(element);
9622 return element_info[element].special_graphic[GFX_SPECIAL_ARG_PREVIEW];
9625 int el2panelimg(int element)
9627 element = GFX_ELEMENT(element);
9629 return element_info[element].special_graphic[GFX_SPECIAL_ARG_PANEL];
9632 int font2baseimg(int font_nr)
9634 return font_info[font_nr].special_graphic[GFX_SPECIAL_ARG_DEFAULT];
9637 int getBeltNrFromBeltElement(int element)
9639 return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
9640 element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
9641 element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
9644 int getBeltNrFromBeltActiveElement(int element)
9646 return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
9647 element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
9648 element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
9651 int getBeltNrFromBeltSwitchElement(int element)
9653 return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
9654 element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
9655 element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
9658 int getBeltDirNrFromBeltElement(int element)
9660 static int belt_base_element[4] =
9662 EL_CONVEYOR_BELT_1_LEFT,
9663 EL_CONVEYOR_BELT_2_LEFT,
9664 EL_CONVEYOR_BELT_3_LEFT,
9665 EL_CONVEYOR_BELT_4_LEFT
9668 int belt_nr = getBeltNrFromBeltElement(element);
9669 int belt_dir_nr = element - belt_base_element[belt_nr];
9671 return (belt_dir_nr % 3);
9674 int getBeltDirNrFromBeltSwitchElement(int element)
9676 static int belt_base_element[4] =
9678 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
9679 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
9680 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
9681 EL_CONVEYOR_BELT_4_SWITCH_LEFT
9684 int belt_nr = getBeltNrFromBeltSwitchElement(element);
9685 int belt_dir_nr = element - belt_base_element[belt_nr];
9687 return (belt_dir_nr % 3);
9690 int getBeltDirFromBeltElement(int element)
9692 static int belt_move_dir[3] =
9699 int belt_dir_nr = getBeltDirNrFromBeltElement(element);
9701 return belt_move_dir[belt_dir_nr];
9704 int getBeltDirFromBeltSwitchElement(int element)
9706 static int belt_move_dir[3] =
9713 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
9715 return belt_move_dir[belt_dir_nr];
9718 int getBeltElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
9720 static int belt_base_element[4] =
9722 EL_CONVEYOR_BELT_1_LEFT,
9723 EL_CONVEYOR_BELT_2_LEFT,
9724 EL_CONVEYOR_BELT_3_LEFT,
9725 EL_CONVEYOR_BELT_4_LEFT
9728 return belt_base_element[belt_nr] + belt_dir_nr;
9731 int getBeltElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
9733 int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
9735 return getBeltElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
9738 int getBeltSwitchElementFromBeltNrAndBeltDirNr(int belt_nr, int belt_dir_nr)
9740 static int belt_base_element[4] =
9742 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
9743 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
9744 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
9745 EL_CONVEYOR_BELT_4_SWITCH_LEFT
9748 return belt_base_element[belt_nr] + belt_dir_nr;
9751 int getBeltSwitchElementFromBeltNrAndBeltDir(int belt_nr, int belt_dir)
9753 int belt_dir_nr = (belt_dir == MV_LEFT ? 0 : belt_dir == MV_RIGHT ? 2 : 1);
9755 return getBeltSwitchElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
9758 boolean swapTiles_EM(boolean is_pre_emc_cave)
9760 return is_pre_emc_cave && leveldir_current->use_emc_tiles;
9763 boolean getTeamMode_EM(void)
9765 return game.team_mode || network_playing;
9768 boolean isActivePlayer_EM(int player_nr)
9770 return stored_player[player_nr].active;
9773 unsigned int InitRND(int seed)
9775 if (level.game_engine_type == GAME_ENGINE_TYPE_BD)
9776 return InitEngineRandom_BD(seed);
9777 else if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
9778 return InitEngineRandom_EM(seed);
9779 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
9780 return InitEngineRandom_SP(seed);
9781 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
9782 return InitEngineRandom_MM(seed);
9784 return InitEngineRandom_RND(seed);
9787 static struct Mapping_BD_to_RND_object bd_object_mapping[O_MAX_ALL];
9788 static struct Mapping_EM_to_RND_object em_object_mapping[GAME_TILE_MAX];
9789 static struct Mapping_EM_to_RND_player em_player_mapping[MAX_PLAYERS][PLY_MAX];
9791 static int get_effective_element_EM(int tile, int frame_em)
9793 int element = em_object_mapping[tile].element_rnd;
9794 int action = em_object_mapping[tile].action;
9795 boolean is_backside = em_object_mapping[tile].is_backside;
9796 boolean action_removing = (action == ACTION_DIGGING ||
9797 action == ACTION_SNAPPING ||
9798 action == ACTION_COLLECTING);
9806 return (frame_em > 5 ? EL_EMPTY : element);
9812 else // frame_em == 7
9823 case Ydiamond_stone:
9827 case Xdrip_stretchB:
9843 case Ymagnify_blank:
9846 case Xsand_stonein_1:
9847 case Xsand_stonein_2:
9848 case Xsand_stonein_3:
9849 case Xsand_stonein_4:
9853 return (is_backside || action_removing ? EL_EMPTY : element);
9858 static boolean check_linear_animation_EM(int tile)
9862 case Xsand_stonesand_1:
9863 case Xsand_stonesand_quickout_1:
9864 case Xsand_sandstone_1:
9865 case Xsand_stonein_1:
9866 case Xsand_stoneout_1:
9894 static void set_crumbled_graphics_EM(struct GraphicInfo_EM *g_em,
9895 boolean has_crumbled_graphics,
9896 int crumbled, int sync_frame)
9898 // if element can be crumbled, but certain action graphics are just empty
9899 // space (like instantly snapping sand to empty space in 1 frame), do not
9900 // treat these empty space graphics as crumbled graphics in EMC engine
9901 if (crumbled == IMG_EMPTY_SPACE)
9902 has_crumbled_graphics = FALSE;
9904 if (has_crumbled_graphics)
9906 struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
9907 int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
9908 g_crumbled->anim_delay,
9909 g_crumbled->anim_mode,
9910 g_crumbled->anim_start_frame,
9913 getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
9914 &g_em->crumbled_src_x, &g_em->crumbled_src_y);
9916 g_em->crumbled_border_size = graphic_info[crumbled].border_size;
9917 g_em->crumbled_tile_size = graphic_info[crumbled].tile_size;
9919 g_em->has_crumbled_graphics = TRUE;
9923 g_em->crumbled_bitmap = NULL;
9924 g_em->crumbled_src_x = 0;
9925 g_em->crumbled_src_y = 0;
9926 g_em->crumbled_border_size = 0;
9927 g_em->crumbled_tile_size = 0;
9929 g_em->has_crumbled_graphics = FALSE;
9934 void ResetGfxAnimation_EM(int x, int y, int tile)
9940 void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
9941 int tile, int frame_em, int x, int y)
9943 int action = em_object_mapping[tile].action;
9944 int direction = em_object_mapping[tile].direction;
9945 int effective_element = get_effective_element_EM(tile, frame_em);
9946 int graphic = (direction == MV_NONE ?
9947 el_act2img(effective_element, action) :
9948 el_act_dir2img(effective_element, action, direction));
9949 struct GraphicInfo *g = &graphic_info[graphic];
9951 boolean action_removing = (action == ACTION_DIGGING ||
9952 action == ACTION_SNAPPING ||
9953 action == ACTION_COLLECTING);
9954 boolean action_moving = (action == ACTION_FALLING ||
9955 action == ACTION_MOVING ||
9956 action == ACTION_PUSHING ||
9957 action == ACTION_EATING ||
9958 action == ACTION_FILLING ||
9959 action == ACTION_EMPTYING);
9960 boolean action_falling = (action == ACTION_FALLING ||
9961 action == ACTION_FILLING ||
9962 action == ACTION_EMPTYING);
9964 // special case: graphic uses "2nd movement tile" and has defined
9965 // 7 frames for movement animation (or less) => use default graphic
9966 // for last (8th) frame which ends the movement animation
9967 if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
9969 action = ACTION_DEFAULT; // (keep action_* unchanged for now)
9970 graphic = (direction == MV_NONE ?
9971 el_act2img(effective_element, action) :
9972 el_act_dir2img(effective_element, action, direction));
9974 g = &graphic_info[graphic];
9977 if ((action_removing || check_linear_animation_EM(tile)) && frame_em == 0)
9981 else if (action_moving)
9983 boolean is_backside = em_object_mapping[tile].is_backside;
9987 int direction = em_object_mapping[tile].direction;
9988 int move_dir = (action_falling ? MV_DOWN : direction);
9993 // !!! TEST !!! NEW !!! DOES NOT WORK RIGHT YET !!!
9994 if (g->double_movement && frame_em == 0)
9998 if (move_dir == MV_LEFT)
9999 GfxFrame[x - 1][y] = GfxFrame[x][y];
10000 else if (move_dir == MV_RIGHT)
10001 GfxFrame[x + 1][y] = GfxFrame[x][y];
10002 else if (move_dir == MV_UP)
10003 GfxFrame[x][y - 1] = GfxFrame[x][y];
10004 else if (move_dir == MV_DOWN)
10005 GfxFrame[x][y + 1] = GfxFrame[x][y];
10012 // special case: animation for Xsand_stonesand_quickout_1/2 twice as fast
10013 if (tile == Xsand_stonesand_quickout_1 ||
10014 tile == Xsand_stonesand_quickout_2)
10018 if (graphic_info[graphic].anim_global_sync)
10019 sync_frame = FrameCounter;
10020 else if (graphic_info[graphic].anim_global_anim_sync)
10021 sync_frame = getGlobalAnimSyncFrame();
10022 else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
10023 sync_frame = GfxFrame[x][y];
10025 sync_frame = 0; // playfield border (pseudo steel)
10027 SetRandomAnimationValue(x, y);
10029 int frame = getAnimationFrame(g->anim_frames,
10032 g->anim_start_frame,
10035 g_em->unique_identifier =
10036 (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
10039 void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
10040 int tile, int frame_em, int x, int y)
10042 int action = em_object_mapping[tile].action;
10043 int direction = em_object_mapping[tile].direction;
10044 boolean is_backside = em_object_mapping[tile].is_backside;
10045 int effective_element = get_effective_element_EM(tile, frame_em);
10046 int effective_action = action;
10047 int graphic = (direction == MV_NONE ?
10048 el_act2img(effective_element, effective_action) :
10049 el_act_dir2img(effective_element, effective_action,
10051 int crumbled = (direction == MV_NONE ?
10052 el_act2crm(effective_element, effective_action) :
10053 el_act_dir2crm(effective_element, effective_action,
10055 int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
10056 int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
10057 boolean has_crumbled_graphics = (base_crumbled != base_graphic);
10058 struct GraphicInfo *g = &graphic_info[graphic];
10061 // special case: graphic uses "2nd movement tile" and has defined
10062 // 7 frames for movement animation (or less) => use default graphic
10063 // for last (8th) frame which ends the movement animation
10064 if (g->double_movement && g->anim_frames < 8 && frame_em == 7)
10066 effective_action = ACTION_DEFAULT;
10067 graphic = (direction == MV_NONE ?
10068 el_act2img(effective_element, effective_action) :
10069 el_act_dir2img(effective_element, effective_action,
10071 crumbled = (direction == MV_NONE ?
10072 el_act2crm(effective_element, effective_action) :
10073 el_act_dir2crm(effective_element, effective_action,
10076 g = &graphic_info[graphic];
10079 if (graphic_info[graphic].anim_global_sync)
10080 sync_frame = FrameCounter;
10081 else if (graphic_info[graphic].anim_global_anim_sync)
10082 sync_frame = getGlobalAnimSyncFrame();
10083 else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
10084 sync_frame = GfxFrame[x][y];
10086 sync_frame = 0; // playfield border (pseudo steel)
10088 SetRandomAnimationValue(x, y);
10090 int frame = getAnimationFrame(g->anim_frames,
10093 g->anim_start_frame,
10096 getGraphicSourceExt(graphic, frame, &g_em->bitmap, &g_em->src_x, &g_em->src_y,
10097 g->double_movement && is_backside);
10099 // (updating the "crumbled" graphic definitions is probably not really needed,
10100 // as animations for crumbled graphics can't be longer than one EMC cycle)
10101 set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
10105 void getGraphicSourcePlayerExt_EM(struct GraphicInfo_EM *g_em,
10106 int player_nr, int anim, int frame_em)
10108 int element = em_player_mapping[player_nr][anim].element_rnd;
10109 int action = em_player_mapping[player_nr][anim].action;
10110 int direction = em_player_mapping[player_nr][anim].direction;
10111 int graphic = (direction == MV_NONE ?
10112 el_act2img(element, action) :
10113 el_act_dir2img(element, action, direction));
10114 struct GraphicInfo *g = &graphic_info[graphic];
10117 InitPlayerGfxAnimation(&stored_player[player_nr], action, direction);
10119 stored_player[player_nr].StepFrame = frame_em;
10121 sync_frame = stored_player[player_nr].Frame;
10123 int frame = getAnimationFrame(g->anim_frames,
10126 g->anim_start_frame,
10129 getGraphicSourceExt(graphic, frame, &g_em->bitmap,
10130 &g_em->src_x, &g_em->src_y, FALSE);
10133 #define BD_GFX_RANGE(a, n, i) ((i) >= (a) && (i) < (a) + (n))
10134 #define BD_GFX_FRAME(b, i) (((i) - (b)) * 8)
10136 void InitGraphicInfo_BD(void)
10140 // always start with reliable default values
10141 for (i = 0; i < O_MAX_ALL; i++)
10143 bd_object_mapping[i].element_rnd = EL_UNKNOWN;
10144 bd_object_mapping[i].action = ACTION_DEFAULT;
10145 bd_object_mapping[i].direction = MV_NONE;
10148 for (i = 0; bd_object_mapping_list[i].element_bd != -1; i++)
10150 int e = bd_object_mapping_list[i].element_bd;
10152 bd_object_mapping[e].element_rnd = bd_object_mapping_list[i].element_rnd;
10154 if (bd_object_mapping_list[i].action != -1)
10155 bd_object_mapping[e].action = bd_object_mapping_list[i].action;
10157 if (bd_object_mapping_list[i].direction != -1)
10158 bd_object_mapping[e].direction =
10159 MV_DIR_FROM_BIT(bd_object_mapping_list[i].direction);
10162 for (i = 0; i < O_MAX_ALL; i++)
10164 int element = bd_object_mapping[i].element_rnd;
10165 int action = bd_object_mapping[i].action;
10166 int direction = bd_object_mapping[i].direction;
10168 for (j = 0; j < 8; j++)
10170 int effective_element = element;
10171 int effective_action = action;
10172 int graphic = (el_act_dir2img(effective_element, effective_action,
10174 struct GraphicInfo *g = &graphic_info[graphic];
10175 struct GraphicInfo_BD *g_bd = &graphic_info_bd_object[i][j];
10176 Bitmap *src_bitmap;
10178 int sync_frame = (BD_GFX_RANGE(O_PRE_PL_1, 3, i) ? BD_GFX_FRAME(O_PRE_PL_1, i) :
10179 BD_GFX_RANGE(O_PRE_DIA_1, 5, i) ? BD_GFX_FRAME(O_PRE_DIA_1, i) :
10180 BD_GFX_RANGE(O_PRE_STONE_1, 4, i) ? BD_GFX_FRAME(O_PRE_STONE_1, i) :
10181 BD_GFX_RANGE(O_PRE_STEEL_1, 4, i) ? BD_GFX_FRAME(O_PRE_STEEL_1, i) :
10182 BD_GFX_RANGE(O_BOMB_TICK_1, 7, i) ? BD_GFX_FRAME(O_BOMB_TICK_1, i) :
10183 BD_GFX_RANGE(O_BOMB_EXPL_1, 4, i) ? BD_GFX_FRAME(O_BOMB_EXPL_1, i) :
10184 BD_GFX_RANGE(O_NUT_EXPL_1, 4, i) ? BD_GFX_FRAME(O_NUT_EXPL_1, i) :
10185 BD_GFX_RANGE(O_GHOST_EXPL_1, 4, i) ? BD_GFX_FRAME(O_GHOST_EXPL_1, i) :
10186 BD_GFX_RANGE(O_EXPLODE_1, 5, i) ? BD_GFX_FRAME(O_EXPLODE_1, i) :
10187 BD_GFX_RANGE(O_PRE_CLOCK_1, 4, i) ? BD_GFX_FRAME(O_PRE_CLOCK_1, i) :
10188 BD_GFX_RANGE(O_NITRO_EXPL_1, 4, i) ? BD_GFX_FRAME(O_NITRO_EXPL_1, i) :
10189 BD_GFX_RANGE(O_AMOEBA_2_EXPL_1, 4, i) ? BD_GFX_FRAME(O_AMOEBA_2_EXPL_1, i):
10190 i == O_INBOX_OPEN || i == O_OUTBOX_OPEN ? j :
10192 int frame = getAnimationFrame(g->anim_frames,
10195 g->anim_start_frame,
10198 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
10200 g_bd->bitmap = src_bitmap;
10201 g_bd->src_x = src_x;
10202 g_bd->src_y = src_y;
10203 g_bd->width = TILEX;
10204 g_bd->height = TILEY;
10208 // game graphics template for level-specific colors for native BD levels
10209 int graphic = IMG_BD_GAME_GRAPHICS_COLOR_TEMPLATE;
10210 struct GraphicInfo_BD *g_bd = &graphic_info_bd_color_template;
10211 Bitmap *src_bitmap;
10214 getGraphicSourceExt(graphic, 0, &src_bitmap, &src_x, &src_y, FALSE);
10216 g_bd->bitmap = src_bitmap;
10217 g_bd->src_x = src_x;
10218 g_bd->src_y = src_y;
10219 g_bd->width = TILEX;
10220 g_bd->height = TILEY;
10223 void InitGraphicInfo_EM(void)
10227 // always start with reliable default values
10228 for (i = 0; i < GAME_TILE_MAX; i++)
10230 em_object_mapping[i].element_rnd = EL_UNKNOWN;
10231 em_object_mapping[i].is_backside = FALSE;
10232 em_object_mapping[i].action = ACTION_DEFAULT;
10233 em_object_mapping[i].direction = MV_NONE;
10236 // always start with reliable default values
10237 for (p = 0; p < MAX_PLAYERS; p++)
10239 for (i = 0; i < PLY_MAX; i++)
10241 em_player_mapping[p][i].element_rnd = EL_UNKNOWN;
10242 em_player_mapping[p][i].action = ACTION_DEFAULT;
10243 em_player_mapping[p][i].direction = MV_NONE;
10247 for (i = 0; em_object_mapping_list[i].element_em != -1; i++)
10249 int e = em_object_mapping_list[i].element_em;
10251 em_object_mapping[e].element_rnd = em_object_mapping_list[i].element_rnd;
10252 em_object_mapping[e].is_backside = em_object_mapping_list[i].is_backside;
10254 if (em_object_mapping_list[i].action != -1)
10255 em_object_mapping[e].action = em_object_mapping_list[i].action;
10257 if (em_object_mapping_list[i].direction != -1)
10258 em_object_mapping[e].direction =
10259 MV_DIR_FROM_BIT(em_object_mapping_list[i].direction);
10262 for (i = 0; em_player_mapping_list[i].action_em != -1; i++)
10264 int a = em_player_mapping_list[i].action_em;
10265 int p = em_player_mapping_list[i].player_nr;
10267 em_player_mapping[p][a].element_rnd = em_player_mapping_list[i].element_rnd;
10269 if (em_player_mapping_list[i].action != -1)
10270 em_player_mapping[p][a].action = em_player_mapping_list[i].action;
10272 if (em_player_mapping_list[i].direction != -1)
10273 em_player_mapping[p][a].direction =
10274 MV_DIR_FROM_BIT(em_player_mapping_list[i].direction);
10277 for (i = 0; i < GAME_TILE_MAX; i++)
10279 int element = em_object_mapping[i].element_rnd;
10280 int action = em_object_mapping[i].action;
10281 int direction = em_object_mapping[i].direction;
10282 boolean is_backside = em_object_mapping[i].is_backside;
10283 boolean action_exploding = ((action == ACTION_EXPLODING ||
10284 action == ACTION_SMASHED_BY_ROCK ||
10285 action == ACTION_SMASHED_BY_SPRING) &&
10286 element != EL_DIAMOND);
10287 boolean action_active = (action == ACTION_ACTIVE);
10288 boolean action_other = (action == ACTION_OTHER);
10290 for (j = 0; j < 8; j++)
10292 int effective_element = get_effective_element_EM(i, j);
10293 int effective_action = (j < 7 ? action :
10294 i == Xdrip_stretch ? action :
10295 i == Xdrip_stretchB ? action :
10296 i == Ydrip_1_s ? action :
10297 i == Ydrip_1_sB ? action :
10298 i == Yball_1 ? action :
10299 i == Xball_2 ? action :
10300 i == Yball_2 ? action :
10301 i == Yball_blank ? action :
10302 i == Ykey_1_blank ? action :
10303 i == Ykey_2_blank ? action :
10304 i == Ykey_3_blank ? action :
10305 i == Ykey_4_blank ? action :
10306 i == Ykey_5_blank ? action :
10307 i == Ykey_6_blank ? action :
10308 i == Ykey_7_blank ? action :
10309 i == Ykey_8_blank ? action :
10310 i == Ylenses_blank ? action :
10311 i == Ymagnify_blank ? action :
10312 i == Ygrass_blank ? action :
10313 i == Ydirt_blank ? action :
10314 i == Xsand_stonein_1 ? action :
10315 i == Xsand_stonein_2 ? action :
10316 i == Xsand_stonein_3 ? action :
10317 i == Xsand_stonein_4 ? action :
10318 i == Xsand_stoneout_1 ? action :
10319 i == Xsand_stoneout_2 ? action :
10320 i == Xboom_android ? ACTION_EXPLODING :
10321 action_exploding ? ACTION_EXPLODING :
10322 action_active ? action :
10323 action_other ? action :
10325 int graphic = (el_act_dir2img(effective_element, effective_action,
10327 int crumbled = (el_act_dir2crm(effective_element, effective_action,
10329 int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
10330 int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
10331 boolean has_action_graphics = (graphic != base_graphic);
10332 boolean has_crumbled_graphics = (base_crumbled != base_graphic);
10333 struct GraphicInfo *g = &graphic_info[graphic];
10334 struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
10335 Bitmap *src_bitmap;
10337 // ensure to get symmetric 3-frame, 2-delay animations as used in EM
10338 boolean special_animation = (action != ACTION_DEFAULT &&
10339 g->anim_frames == 3 &&
10340 g->anim_delay == 2 &&
10341 g->anim_mode & ANIM_LINEAR);
10342 int sync_frame = (i == Xdrip_stretch ? 7 :
10343 i == Xdrip_stretchB ? 7 :
10344 i == Ydrip_2_s ? j + 8 :
10345 i == Ydrip_2_sB ? j + 8 :
10347 i == Xacid_2 ? 10 :
10348 i == Xacid_3 ? 20 :
10349 i == Xacid_4 ? 30 :
10350 i == Xacid_5 ? 40 :
10351 i == Xacid_6 ? 50 :
10352 i == Xacid_7 ? 60 :
10353 i == Xacid_8 ? 70 :
10354 i == Xfake_acid_1 ? 0 :
10355 i == Xfake_acid_2 ? 10 :
10356 i == Xfake_acid_3 ? 20 :
10357 i == Xfake_acid_4 ? 30 :
10358 i == Xfake_acid_5 ? 40 :
10359 i == Xfake_acid_6 ? 50 :
10360 i == Xfake_acid_7 ? 60 :
10361 i == Xfake_acid_8 ? 70 :
10362 i == Xfake_acid_1_player ? 0 :
10363 i == Xfake_acid_2_player ? 10 :
10364 i == Xfake_acid_3_player ? 20 :
10365 i == Xfake_acid_4_player ? 30 :
10366 i == Xfake_acid_5_player ? 40 :
10367 i == Xfake_acid_6_player ? 50 :
10368 i == Xfake_acid_7_player ? 60 :
10369 i == Xfake_acid_8_player ? 70 :
10371 i == Yball_2 ? j + 8 :
10372 i == Yball_blank ? j + 1 :
10373 i == Ykey_1_blank ? j + 1 :
10374 i == Ykey_2_blank ? j + 1 :
10375 i == Ykey_3_blank ? j + 1 :
10376 i == Ykey_4_blank ? j + 1 :
10377 i == Ykey_5_blank ? j + 1 :
10378 i == Ykey_6_blank ? j + 1 :
10379 i == Ykey_7_blank ? j + 1 :
10380 i == Ykey_8_blank ? j + 1 :
10381 i == Ylenses_blank ? j + 1 :
10382 i == Ymagnify_blank ? j + 1 :
10383 i == Ygrass_blank ? j + 1 :
10384 i == Ydirt_blank ? j + 1 :
10385 i == Xamoeba_1 ? 0 :
10386 i == Xamoeba_2 ? 1 :
10387 i == Xamoeba_3 ? 2 :
10388 i == Xamoeba_4 ? 3 :
10389 i == Xamoeba_5 ? 0 :
10390 i == Xamoeba_6 ? 1 :
10391 i == Xamoeba_7 ? 2 :
10392 i == Xamoeba_8 ? 3 :
10393 i == Xexit_2 ? j + 8 :
10394 i == Xexit_3 ? j + 16 :
10395 i == Xdynamite_1 ? 0 :
10396 i == Xdynamite_2 ? 8 :
10397 i == Xdynamite_3 ? 16 :
10398 i == Xdynamite_4 ? 24 :
10399 i == Xsand_stonein_1 ? j + 1 :
10400 i == Xsand_stonein_2 ? j + 9 :
10401 i == Xsand_stonein_3 ? j + 17 :
10402 i == Xsand_stonein_4 ? j + 25 :
10403 i == Xsand_stoneout_1 && j == 0 ? 0 :
10404 i == Xsand_stoneout_1 && j == 1 ? 0 :
10405 i == Xsand_stoneout_1 && j == 2 ? 1 :
10406 i == Xsand_stoneout_1 && j == 3 ? 2 :
10407 i == Xsand_stoneout_1 && j == 4 ? 2 :
10408 i == Xsand_stoneout_1 && j == 5 ? 3 :
10409 i == Xsand_stoneout_1 && j == 6 ? 4 :
10410 i == Xsand_stoneout_1 && j == 7 ? 4 :
10411 i == Xsand_stoneout_2 && j == 0 ? 5 :
10412 i == Xsand_stoneout_2 && j == 1 ? 6 :
10413 i == Xsand_stoneout_2 && j == 2 ? 7 :
10414 i == Xsand_stoneout_2 && j == 3 ? 8 :
10415 i == Xsand_stoneout_2 && j == 4 ? 9 :
10416 i == Xsand_stoneout_2 && j == 5 ? 11 :
10417 i == Xsand_stoneout_2 && j == 6 ? 13 :
10418 i == Xsand_stoneout_2 && j == 7 ? 15 :
10419 i == Xboom_bug && j == 1 ? 2 :
10420 i == Xboom_bug && j == 2 ? 2 :
10421 i == Xboom_bug && j == 3 ? 4 :
10422 i == Xboom_bug && j == 4 ? 4 :
10423 i == Xboom_bug && j == 5 ? 2 :
10424 i == Xboom_bug && j == 6 ? 2 :
10425 i == Xboom_bug && j == 7 ? 0 :
10426 i == Xboom_tank && j == 1 ? 2 :
10427 i == Xboom_tank && j == 2 ? 2 :
10428 i == Xboom_tank && j == 3 ? 4 :
10429 i == Xboom_tank && j == 4 ? 4 :
10430 i == Xboom_tank && j == 5 ? 2 :
10431 i == Xboom_tank && j == 6 ? 2 :
10432 i == Xboom_tank && j == 7 ? 0 :
10433 i == Xboom_android && j == 7 ? 6 :
10434 i == Xboom_1 && j == 1 ? 2 :
10435 i == Xboom_1 && j == 2 ? 2 :
10436 i == Xboom_1 && j == 3 ? 4 :
10437 i == Xboom_1 && j == 4 ? 4 :
10438 i == Xboom_1 && j == 5 ? 6 :
10439 i == Xboom_1 && j == 6 ? 6 :
10440 i == Xboom_1 && j == 7 ? 8 :
10441 i == Xboom_2 && j == 0 ? 8 :
10442 i == Xboom_2 && j == 1 ? 8 :
10443 i == Xboom_2 && j == 2 ? 10 :
10444 i == Xboom_2 && j == 3 ? 10 :
10445 i == Xboom_2 && j == 4 ? 10 :
10446 i == Xboom_2 && j == 5 ? 12 :
10447 i == Xboom_2 && j == 6 ? 12 :
10448 i == Xboom_2 && j == 7 ? 12 :
10449 special_animation && j == 4 ? 3 :
10450 effective_action != action ? 0 :
10452 int frame = getAnimationFrame(g->anim_frames,
10455 g->anim_start_frame,
10458 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y,
10459 g->double_movement && is_backside);
10461 g_em->bitmap = src_bitmap;
10462 g_em->src_x = src_x;
10463 g_em->src_y = src_y;
10464 g_em->src_offset_x = 0;
10465 g_em->src_offset_y = 0;
10466 g_em->dst_offset_x = 0;
10467 g_em->dst_offset_y = 0;
10468 g_em->width = TILEX;
10469 g_em->height = TILEY;
10471 g_em->preserve_background = FALSE;
10473 set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
10476 if ((!g->double_movement && (effective_action == ACTION_FALLING ||
10477 effective_action == ACTION_MOVING ||
10478 effective_action == ACTION_PUSHING ||
10479 effective_action == ACTION_EATING)) ||
10480 (!has_action_graphics && (effective_action == ACTION_FILLING ||
10481 effective_action == ACTION_EMPTYING)))
10484 (effective_action == ACTION_FALLING ||
10485 effective_action == ACTION_FILLING ||
10486 effective_action == ACTION_EMPTYING ? MV_DOWN : direction);
10487 int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? 1 : 0);
10488 int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? 1 : 0);
10489 int num_steps = (i == Ydrip_1_s ? 16 :
10490 i == Ydrip_1_sB ? 16 :
10491 i == Ydrip_2_s ? 16 :
10492 i == Ydrip_2_sB ? 16 :
10493 i == Xsand_stonein_1 ? 32 :
10494 i == Xsand_stonein_2 ? 32 :
10495 i == Xsand_stonein_3 ? 32 :
10496 i == Xsand_stonein_4 ? 32 :
10497 i == Xsand_stoneout_1 ? 16 :
10498 i == Xsand_stoneout_2 ? 16 : 8);
10499 int cx = ABS(dx) * (TILEX / num_steps);
10500 int cy = ABS(dy) * (TILEY / num_steps);
10501 int step_frame = (i == Ydrip_2_s ? j + 8 :
10502 i == Ydrip_2_sB ? j + 8 :
10503 i == Xsand_stonein_2 ? j + 8 :
10504 i == Xsand_stonein_3 ? j + 16 :
10505 i == Xsand_stonein_4 ? j + 24 :
10506 i == Xsand_stoneout_2 ? j + 8 : j) + 1;
10507 int step = (is_backside ? step_frame : num_steps - step_frame);
10509 if (is_backside) // tile where movement starts
10511 if (dx < 0 || dy < 0)
10513 g_em->src_offset_x = cx * step;
10514 g_em->src_offset_y = cy * step;
10518 g_em->dst_offset_x = cx * step;
10519 g_em->dst_offset_y = cy * step;
10522 else // tile where movement ends
10524 if (dx < 0 || dy < 0)
10526 g_em->dst_offset_x = cx * step;
10527 g_em->dst_offset_y = cy * step;
10531 g_em->src_offset_x = cx * step;
10532 g_em->src_offset_y = cy * step;
10536 g_em->width = TILEX - cx * step;
10537 g_em->height = TILEY - cy * step;
10540 // create unique graphic identifier to decide if tile must be redrawn
10541 /* bit 31 - 16 (16 bit): EM style graphic
10542 bit 15 - 12 ( 4 bit): EM style frame
10543 bit 11 - 6 ( 6 bit): graphic width
10544 bit 5 - 0 ( 6 bit): graphic height */
10545 g_em->unique_identifier =
10546 (graphic << 16) | (frame << 12) | (g_em->width << 6) | g_em->height;
10550 for (i = 0; i < GAME_TILE_MAX; i++)
10552 for (j = 0; j < 8; j++)
10554 int element = em_object_mapping[i].element_rnd;
10555 int action = em_object_mapping[i].action;
10556 int direction = em_object_mapping[i].direction;
10557 boolean is_backside = em_object_mapping[i].is_backside;
10558 int graphic_action = el_act_dir2img(element, action, direction);
10559 int graphic_default = el_act_dir2img(element, ACTION_DEFAULT, direction);
10561 if ((action == ACTION_SMASHED_BY_ROCK ||
10562 action == ACTION_SMASHED_BY_SPRING ||
10563 action == ACTION_EATING) &&
10564 graphic_action == graphic_default)
10566 int e = (action == ACTION_SMASHED_BY_ROCK ? Ystone_s :
10567 action == ACTION_SMASHED_BY_SPRING ? Yspring_s :
10568 direction == MV_LEFT ? (is_backside? Yspring_wB: Yspring_w) :
10569 direction == MV_RIGHT ? (is_backside? Yspring_eB: Yspring_e) :
10572 // no separate animation for "smashed by rock" -- use rock instead
10573 struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][j];
10574 struct GraphicInfo_EM *g_xx = &graphic_info_em_object[e][j];
10576 g_em->bitmap = g_xx->bitmap;
10577 g_em->src_x = g_xx->src_x;
10578 g_em->src_y = g_xx->src_y;
10579 g_em->src_offset_x = g_xx->src_offset_x;
10580 g_em->src_offset_y = g_xx->src_offset_y;
10581 g_em->dst_offset_x = g_xx->dst_offset_x;
10582 g_em->dst_offset_y = g_xx->dst_offset_y;
10583 g_em->width = g_xx->width;
10584 g_em->height = g_xx->height;
10585 g_em->unique_identifier = g_xx->unique_identifier;
10588 g_em->preserve_background = TRUE;
10593 for (p = 0; p < MAX_PLAYERS; p++)
10595 for (i = 0; i < PLY_MAX; i++)
10597 int element = em_player_mapping[p][i].element_rnd;
10598 int action = em_player_mapping[p][i].action;
10599 int direction = em_player_mapping[p][i].direction;
10601 for (j = 0; j < 8; j++)
10603 int effective_element = element;
10604 int effective_action = action;
10605 int graphic = (direction == MV_NONE ?
10606 el_act2img(effective_element, effective_action) :
10607 el_act_dir2img(effective_element, effective_action,
10609 struct GraphicInfo *g = &graphic_info[graphic];
10610 struct GraphicInfo_EM *g_em = &graphic_info_em_player[p][i][j];
10611 Bitmap *src_bitmap;
10613 int sync_frame = j;
10614 int frame = getAnimationFrame(g->anim_frames,
10617 g->anim_start_frame,
10620 getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE);
10622 g_em->bitmap = src_bitmap;
10623 g_em->src_x = src_x;
10624 g_em->src_y = src_y;
10625 g_em->src_offset_x = 0;
10626 g_em->src_offset_y = 0;
10627 g_em->dst_offset_x = 0;
10628 g_em->dst_offset_y = 0;
10629 g_em->width = TILEX;
10630 g_em->height = TILEY;
10636 static void CheckSaveEngineSnapshot_EM(int frame,
10637 boolean any_player_moving,
10638 boolean any_player_snapping,
10639 boolean any_player_dropping)
10641 if (frame == 7 && !any_player_dropping)
10643 if (!local_player->was_waiting)
10645 if (!CheckSaveEngineSnapshotToList())
10648 local_player->was_waiting = TRUE;
10651 else if (any_player_moving || any_player_snapping || any_player_dropping)
10653 local_player->was_waiting = FALSE;
10657 static void CheckSaveEngineSnapshot_SP(boolean murphy_is_waiting,
10658 boolean murphy_is_dropping)
10660 if (murphy_is_waiting)
10662 if (!local_player->was_waiting)
10664 if (!CheckSaveEngineSnapshotToList())
10667 local_player->was_waiting = TRUE;
10672 local_player->was_waiting = FALSE;
10676 static void CheckSaveEngineSnapshot_MM(boolean element_clicked,
10677 boolean button_released)
10679 if (button_released)
10681 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE)
10682 CheckSaveEngineSnapshotToList();
10684 else if (element_clicked)
10686 if (game.snapshot.mode != SNAPSHOT_MODE_EVERY_MOVE)
10687 CheckSaveEngineSnapshotToList();
10689 game.snapshot.changed_action = TRUE;
10693 boolean CheckSingleStepMode_EM(int frame,
10694 boolean any_player_moving,
10695 boolean any_player_snapping,
10696 boolean any_player_dropping)
10698 if (tape.single_step && tape.recording && !tape.pausing)
10699 if (frame == 7 && !any_player_dropping && FrameCounter > 6)
10700 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
10702 CheckSaveEngineSnapshot_EM(frame, any_player_moving,
10703 any_player_snapping, any_player_dropping);
10705 return tape.pausing;
10708 void CheckSingleStepMode_SP(boolean murphy_is_waiting,
10709 boolean murphy_is_dropping)
10711 boolean murphy_starts_dropping = FALSE;
10714 for (i = 0; i < MAX_PLAYERS; i++)
10715 if (stored_player[i].force_dropping)
10716 murphy_starts_dropping = TRUE;
10718 if (tape.single_step && tape.recording && !tape.pausing)
10719 if (murphy_is_waiting && !murphy_starts_dropping)
10720 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
10722 CheckSaveEngineSnapshot_SP(murphy_is_waiting, murphy_is_dropping);
10725 void CheckSingleStepMode_MM(boolean element_clicked,
10726 boolean button_released)
10728 if (tape.single_step && tape.recording && !tape.pausing)
10729 if (button_released)
10730 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
10732 CheckSaveEngineSnapshot_MM(element_clicked, button_released);
10735 void getGraphicSource_SP(struct GraphicInfo_SP *g_sp,
10736 int graphic, int sync_frame)
10738 int frame = getGraphicAnimationFrame(graphic, sync_frame);
10740 getGraphicSource(graphic, frame, &g_sp->bitmap, &g_sp->src_x, &g_sp->src_y);
10743 boolean isNextAnimationFrame_SP(int graphic, int sync_frame)
10745 return (IS_NEXT_FRAME(sync_frame, graphic));
10748 int getGraphicInfo_Delay(int graphic)
10750 return graphic_info[graphic].anim_delay;
10753 boolean getGraphicInfo_NewFrame(int x, int y, int graphic)
10755 if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
10758 if (ANIM_MODE(graphic) & (ANIM_TILED | ANIM_RANDOM_STATIC))
10764 void PlayMenuSoundExt(int sound)
10766 if (sound == SND_UNDEFINED)
10769 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
10770 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
10773 if (IS_LOOP_SOUND(sound))
10774 PlaySoundLoop(sound);
10779 void PlayMenuSound(void)
10781 PlayMenuSoundExt(menu.sound[game_status]);
10784 void PlayMenuSoundStereo(int sound, int stereo_position)
10786 if (sound == SND_UNDEFINED)
10789 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
10790 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
10793 if (IS_LOOP_SOUND(sound))
10794 PlaySoundExt(sound, SOUND_MAX_VOLUME, stereo_position, SND_CTRL_PLAY_LOOP);
10796 PlaySoundStereo(sound, stereo_position);
10799 void PlayMenuSoundIfLoopExt(int sound)
10801 if (sound == SND_UNDEFINED)
10804 if ((!setup.sound_simple && !IS_LOOP_SOUND(sound)) ||
10805 (!setup.sound_loops && IS_LOOP_SOUND(sound)))
10808 if (IS_LOOP_SOUND(sound))
10809 PlaySoundLoop(sound);
10812 void PlayMenuSoundIfLoop(void)
10814 PlayMenuSoundIfLoopExt(menu.sound[game_status]);
10817 void PlayMenuMusicExt(int music)
10819 if (music == MUS_UNDEFINED)
10822 if (!setup.sound_music)
10825 if (IS_LOOP_MUSIC(music))
10826 PlayMusicLoop(music);
10831 void PlayMenuMusic(void)
10833 char *curr_music = getCurrentlyPlayingMusicFilename();
10834 char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
10836 if (!strEqual(curr_music, next_music))
10837 PlayMenuMusicExt(menu.music[game_status]);
10840 void PlayMenuSoundsAndMusic(void)
10846 static void FadeMenuSounds(void)
10851 static void FadeMenuMusic(void)
10853 char *curr_music = getCurrentlyPlayingMusicFilename();
10854 char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
10856 if (!strEqual(curr_music, next_music))
10860 void FadeMenuSoundsAndMusic(void)
10866 void PlaySoundActivating(void)
10869 PlaySound(SND_MENU_ITEM_ACTIVATING);
10873 void PlaySoundSelecting(void)
10876 PlaySound(SND_MENU_ITEM_SELECTING);
10880 void ToggleFullscreenIfNeeded(void)
10882 // if setup and video fullscreen state are already matching, nothing do do
10883 if (setup.fullscreen == video.fullscreen_enabled ||
10884 !video.fullscreen_available)
10887 SDLSetWindowFullscreen(setup.fullscreen);
10889 // set setup value according to successfully changed fullscreen mode
10890 setup.fullscreen = video.fullscreen_enabled;
10893 void ChangeWindowScalingIfNeeded(void)
10895 // if setup and video window scaling are already matching, nothing do do
10896 if (setup.window_scaling_percent == video.window_scaling_percent ||
10897 video.fullscreen_enabled)
10900 SDLSetWindowScaling(setup.window_scaling_percent);
10902 // set setup value according to successfully changed window scaling
10903 setup.window_scaling_percent = video.window_scaling_percent;
10906 void ChangeVsyncModeIfNeeded(void)
10908 int setup_vsync_mode = VSYNC_MODE_STR_TO_INT(setup.vsync_mode);
10909 int video_vsync_mode = video.vsync_mode;
10911 // if setup and video vsync mode are already matching, nothing do do
10912 if (setup_vsync_mode == video_vsync_mode)
10915 // if renderer is using OpenGL, vsync mode can directly be changed
10916 SDLSetScreenVsyncMode(setup.vsync_mode);
10918 // if vsync mode unchanged, try re-creating renderer to set vsync mode
10919 if (video.vsync_mode == video_vsync_mode)
10921 Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
10923 // save backbuffer content which gets lost when re-creating screen
10924 BlitBitmap(backbuffer, tmp_backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
10926 // force re-creating screen and renderer to set new vsync mode
10927 video.fullscreen_enabled = !setup.fullscreen;
10929 // when creating new renderer, destroy textures linked to old renderer
10930 FreeAllImageTextures(); // needs old renderer to free the textures
10932 // re-create screen and renderer (including change of vsync mode)
10933 ChangeVideoModeIfNeeded(setup.fullscreen);
10935 // set setup value according to successfully changed fullscreen mode
10936 setup.fullscreen = video.fullscreen_enabled;
10938 // restore backbuffer content from temporary backbuffer backup bitmap
10939 BlitBitmap(tmp_backbuffer, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
10940 FreeBitmap(tmp_backbuffer);
10942 // update visible window/screen
10943 BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
10945 // when changing vsync mode, re-create textures for new renderer
10946 InitImageTextures();
10949 // set setup value according to successfully changed vsync mode
10950 setup.vsync_mode = VSYNC_MODE_INT_TO_STR(video.vsync_mode);
10953 static void JoinRectangles(int *x, int *y, int *width, int *height,
10954 int x2, int y2, int width2, int height2)
10956 // do not join with "off-screen" rectangle
10957 if (x2 == -1 || y2 == -1)
10962 *width = MAX(*width, width2);
10963 *height = MAX(*height, height2);
10966 void SetAnimStatus(int anim_status_new)
10968 if (anim_status_new == GAME_MODE_MAIN)
10969 anim_status_new = GAME_MODE_PSEUDO_MAINONLY;
10970 else if (anim_status_new == GAME_MODE_NAMES)
10971 anim_status_new = GAME_MODE_PSEUDO_NAMESONLY;
10972 else if (anim_status_new == GAME_MODE_SCORES)
10973 anim_status_new = GAME_MODE_PSEUDO_SCORESOLD;
10975 global.anim_status_next = anim_status_new;
10977 // directly set screen modes that are entered without fading
10978 if ((global.anim_status == GAME_MODE_PSEUDO_MAINONLY &&
10979 global.anim_status_next == GAME_MODE_PSEUDO_TYPENAME) ||
10980 (global.anim_status == GAME_MODE_PSEUDO_TYPENAME &&
10981 global.anim_status_next == GAME_MODE_PSEUDO_MAINONLY) ||
10982 (global.anim_status == GAME_MODE_PSEUDO_NAMESONLY &&
10983 global.anim_status_next == GAME_MODE_PSEUDO_TYPENAMES) ||
10984 (global.anim_status == GAME_MODE_PSEUDO_TYPENAMES &&
10985 global.anim_status_next == GAME_MODE_PSEUDO_NAMESONLY))
10986 global.anim_status = global.anim_status_next;
10989 void SetGameStatus(int game_status_new)
10991 if (game_status_new != game_status)
10992 game_status_last_screen = game_status;
10994 game_status = game_status_new;
10996 SetAnimStatus(game_status_new);
10999 void SetFontStatus(int game_status_new)
11001 static int last_game_status = -1;
11003 if (game_status_new != -1)
11005 // set game status for font use after storing last game status
11006 last_game_status = game_status;
11007 game_status = game_status_new;
11011 // reset game status after font use from last stored game status
11012 game_status = last_game_status;
11016 void ResetFontStatus(void)
11021 void SetLevelSetInfo(char *identifier, int level_nr)
11023 setString(&levelset.identifier, identifier);
11025 levelset.level_nr = level_nr;
11028 boolean CheckIfAllViewportsHaveChanged(void)
11030 // if game status has not changed, viewports have not changed either
11031 if (game_status == game_status_last)
11034 // check if all viewports have changed with current game status
11036 struct RectWithBorder *vp_playfield = &viewport.playfield[game_status];
11037 struct RectWithBorder *vp_door_1 = &viewport.door_1[game_status];
11038 struct RectWithBorder *vp_door_2 = &viewport.door_2[game_status];
11039 int new_real_sx = vp_playfield->x;
11040 int new_real_sy = vp_playfield->y;
11041 int new_full_sxsize = vp_playfield->width;
11042 int new_full_sysize = vp_playfield->height;
11043 int new_dx = vp_door_1->x;
11044 int new_dy = vp_door_1->y;
11045 int new_dxsize = vp_door_1->width;
11046 int new_dysize = vp_door_1->height;
11047 int new_vx = vp_door_2->x;
11048 int new_vy = vp_door_2->y;
11049 int new_vxsize = vp_door_2->width;
11050 int new_vysize = vp_door_2->height;
11052 boolean playfield_viewport_has_changed =
11053 (new_real_sx != REAL_SX ||
11054 new_real_sy != REAL_SY ||
11055 new_full_sxsize != FULL_SXSIZE ||
11056 new_full_sysize != FULL_SYSIZE);
11058 boolean door_1_viewport_has_changed =
11061 new_dxsize != DXSIZE ||
11062 new_dysize != DYSIZE);
11064 boolean door_2_viewport_has_changed =
11067 new_vxsize != VXSIZE ||
11068 new_vysize != VYSIZE ||
11069 game_status_last == GAME_MODE_EDITOR);
11071 return (playfield_viewport_has_changed &&
11072 door_1_viewport_has_changed &&
11073 door_2_viewport_has_changed);
11076 boolean CheckFadeAll(void)
11078 return (CheckIfGlobalBorderHasChanged() ||
11079 CheckIfAllViewportsHaveChanged());
11082 void ChangeViewportPropertiesIfNeeded(void)
11084 boolean use_mini_tilesize = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
11085 FALSE : setup.small_game_graphics);
11086 int gfx_game_mode = getGlobalGameStatus(game_status);
11087 int gfx_game_mode2 = (gfx_game_mode == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
11089 struct RectWithBorder *vp_window = &viewport.window[gfx_game_mode];
11090 struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
11091 struct RectWithBorder *vp_door_1 = &viewport.door_1[gfx_game_mode];
11092 struct RectWithBorder *vp_door_2 = &viewport.door_2[gfx_game_mode2];
11093 struct RectWithBorder *vp_door_3 = &viewport.door_2[GAME_MODE_EDITOR];
11094 int new_win_xsize = vp_window->width;
11095 int new_win_ysize = vp_window->height;
11096 int border_left = vp_playfield->border_left;
11097 int border_right = vp_playfield->border_right;
11098 int border_top = vp_playfield->border_top;
11099 int border_bottom = vp_playfield->border_bottom;
11100 int new_sx = vp_playfield->x + border_left;
11101 int new_sy = vp_playfield->y + border_top;
11102 int new_sxsize = vp_playfield->width - border_left - border_right;
11103 int new_sysize = vp_playfield->height - border_top - border_bottom;
11104 int new_real_sx = vp_playfield->x;
11105 int new_real_sy = vp_playfield->y;
11106 int new_full_sxsize = vp_playfield->width;
11107 int new_full_sysize = vp_playfield->height;
11108 int new_dx = vp_door_1->x;
11109 int new_dy = vp_door_1->y;
11110 int new_dxsize = vp_door_1->width;
11111 int new_dysize = vp_door_1->height;
11112 int new_vx = vp_door_2->x;
11113 int new_vy = vp_door_2->y;
11114 int new_vxsize = vp_door_2->width;
11115 int new_vysize = vp_door_2->height;
11116 int new_ex = vp_door_3->x;
11117 int new_ey = vp_door_3->y;
11118 int new_exsize = vp_door_3->width;
11119 int new_eysize = vp_door_3->height;
11120 int new_tilesize_var = (use_mini_tilesize ? MINI_TILESIZE : game.tile_size);
11121 int tilesize = (gfx_game_mode == GAME_MODE_PLAYING ? new_tilesize_var :
11122 gfx_game_mode == GAME_MODE_EDITOR ? MINI_TILESIZE : TILESIZE);
11123 int new_scr_fieldx = new_sxsize / tilesize;
11124 int new_scr_fieldy = new_sysize / tilesize;
11125 int new_scr_fieldx_buffers = new_sxsize / new_tilesize_var;
11126 int new_scr_fieldy_buffers = new_sysize / new_tilesize_var;
11127 boolean init_gfx_buffers = FALSE;
11128 boolean init_video_buffer = FALSE;
11129 boolean init_gadgets_and_anims = FALSE;
11130 boolean init_bd_graphics = FALSE;
11131 boolean init_em_graphics = FALSE;
11133 if (new_win_xsize != WIN_XSIZE ||
11134 new_win_ysize != WIN_YSIZE)
11136 WIN_XSIZE = new_win_xsize;
11137 WIN_YSIZE = new_win_ysize;
11139 init_video_buffer = TRUE;
11140 init_gfx_buffers = TRUE;
11141 init_gadgets_and_anims = TRUE;
11143 // Debug("tools:viewport", "video: init_video_buffer, init_gfx_buffers");
11146 if (new_scr_fieldx != SCR_FIELDX ||
11147 new_scr_fieldy != SCR_FIELDY)
11149 // this always toggles between MAIN and GAME when using small tile size
11151 SCR_FIELDX = new_scr_fieldx;
11152 SCR_FIELDY = new_scr_fieldy;
11154 // Debug("tools:viewport", "new_scr_fieldx != SCR_FIELDX ...");
11157 if (new_sx != SX ||
11165 new_sxsize != SXSIZE ||
11166 new_sysize != SYSIZE ||
11167 new_dxsize != DXSIZE ||
11168 new_dysize != DYSIZE ||
11169 new_vxsize != VXSIZE ||
11170 new_vysize != VYSIZE ||
11171 new_exsize != EXSIZE ||
11172 new_eysize != EYSIZE ||
11173 new_real_sx != REAL_SX ||
11174 new_real_sy != REAL_SY ||
11175 new_full_sxsize != FULL_SXSIZE ||
11176 new_full_sysize != FULL_SYSIZE ||
11177 new_tilesize_var != TILESIZE_VAR
11180 // ------------------------------------------------------------------------
11181 // determine next fading area for changed viewport definitions
11182 // ------------------------------------------------------------------------
11184 // start with current playfield area (default fading area)
11187 FADE_SXSIZE = FULL_SXSIZE;
11188 FADE_SYSIZE = FULL_SYSIZE;
11190 // add new playfield area if position or size has changed
11191 if (new_real_sx != REAL_SX || new_real_sy != REAL_SY ||
11192 new_full_sxsize != FULL_SXSIZE || new_full_sysize != FULL_SYSIZE)
11194 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
11195 new_real_sx, new_real_sy, new_full_sxsize,new_full_sysize);
11198 // add current and new door 1 area if position or size has changed
11199 if (new_dx != DX || new_dy != DY ||
11200 new_dxsize != DXSIZE || new_dysize != DYSIZE)
11202 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
11203 DX, DY, DXSIZE, DYSIZE);
11204 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
11205 new_dx, new_dy, new_dxsize, new_dysize);
11208 // add current and new door 2 area if position or size has changed
11209 if (new_vx != VX || new_vy != VY ||
11210 new_vxsize != VXSIZE || new_vysize != VYSIZE)
11212 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
11213 VX, VY, VXSIZE, VYSIZE);
11214 JoinRectangles(&FADE_SX, &FADE_SY, &FADE_SXSIZE, &FADE_SYSIZE,
11215 new_vx, new_vy, new_vxsize, new_vysize);
11218 // ------------------------------------------------------------------------
11219 // handle changed tile size
11220 // ------------------------------------------------------------------------
11222 if (new_tilesize_var != TILESIZE_VAR)
11224 // Debug("tools:viewport", "new_tilesize_var != TILESIZE_VAR");
11226 // changing tile size invalidates scroll values of engine snapshots
11227 FreeEngineSnapshotSingle();
11229 // changing tile size requires update of graphic mapping for BD/EM engine
11230 init_bd_graphics = TRUE;
11231 init_em_graphics = TRUE;
11242 SXSIZE = new_sxsize;
11243 SYSIZE = new_sysize;
11244 DXSIZE = new_dxsize;
11245 DYSIZE = new_dysize;
11246 VXSIZE = new_vxsize;
11247 VYSIZE = new_vysize;
11248 EXSIZE = new_exsize;
11249 EYSIZE = new_eysize;
11250 REAL_SX = new_real_sx;
11251 REAL_SY = new_real_sy;
11252 FULL_SXSIZE = new_full_sxsize;
11253 FULL_SYSIZE = new_full_sysize;
11254 TILESIZE_VAR = new_tilesize_var;
11256 init_gfx_buffers = TRUE;
11257 init_gadgets_and_anims = TRUE;
11259 // Debug("tools:viewport", "viewports: init_gfx_buffers");
11260 // Debug("tools:viewport", "viewports: init_gadgets_and_anims");
11263 if (init_gfx_buffers)
11265 // Debug("tools:viewport", "init_gfx_buffers");
11267 SCR_FIELDX = new_scr_fieldx_buffers;
11268 SCR_FIELDY = new_scr_fieldy_buffers;
11272 SCR_FIELDX = new_scr_fieldx;
11273 SCR_FIELDY = new_scr_fieldy;
11275 SetDrawDeactivationMask(REDRAW_NONE);
11276 SetDrawBackgroundMask(REDRAW_FIELD);
11279 if (init_video_buffer)
11281 // Debug("tools:viewport", "init_video_buffer");
11283 FreeAllImageTextures(); // needs old renderer to free the textures
11285 InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen);
11286 InitImageTextures();
11289 if (init_gadgets_and_anims)
11291 // Debug("tools:viewport", "init_gadgets_and_anims");
11294 InitGlobalAnimations();
11297 if (init_bd_graphics)
11299 InitGraphicInfo_BD();
11302 if (init_em_graphics)
11304 InitGraphicInfo_EM();
11308 void OpenURL(char *url)
11310 #if SDL_VERSION_ATLEAST(2,0,14)
11313 Warn("SDL_OpenURL(\"%s\") not supported by SDL %d.%d.%d!",
11314 url, SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
11315 Warn("Please upgrade to at least SDL 2.0.14 for URL support!");
11319 void OpenURLFromHash(SetupFileHash *hash, int hash_key)
11321 OpenURL(getHashEntry(hash, int2str(hash_key, 0)));
11324 char *getCurrentLevelsetName(void)
11326 return leveldir_current->name;
11330 // ============================================================================
11332 // ============================================================================
11334 #if defined(PLATFORM_WINDOWS)
11335 /* FILETIME of Jan 1 1970 00:00:00. */
11336 static const unsigned __int64 epoch = ((unsigned __int64) 116444736000000000ULL);
11339 * timezone information is stored outside the kernel so tzp isn't used anymore.
11341 * Note: this function is not for Win32 high precision timing purpose. See
11344 static int gettimeofday_windows(struct timeval * tp, struct timezone * tzp)
11346 FILETIME file_time;
11347 SYSTEMTIME system_time;
11348 ULARGE_INTEGER ularge;
11350 GetSystemTime(&system_time);
11351 SystemTimeToFileTime(&system_time, &file_time);
11352 ularge.LowPart = file_time.dwLowDateTime;
11353 ularge.HighPart = file_time.dwHighDateTime;
11355 tp->tv_sec = (long) ((ularge.QuadPart - epoch) / 10000000L);
11356 tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
11362 static char *test_init_uuid_random_function_simple(void)
11364 static char seed_text[100];
11365 unsigned int seed = InitSimpleRandom(NEW_RANDOMIZE);
11367 sprintf(seed_text, "%d", seed);
11372 static char *test_init_uuid_random_function_better(void)
11374 static char seed_text[100];
11375 struct timeval current_time;
11377 gettimeofday(¤t_time, NULL);
11379 prng_seed_bytes(¤t_time, sizeof(current_time));
11381 sprintf(seed_text, "%ld.%ld",
11382 (long)current_time.tv_sec,
11383 (long)current_time.tv_usec);
11388 #if defined(PLATFORM_WINDOWS)
11389 static char *test_init_uuid_random_function_better_windows(void)
11391 static char seed_text[100];
11392 struct timeval current_time;
11394 gettimeofday_windows(¤t_time, NULL);
11396 prng_seed_bytes(¤t_time, sizeof(current_time));
11398 sprintf(seed_text, "%ld.%ld",
11399 (long)current_time.tv_sec,
11400 (long)current_time.tv_usec);
11406 static unsigned int test_uuid_random_function_simple(int max)
11408 return GetSimpleRandom(max);
11411 static unsigned int test_uuid_random_function_better(int max)
11413 return (max > 0 ? prng_get_uint() % max : 0);
11416 #if defined(PLATFORM_WINDOWS)
11417 #define NUM_UUID_TESTS 3
11419 #define NUM_UUID_TESTS 2
11422 static void TestGeneratingUUIDs_RunTest(int nr, int always_seed, int num_uuids)
11424 HashTable *hash_seeds =
11425 create_hashtable(get_hash_from_string, hash_key_strings_are_equal, free, NULL);
11426 HashTable *hash_uuids =
11427 create_hashtable(get_hash_from_string, hash_key_strings_are_equal, free, NULL);
11428 static char message[100];
11431 char *random_name = (nr == 0 ? "simple" : "better");
11432 char *random_type = (always_seed ? "always" : "only once");
11433 char *(*init_random_function)(void) =
11435 test_init_uuid_random_function_simple :
11436 test_init_uuid_random_function_better);
11437 unsigned int (*random_function)(int) =
11439 test_uuid_random_function_simple :
11440 test_uuid_random_function_better);
11443 #if defined(PLATFORM_WINDOWS)
11446 random_name = "windows";
11447 init_random_function = test_init_uuid_random_function_better_windows;
11453 DrawTextF(xpos, 40, FC_GREEN, "Test: Generating UUIDs");
11454 DrawTextF(xpos, 80, FC_YELLOW, "Test %d.%d:", nr + 1, always_seed + 1);
11456 DrawTextF(xpos, 100, FC_YELLOW, "Random Generator Name: %s", random_name);
11457 DrawTextF(xpos, 120, FC_YELLOW, "Seeding Random Generator: %s", random_type);
11458 DrawTextF(xpos, 140, FC_YELLOW, "Number of UUIDs generated: %d", num_uuids);
11460 DrawTextF(xpos, 180, FC_GREEN, "Please wait ...");
11464 // always initialize random number generator at least once
11465 init_random_function();
11467 unsigned int time_start = SDL_GetTicks();
11469 for (i = 0; i < num_uuids; i++)
11473 char *seed = getStringCopy(init_random_function());
11475 hashtable_remove(hash_seeds, seed);
11476 hashtable_insert(hash_seeds, seed, "1");
11479 char *uuid = getStringCopy(getUUIDExt(random_function));
11481 hashtable_remove(hash_uuids, uuid);
11482 hashtable_insert(hash_uuids, uuid, "1");
11485 int num_unique_seeds = hashtable_count(hash_seeds);
11486 int num_unique_uuids = hashtable_count(hash_uuids);
11488 unsigned int time_needed = SDL_GetTicks() - time_start;
11490 DrawTextF(xpos, 220, FC_YELLOW, "Time needed: %d ms", time_needed);
11492 DrawTextF(xpos, 240, FC_YELLOW, "Number of unique UUIDs: %d", num_unique_uuids);
11495 DrawTextF(xpos, 260, FC_YELLOW, "Number of unique seeds: %d", num_unique_seeds);
11497 if (nr == NUM_UUID_TESTS - 1 && always_seed)
11498 DrawTextF(xpos, 300, FC_GREEN, "All tests done!");
11500 DrawTextF(xpos, 300, FC_GREEN, "Confirm dialog for next test ...");
11502 sprintf(message, "Test %d.%d finished!", nr + 1, always_seed + 1);
11504 Request(message, REQ_CONFIRM);
11506 hashtable_destroy(hash_seeds);
11507 hashtable_destroy(hash_uuids);
11510 void TestGeneratingUUIDs(void)
11512 int num_uuids = 1000000;
11515 for (i = 0; i < NUM_UUID_TESTS; i++)
11516 for (j = 0; j < 2; j++)
11517 TestGeneratingUUIDs_RunTest(i, j, num_uuids);
11519 CloseAllAndExit(0);