+// returns true if the element is pushable
+static inline boolean el_pushable(const int element)
+{
+ return (gd_elements[element & O_MASK].properties & P_PUSHABLE) != 0;
+}
+
+// returns true if the element can move
+static inline boolean el_can_move(const int element)
+{
+ return (gd_elements[element & O_MASK].properties & P_CAN_MOVE) != 0;
+}
+
+// returns true if the element can fall
+static inline boolean el_falling(const int element)
+{
+ return (gd_elements[element & O_MASK].properties & P_FALLING) != 0;
+}
+#endif
+
+// returns true if the element is growing
+static inline boolean el_growing(const int element)
+{
+ return (gd_elements[element & O_MASK].properties & P_GROWING) != 0;
+}
+
+// returns true if the element is exploding
+static inline boolean el_explosion(const int element)
+{
+ return (gd_elements[element & O_MASK].properties & P_EXPLOSION) != 0;
+}
+
+static void gd_drawcave_tile(Bitmap *dest, GdGame *game, int x, int y, boolean draw_masked)
+{
+ void (*blit_bitmap)(Bitmap *, Bitmap *, int, int, int, int, int, int) =
+ (draw_masked ? BlitBitmapMasked : BlitBitmap);
+ GdCave *cave = game->cave;
+ int sx = x * cell_size - scroll_x;
+ int sy = y * cell_size - scroll_y;
+ int dir_from = game->dir_buffer_from[y][x];
+ int dir_to = game->dir_buffer_to[y][x];
+ int tile = game->element_buffer[y][x];
+ int tile_last = game->last_element_buffer[y][x];
+ int tile_from = O_NONE; // source element if element is moving (will be set later)
+ int tile_to = tile; // target element if element is moving
+ int frame = game->animcycle;
+ boolean is_moving_from = (dir_from != GD_MV_STILL);
+ boolean is_moving_to = (dir_to != GD_MV_STILL);
+ boolean is_moving = (is_moving_from || is_moving_to);
+ boolean use_smooth_movements = use_bd_smooth_movements();
+
+ // if element is moving away from this tile, determine element that is moving
+ if (is_moving_from)
+ {
+ int dx = (dir_from == GD_MV_LEFT ? -1 : dir_from == GD_MV_RIGHT ? +1 : 0);
+ int dy = (dir_from == GD_MV_UP ? -1 : dir_from == GD_MV_DOWN ? +1 : 0);
+ int new_x = cave->getx(cave, x + dx, y + dy);
+ int new_y = cave->gety(cave, x + dx, y + dy);
+
+ tile_from = game->element_buffer[new_y][new_x];
+
+ // handle special case of player running into enemy/explosion from top or left side
+ if ((el_growing(tile_from) || el_explosion(tile_from)) && el_player(tile_last))
+ tile_from = tile_last;
+ }
+
+ // --------------------------------------------------------------------------------
+ // check if we should use smooth movement animations or not
+ // --------------------------------------------------------------------------------
+
+ // do not use smooth movement animation for player entering exit (engine stopped)
+ if (cave->player_state == GD_PL_EXITED)
+ use_smooth_movements = FALSE;
+
+ // never treat empty space as "moving" (source tile if player is snapping)
+ if (tile_from == O_SPACE)
+ use_smooth_movements = FALSE;
+
+ // do not use smooth movement animation for player stirring the pot
+ if (tile_from == O_PLAYER_STIRRING || tile_to == O_PLAYER_STIRRING)
+ use_smooth_movements = FALSE;
+
+ // do not use smooth movement animation for growing or exploding game elements
+ if (el_growing(tile) || el_explosion(tile))
+ use_smooth_movements = FALSE;
+
+#if DO_GFX_SANITY_CHECK
+ if (use_native_bd_graphics_engine() && !setup.small_game_graphics && !program.headless)
+ {
+ struct GraphicInfo_BD *g = &graphic_info_bd_object[tile][frame];
+ int old_x = (game->gfx_buffer[y][x] % GD_NUM_OF_CELLS) % GD_NUM_OF_CELLS_X;
+ int old_y = (game->gfx_buffer[y][x] % GD_NUM_OF_CELLS) / GD_NUM_OF_CELLS_X;
+ int new_x = g->src_x / g->width;
+ int new_y = g->src_y / g->height;
+
+ if (new_x != old_x || new_y != old_y)
+ {
+ printf("::: BAD ANIMATION FOR TILE %d, FRAME %d [NEW(%d, %d) != OLD(%d, %d)] ['%s']\n",
+ tile, frame,
+ new_x, new_y,
+ old_x, old_y,
+ gd_elements[tile].name);
+ }
+ }
+#endif
+
+ // if game element not moving (or no smooth movements requested), simply draw tile
+ if (!is_moving || !use_smooth_movements)
+ {
+ struct GraphicInfo_BD *g = &graphic_info_bd_object[tile][frame];
+ Bitmap *tile_bitmap = gd_get_tile_bitmap(g->bitmap);
+
+ blit_bitmap(tile_bitmap, dest, g->src_x, g->src_y, cell_size, cell_size, sx, sy);
+
+ return;
+ }
+
+ // --------------------------------------------------------------------------------
+ // draw smooth animation for game element moving between two cave tiles
+ // --------------------------------------------------------------------------------
+
+ // ---------- 1st step: draw background element for this tile ----------
+ {
+ int tile_back = (!is_moving_to ? tile : el_diggable(tile_last) ? tile_last : O_SPACE);
+ struct GraphicInfo_BD *g = &graphic_info_bd_object[tile_back][frame];
+ Bitmap *tile_bitmap = gd_get_tile_bitmap(g->bitmap);
+
+ blit_bitmap(tile_bitmap, dest, g->src_x, g->src_y, cell_size, cell_size, sx, sy);
+ }
+
+ // get shifted position between cave fields the game element is moving from/to
+ int itercycle = MIN(MAX(0, game->itermax - game->itercycle - 1), game->itermax);
+ int shift = cell_size * itercycle / game->itermax;
+
+ // ---------- 2nd step: draw element that is moving away from this tile ----------
+
+ if (is_moving_from)
+ {
+ struct GraphicInfo_BD *g = &graphic_info_bd_object[tile_from][frame];
+ Bitmap *tile_bitmap = gd_get_tile_bitmap(g->bitmap);
+ int dx = (dir_from == GD_MV_LEFT ? -1 : dir_from == GD_MV_RIGHT ? +1 : 0);
+ int dy = (dir_from == GD_MV_UP ? -1 : dir_from == GD_MV_DOWN ? +1 : 0);
+ int xsize = (dx != 0 ? shift : cell_size);
+ int ysize = (dy != 0 ? shift : cell_size);
+ int gx = g->src_x + (dx < 0 ? cell_size - shift : 0);
+ int gy = g->src_y + (dy < 0 ? cell_size - shift : 0);
+ int tx = sx + (dx < 0 ? 0 : dx > 0 ? cell_size - shift : 0);
+ int ty = sy + (dy < 0 ? 0 : dy > 0 ? cell_size - shift : 0);
+
+ if (el_walkable(tile))
+ blit_bitmap = BlitBitmapMasked;
+
+ blit_bitmap(tile_bitmap, dest, gx, gy, xsize, ysize, tx, ty);
+
+ // when using dynamic scheduling (mainly BD1 levels), redraw tile in next frame
+ game->gfx_buffer[y][x] |= GD_REDRAW;
+ }
+
+ // ---------- 3rd step: draw element that is moving towards this tile ----------
+
+ if (is_moving_to)
+ {
+ struct GraphicInfo_BD *g = &graphic_info_bd_object[tile_to][frame];
+ Bitmap *tile_bitmap = gd_get_tile_bitmap(g->bitmap);
+ int dx = (dir_to == GD_MV_LEFT ? +1 : dir_to == GD_MV_RIGHT ? -1 : 0);
+ int dy = (dir_to == GD_MV_UP ? +1 : dir_to == GD_MV_DOWN ? -1 : 0);
+ int xsize = (dx != 0 ? cell_size - shift : cell_size);
+ int ysize = (dy != 0 ? cell_size - shift : cell_size);
+ int gx = g->src_x + (dx < 0 ? shift : 0);
+ int gy = g->src_y + (dy < 0 ? shift : 0);
+ int tx = sx + (dx < 0 ? 0 : dx > 0 ? shift : 0);
+ int ty = sy + (dy < 0 ? 0 : dy > 0 ? shift : 0);
+
+ if (is_moving_from)
+ blit_bitmap = BlitBitmapMasked;
+
+ blit_bitmap(tile_bitmap, dest, gx, gy, xsize, ysize, tx, ty);
+
+ // when using dynamic scheduling (mainly BD1 levels), redraw tile in next frame
+ game->gfx_buffer[y][x] |= GD_REDRAW;
+ }
+}
+