X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame_bd%2Fbd_graphics.c;h=fa139d0cec13b52f0f886f4165a9fe43df98b268;hb=refs%2Fheads%2Fmaster-next-major-release;hp=edc8003788e68ef268ee792eb1903716c47eeca2;hpb=6fe46ea9fbf85c0ea5d27a452184b9a0183193c7;p=rocksndiamonds.git diff --git a/src/game_bd/bd_graphics.c b/src/game_bd/bd_graphics.c index edc80037..fa139d0c 100644 --- a/src/game_bd/bd_graphics.c +++ b/src/game_bd/bd_graphics.c @@ -58,8 +58,6 @@ static int scroll_x, scroll_y; // quit, global variable which is set to true if the application should quit boolean gd_quit = FALSE; -const byte *gd_keystate; - static int cell_size = 0; // graphic info for game objects/frames and players/actions/frames @@ -110,11 +108,9 @@ void set_play_area(int w, int h) play_area_h = h; } -void gd_init_keystate(void) +void gd_init_play_area(void) { set_play_area(SXSIZE, SYSIZE); - - gd_keystate = SDL_GetKeyboardState(NULL); } /* @@ -367,6 +363,11 @@ static boolean surface_has_c64_colors(SDL_Surface *surface) return has_c64_colors; } +boolean gd_bitmap_has_c64_colors(Bitmap *bitmap) +{ + return surface_has_c64_colors(bitmap->surface); +} + // sets one of the colors in the indexed palette of an sdl surface to a GdColor. static void set_surface_palette_color(SDL_Surface *surface, int index, GdColor col) { @@ -470,8 +471,14 @@ static Bitmap *get_tile_bitmap_c64(GdCave *cave, SDL_Surface *surface) set_surface_palette_color(surface, 7, 0); set_surface_palette_color(surface, 8, 0); + // set background color to be transparent for masked tile bitmap + int bg_color = gd_color_get_rgb(cave->color0); + int bg_r = gd_color_get_r(bg_color); + int bg_g = gd_color_get_g(bg_color); + int bg_b = gd_color_get_b(bg_color); + // create bitmap from C64 surface - tile_bitmap_c64 = SDLGetBitmapFromSurface(surface); + tile_bitmap_c64 = SDLGetBitmapFromSurface_WithMaskedColor(surface, bg_r, bg_g, bg_b); return tile_bitmap_c64; } @@ -536,12 +543,19 @@ static inline boolean el_player(const int element) return (gd_elements[element & O_MASK].properties & P_PLAYER) != 0; } +// returns true if the element is walkable +static inline boolean el_walkable(const int element) +{ + return (gd_elements[element & O_MASK].properties & P_WALKABLE) != 0; +} + // returns true if the element is diggable static inline boolean el_diggable(const int element) { return (gd_elements[element & O_MASK].properties & P_DIGGABLE) != 0; } +#if 0 // returns true if the element is collectible static inline boolean el_collectible(const int element) { @@ -555,15 +569,22 @@ static inline boolean el_pushable(const int element) } // returns true if the element can move -static inline boolean can_move(const int element) +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 can_fall(const int element) +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_CAN_FALL) != 0; + return (gd_elements[element & O_MASK].properties & P_GROWING) != 0; } // returns true if the element is exploding @@ -579,27 +600,57 @@ static void gd_drawcave_tile(Bitmap *dest, GdGame *game, int x, int y, boolean d GdCave *cave = game->cave; int sx = x * cell_size - scroll_x; int sy = y * cell_size - scroll_y; - int dir = game->dir_buffer[y][x]; + 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; - struct GraphicInfo_BD *g = &graphic_info_bd_object[tile][frame]; - Bitmap *tile_bitmap = gd_get_tile_bitmap(g->bitmap); - boolean is_movable = (can_move(tile) || can_fall(tile) || el_pushable(tile) || el_player(tile)); - boolean is_movable_or_diggable = (is_movable || el_diggable(game->last_element_buffer[y][x])); - boolean is_moving = (is_movable_or_diggable && dir != GD_MV_STILL); + 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(); - // do not use smooth movement animation for exploding game elements (like player) - if (el_explosion(tile) && dir != GD_MV_STILL) - use_smooth_movements = FALSE; + // 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; @@ -619,74 +670,77 @@ static void gd_drawcave_tile(Bitmap *dest, GdGame *game, int x, int y, boolean d // 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 + // -------------------------------------------------------------------------------- - if (!(game->last_element_buffer[y][x] & SKIPPED)) + // ---------- 1st step: draw background element for this tile ---------- { - // redraw previous game element on the cave field the new element is moving to - int tile_last = game->last_element_buffer[y][x]; - - // only redraw previous game element if it is diggable (like dirt etc.) - if (!el_diggable(tile_last)) - tile_last = O_SPACE; - - struct GraphicInfo_BD *g_old = &graphic_info_bd_object[tile_last][frame]; - Bitmap *tile_bitmap_old = gd_get_tile_bitmap(g_old->bitmap); - - blit_bitmap(tile_bitmap_old, dest, g_old->src_x, g_old->src_y, cell_size, cell_size, sx, sy); - } - - // get cave field position the game element is moving from - int dx = (dir == GD_MV_LEFT ? +1 : dir == GD_MV_RIGHT ? -1 : 0); - int dy = (dir == GD_MV_UP ? +1 : dir == GD_MV_DOWN ? -1 : 0); - int old_x = cave->getx(cave, x + dx, y + dy); - int old_y = cave->gety(cave, x + dx, y + dy); - int tile_from = game->element_buffer[old_y][old_x] & ~SKIPPED; // should never be skipped - struct GraphicInfo_BD *g_from = &graphic_info_bd_object[tile_from][frame]; - Bitmap *tile_bitmap_from = gd_get_tile_bitmap(g_from->bitmap); - boolean old_is_player = el_player(tile_from); - boolean old_is_moving = (game->dir_buffer[old_y][old_x] != GD_MV_STILL); - boolean old_is_visible = (old_x >= cave->x1 && - old_x <= cave->x2 && - old_y >= cave->y1 && - old_y <= cave->y2); - if (old_is_visible) - { - if (!old_is_moving && !old_is_player) - { - // redraw game element on the cave field the element is moving from - blit_bitmap(tile_bitmap_from, dest, g_from->src_x, g_from->src_y, cell_size, cell_size, - sx + dx * cell_size, sy + dy * cell_size); + 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); - game->element_buffer[old_y][old_x] |= SKIPPED; - } - else - { - // if old tile also moving (like pushing player), do not redraw tile background - // (but redraw if tile and old tile are moving/falling into different directions) - if (game->dir_buffer[old_y][old_x] == game->dir_buffer[y][x]) - game->last_element_buffer[old_y][old_x] |= SKIPPED; - } + 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; - blit_bitmap(tile_bitmap, dest, g->src_x, g->src_y, cell_size, cell_size, - sx + dx * shift, sy + dy * shift); + // ---------- 2nd step: draw element that is moving away from this tile ---------- - // special case: redraw player snapping a game element - if (old_is_visible && old_is_player && !old_is_moving) + if (is_moving_from) { - // redraw game element on the cave field the element is moving from - blit_bitmap(tile_bitmap_from, dest, g_from->src_x, g_from->src_y, cell_size, cell_size, - sx + dx * cell_size, sy + dy * cell_size); + 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; } } @@ -731,12 +785,9 @@ int gd_drawcave(Bitmap *dest, GdGame *game, boolean force_redraw) { if (redraw_all || game->gfx_buffer[y][x] & GD_REDRAW || - game->dir_buffer[y][x] != GD_MV_STILL) + game->dir_buffer_from[y][x] != GD_MV_STILL || + game->dir_buffer_to[y][x] != GD_MV_STILL) { - // skip redrawing already drawn element with movement - if (game->element_buffer[y][x] & SKIPPED) - continue; - // now we have drawn it game->gfx_buffer[y][x] = game->gfx_buffer[y][x] & ~GD_REDRAW;