}
}
+#if 1
+
+static void RedrawPlayfield_RND()
+{
+ if (game.envelope_active)
+ return;
+
+#if 1
+ DrawLevel(REDRAW_ALL);
+#else
+ int x, y;
+
+ SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
+ // SetDrawBackgroundMask(REDRAW_FIELD); // !!! CHECK THIS !!!
+ SetDrawBackgroundMask(REDRAW_ALL); // !!! CHECK THIS !!!
+
+ for (x = BX1; x <= BX2; x++)
+ for (y = BY1; y <= BY2; y++)
+ DrawScreenField(x, y);
+
+ redraw_mask |= REDRAW_FIELD;
+#endif
+ DrawAllPlayers();
+
+#if 0
+#if NEW_TILESIZE
+ BlitScreenToBitmap(backbuffer);
+#else
+ /* blit playfield from scroll buffer to normal back buffer */
+ if (setup.soft_scrolling)
+ {
+ int fx = FX, fy = FY;
+
+ fx += (ScreenMovDir & (MV_LEFT|MV_RIGHT) ? ScreenGfxPos : 0);
+ fy += (ScreenMovDir & (MV_UP|MV_DOWN) ? ScreenGfxPos : 0);
+
+ BlitBitmap(fieldbuffer, backbuffer, fx,fy, SXSIZE,SYSIZE, SX,SY);
+ }
+#endif
+#endif
+}
+
+void RedrawPlayfield()
+{
+ if (game_status != GAME_MODE_PLAYING)
+ return;
+
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ RedrawPlayfield_EM(TRUE);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ RedrawPlayfield_SP(TRUE);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
+ RedrawPlayfield_RND();
+
+ BlitScreenToBitmap(backbuffer);
+
+ BlitBitmap(drawto, window, gfx.sx, gfx.sy, gfx.sxsize, gfx.sysize,
+ gfx.sx, gfx.sy);
+}
+
+#else
+
void RedrawPlayfield(boolean force_redraw, int x, int y, int width, int height)
{
if (game_status == GAME_MODE_PLAYING &&
BlitBitmap(drawto, window, x, y, width, height, x, y);
}
+#endif
+
void DrawMaskedBorder_Rect(int x, int y, int width, int height)
{
Bitmap *bitmap = graphic_info[IMG_GLOBAL_BORDER].bitmap;
}
}
-void BlitScreenToBitmap(Bitmap *target_bitmap)
+static void BlitScreenToBitmap_RND(Bitmap *target_bitmap)
{
DrawBuffer *buffer = (drawto_field == window ? backbuffer : drawto_field);
int fx = FX, fy = FY;
+ int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
+ int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
#if NEW_TILESIZE
int dx = (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0);
fx, fy);
#endif
+#if 1
+ if (full_lev_fieldx <= SCR_FIELDX)
+ {
+ // printf(":1: PLAYFIELD FITS TO SCREEN [%d, %d, %d]\n", fx, ffx, dx_var);
+
+ if (EVEN(SCR_FIELDX))
+ fx = 2 * TILEX_VAR - (ODD(lev_fieldx) ? TILEX_VAR / 2 : 0);
+ else
+ fx = 2 * TILEX_VAR - (EVEN(lev_fieldx) ? TILEX_VAR / 2 : 0);
+
+ // printf(":2: PLAYFIELD FITS TO SCREEN [%d, %d, %d]\n", fx, ffx, dx_var);
+ }
+
+ if (full_lev_fieldy <= SCR_FIELDY)
+ {
+ if (EVEN(SCR_FIELDY))
+ fy = 2 * TILEY_VAR - (ODD(lev_fieldy) ? TILEY_VAR / 2 : 0);
+ else
+ fy = 2 * TILEY_VAR - (EVEN(lev_fieldy) ? TILEY_VAR / 2 : 0);
+ }
+#endif
+
if (border.draw_masked[GAME_MODE_PLAYING])
{
if (buffer != backbuffer)
}
}
+void BlitScreenToBitmap(Bitmap *target_bitmap)
+{
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ BlitScreenToBitmap_EM(target_bitmap);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ BlitScreenToBitmap_SP(target_bitmap);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
+ BlitScreenToBitmap_RND(target_bitmap);
+}
+
void BackToFront()
{
int x, y;
if (redraw_mask & REDRAW_ALL)
{
+#if 0
+ if (game_status != GAME_MODE_PLAYING ||
+ redraw_mask & REDRAW_FROM_BACKBUFFER)
+ {
+#if 0
+ printf("::: REDRAW_ALL [%d]\n", FrameCounter);
+#endif
+
+ BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+
+ redraw_mask = REDRAW_NONE;
+ }
+ else
+ {
+ redraw_mask &= ~REDRAW_ALL;
+ }
+#else
+#if 0
+ printf("::: REDRAW_ALL [%d]\n", FrameCounter);
+#endif
+
BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
redraw_mask = REDRAW_NONE;
+#endif
}
if (redraw_mask & REDRAW_FIELD)
{
#if 0
- printf("::: REDRAW_FIELD\n");
+ printf("::: REDRAW_FIELD [%d]\n", FrameCounter);
#endif
if (game_status != GAME_MODE_PLAYING ||
else
{
#if 1
- BlitScreenToBitmap(window);
+ BlitScreenToBitmap_RND(window);
#else
int fx = FX, fy = FY;
ClearRectangle(backbuffer, x, y, width, height);
#endif
+#if 1
+
+#if 1
+ BlitBitmap(backbuffer, window, x, y, width, height, x, y);
+
+ redraw_mask &= ~fade_mask;
+#else
+ /* always redraw area that was explicitly marked to fade */
+ redraw_mask |= fade_mask;
+
+ BackToFront();
+#endif
+
+#else
+
#if 1
BlitBitmap(backbuffer, window, x, y, width, height, x, y);
redraw_mask = REDRAW_NONE;
+ // (^^^ WRONG; should be "redraw_mask &= ~fade_mask" if done this way)
#else
BackToFront();
+#endif
#endif
return;
Bitmap *src_bitmap = g->bitmap;
int tilesize = MIN(MAX(1, tilesize_raw), TILESIZE);
int offset_calc_pos = log_2(tilesize);
+ int bitmap_width = src_bitmap->width;
+ int bitmap_height = src_bitmap->height;
int width_mult = offset_calc[offset_calc_pos].width_mult;
int width_div = offset_calc[offset_calc_pos].width_div;
int height_mult = offset_calc[offset_calc_pos].height_mult;
int height_div = offset_calc[offset_calc_pos].height_div;
- int startx = src_bitmap->width * width_mult / width_div;
- int starty = src_bitmap->height * height_mult / height_div;
+ int startx = bitmap_width * width_mult / width_div;
+ int starty = bitmap_height * height_mult / height_div;
+
+#if NEW_GAME_TILESIZE
+
+ int src_x = (g->src_x + (get_backside ? g->offset2_x : 0)) *
+ tilesize_raw / TILESIZE;
+ int src_y = (g->src_y + (get_backside ? g->offset2_y : 0)) *
+ tilesize_raw / TILESIZE;
+ int width = g->width * tilesize_raw / TILESIZE;
+ int height = g->height * tilesize_raw / TILESIZE;
+ int offset_x = g->offset_x * tilesize_raw / TILESIZE;
+ int offset_y = g->offset_y * tilesize_raw / TILESIZE;
+
+#else
+
#if NEW_TILESIZE
int src_x = (g->src_x + (get_backside ? g->offset2_x : 0)) *
tilesize / TILESIZE;
int offset_x = g->offset_x * tilesize / TILESIZE;
int offset_y = g->offset_y * tilesize / TILESIZE;
+#endif
+
+#if NEW_GAME_TILESIZE
+ if (game.tile_size != TILESIZE)
+ {
+ int bitmap_width_std =
+ bitmap_width * TILESIZE / (TILESIZE + game.tile_size);
+ int bitmap_height_std =
+ bitmap_height * TILESIZE / game.tile_size * 3 / 2;
+
+ if (tilesize_raw == game.tile_size)
+ {
+ startx = bitmap_width_std;
+ starty = 0;
+ }
+ else
+ {
+ bitmap_width = bitmap_width_std;
+
+ if (game.tile_size > TILESIZE * 3 / 2)
+ bitmap_height = bitmap_height_std;
+
+ startx = bitmap_width * width_mult / width_div;
+ starty = bitmap_height * height_mult / height_div;
+ }
+ }
+#endif
+
if (g->offset_y == 0) /* frames are ordered horizontally */
{
int max_width = g->anim_frames_per_line * width;
#if NEW_TILESIZE
width = crumbled_border_size * TILESIZE_VAR / TILESIZE;
height = crumbled_border_size * TILESIZE_VAR / TILESIZE;
- cx = (dx > 0 ? TILEX - crumbled_border_size : 0) * TILESIZE_VAR / TILESIZE;
- cy = (dy > 0 ? TILEY - crumbled_border_size : 0) * TILESIZE_VAR / TILESIZE;
+ cx = (dx > 0 ? TILESIZE_VAR - width : 0);
+ cy = (dy > 0 ? TILESIZE_VAR - height : 0);
BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
width, height, FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
int width, height, bx, by, cx, cy;
int sx = SCREENX(x), sy = SCREENY(y);
int crumbled_border_size = graphic_info[graphic].border_size;
+ int crumbled_border_size_var = crumbled_border_size * TILESIZE_VAR / TILESIZE;
+ int crumbled_border_pos_var = TILESIZE_VAR - crumbled_border_size_var;
int i;
getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
/* draw simple, sloppy, non-corner-accurate crumbled border */
#if 1
- width = (dir == 1 || dir == 2 ? crumbled_border_size : TILEX);
- height = (dir == 0 || dir == 3 ? crumbled_border_size : TILEY);
- cx = (dir == 2 ? TILEX - crumbled_border_size : 0);
- cy = (dir == 3 ? TILEY - crumbled_border_size : 0);
+ width = (dir == 1 || dir == 2 ? crumbled_border_size_var : TILESIZE_VAR);
+ height = (dir == 0 || dir == 3 ? crumbled_border_size_var : TILESIZE_VAR);
+ cx = (dir == 2 ? crumbled_border_pos_var : 0);
+ cy = (dir == 3 ? crumbled_border_pos_var : 0);
#else
if (dir == 1 || dir == 2) /* left or right crumbled border */
{
#if NEW_TILESIZE
BlitBitmap(src_bitmap, drawto_field,
- src_x + cx * TILESIZE_VAR / TILESIZE,
- src_y + cy * TILESIZE_VAR / TILESIZE,
- width * TILESIZE_VAR / TILESIZE,
- height * TILESIZE_VAR / TILESIZE,
- FX + sx * TILEX_VAR + cx * TILESIZE_VAR / TILESIZE,
- FY + sy * TILEY_VAR + cy * TILESIZE_VAR / TILESIZE);
+ src_x + cx,
+ src_y + cy,
+ width,
+ height,
+ FX + sx * TILEX_VAR + cx,
+ FY + sy * TILEY_VAR + cy);
#else
BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy);
/* correct corners of crumbled border, if needed */
#if 1
- for (i = -1; i <= 1; i+=2)
+ for (i = -1; i <= 1; i += 2)
{
int xx = x + (dir == 0 || dir == 3 ? i : 0);
int yy = y + (dir == 1 || dir == 2 ? i : 0);
{
/* no crumbled corner, but continued crumbled border */
- int c1 = (dir == 2 || dir == 3 ? TILESIZE - crumbled_border_size : 0);
- int c2 = (i == 1 ? TILESIZE - crumbled_border_size : 0);
- int b1 = (i == 1 ? crumbled_border_size :
- TILESIZE - 2 * crumbled_border_size);
+ int c1 = (dir == 2 || dir == 3 ? crumbled_border_pos_var : 0);
+ int c2 = (i == 1 ? crumbled_border_pos_var : 0);
+ int b1 = (i == 1 ? crumbled_border_size_var :
+ TILESIZE_VAR - 2 * crumbled_border_size_var);
- width = crumbled_border_size;
- height = crumbled_border_size;
+ width = crumbled_border_size_var;
+ height = crumbled_border_size_var;
if (dir == 1 || dir == 2)
{
#if NEW_TILESIZE
BlitBitmap(src_bitmap, drawto_field,
- src_x + bx * TILESIZE_VAR / TILESIZE,
- src_y + by * TILESIZE_VAR / TILESIZE,
- width * TILESIZE_VAR / TILESIZE,
- height * TILESIZE_VAR / TILESIZE,
- FX + sx * TILEX_VAR + cx * TILESIZE_VAR / TILESIZE,
- FY + sy * TILEY_VAR + cy * TILESIZE_VAR / TILESIZE);
+ src_x + bx,
+ src_y + by,
+ width,
+ height,
+ FX + sx * TILEX_VAR + cx,
+ FY + sy * TILEY_VAR + cy);
#else
BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy);
dst_x + xsize_size_left, dst_y + ysize_size_top);
#endif
-#if 1
+#if 0
redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
// redraw_mask |= REDRAW_ALL | REDRAW_FROM_BACKBUFFER;
#else
+ /* CHECK AGAIN (previous code reactivated) */
redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
#endif
#if 1
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ BlitScreenToBitmap_EM(backbuffer);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ BlitScreenToBitmap_SP(backbuffer);
+ else
+ BlitScreenToBitmap_RND(backbuffer);
+#endif
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
{
BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
}
+#endif
}
SetDrawtoField(DRAW_BACKBUFFER);
#if 1
// game_status = last_game_status; /* restore current game status */
+#if 1
+ /* !!! CHECK AGAIN (SEE BELOW) !!! */
+ game_status = last_game_status; /* restore current game status */
+#endif
+
if (action == ACTION_CLOSING)
{
if (game_status != GAME_MODE_MAIN)
// SetDrawBackgroundMask(last_draw_background_mask);
-#if 1
+#if 0
redraw_mask = REDRAW_FIELD;
// redraw_mask |= REDRAW_ALL;
#else
+ /* CHECK AGAIN (previous code reactivated) */
redraw_mask |= REDRAW_FIELD;
#endif
BackToFront();
+#if 0
/* (important: after "BackToFront()", but before "SetDrawtoField()") */
game_status = last_game_status; /* restore current game status */
+#endif
#if 1
if (action == ACTION_CLOSING &&
BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize, dst_x,dst_y);
}
-void DrawLevel()
+void DrawLevel(int draw_background_mask)
{
int x,y;
+#if 1
+ SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
+ SetDrawBackgroundMask(draw_background_mask);
+#else
#if 1
SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
SetDrawBackgroundMask(REDRAW_FIELD);
#else
SetDrawBackgroundMask(REDRAW_NONE);
+#endif
#endif
ClearField();
break;
case KSYM_Return:
+#if defined(TARGET_SDL2)
+ case KSYM_Menu:
+#endif
result = 1;
break;
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
BlitScreenToBitmap_SP(backbuffer);
+#endif
}
/* disable deactivated drawing when quick-loading level tape recording */
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
BlitScreenToBitmap_SP(backbuffer);
+ else
+ BlitScreenToBitmap_RND(backbuffer);
+#endif
+#else
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ BlitScreenToBitmap_EM(backbuffer);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ BlitScreenToBitmap_SP(backbuffer);
+#endif
}
/* disable deactivated drawing when quick-loading level tape recording */
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
BlitScreenToBitmap_SP(backbuffer);
+#endif
}
/* disable deactivated drawing when quick-loading level tape recording */
if (door_state & DOOR_ACTION)
{
boolean door_panel_drawn[NUM_DOORS];
+ boolean panel_has_doors[NUM_DOORS];
boolean door_part_skip[MAX_DOOR_PARTS];
boolean door_part_done[MAX_DOOR_PARTS];
boolean door_part_done_all;
int current_move_delay = 0;
int k;
+ for (i = 0; i < NUM_DOORS; i++)
+ panel_has_doors[i] = FALSE;
+
for (i = 0; i < MAX_DOOR_PARTS; i++)
{
struct DoorPartControlInfo *dpc = &door_part_controls[i];
struct DoorPartPosInfo *pos = dpc->pos;
struct GraphicInfo *g = &graphic_info[dpc->graphic];
int door_token = dpc->door_token;
+ int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
boolean is_panel = DOOR_PART_IS_PANEL(nr);
int step_xoffset = ABS(pos->step_xoffset);
int step_yoffset = ABS(pos->step_yoffset);
if (door_part_skip[nr])
continue;
+ if (!is_panel)
+ panel_has_doors[door_index] = TRUE;
+
max_move_delay = MAX(max_move_delay, move_delay);
max_step_delay = (max_step_delay == 0 ? step_delay :
euclid(max_step_delay, step_delay));
door_part_done[nr] = TRUE;
#endif
+#if 1
+ // continue door part animations, but not panel after door has closed
+ if (!door_part_done[nr] &&
+ !(is_panel && door_closing && panel_has_doors[door_index]))
+ door_part_done_all = FALSE;
+#else
// continue door part animations, but not panel after door has closed
if (!door_part_done[nr] && !(is_panel && door_closing))
door_part_done_all = FALSE;
+#endif
#if 0
if (!door_part_done[nr])
int *door_2_x = (game_status == GAME_MODE_EDITOR ? &EX : &VX);
int *door_2_y = (game_status == GAME_MODE_EDITOR ? &EY : &VY);
#endif
+#if 1
+ int gfx_game_mode = game_status;
+#else
int gfx_game_mode = (game_status == GAME_MODE_PLAYING ||
game_status == GAME_MODE_EDITOR ? game_status :
GAME_MODE_MAIN);
+#endif
int gfx_game_mode2 = (game_status == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
game_status);
struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
int new_exsize = vp_door_3->width;
int new_eysize = vp_door_3->height;
#if NEW_TILESIZE
+
+#if NEW_GAME_TILESIZE
+ int new_tilesize_var =
+ (setup.small_game_graphics ? MINI_TILESIZE : game.tile_size);
+#else
int new_tilesize_var = TILESIZE / (setup.small_game_graphics ? 2 : 1);
+#endif
+
int tilesize = (gfx_game_mode == GAME_MODE_PLAYING ? new_tilesize_var :
gfx_game_mode == GAME_MODE_EDITOR ? MINI_TILESIZE : TILESIZE);
int new_scr_fieldx = new_sxsize / tilesize;
boolean init_gfx_buffers = FALSE;
boolean init_video_buffer = FALSE;
boolean init_gadgets_and_toons = FALSE;
+ boolean init_em_graphics = FALSE;
#if 0
/* !!! TEST ONLY !!! */
#endif
)
{
+#if 1
+ if (new_tilesize_var != TILESIZE_VAR)
+ {
+ // printf("::: new_tilesize_var != TILESIZE_VAR\n");
+
+ // changing tile size invalidates scroll values of engine snapshots
+ FreeEngineSnapshot();
+
+ // changing tile size requires update of graphic mapping for EM engine
+ init_em_graphics = TRUE;
+ }
+#endif
+
SX = new_sx;
SY = new_sy;
DX = new_dx;
InitToons();
}
+ if (init_em_graphics)
+ {
+ InitGraphicInfo_EM();
+ }
+
#if 0
printf("::: %d, %d / %d, %d [%d]\n", VX, VY, EX, EY, game_status);
#endif
projects / rocksndiamonds.git / blobdiff