X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=9a712934ac5cf3a9344bd61244273bdfe4ff5d83;hb=8027f83cb6288618be3892b268760f25ca252606;hp=cb23bae615649c143a0e385aa126f6eb869a4f63;hpb=41def9c1d8c6939b8754fdab43579272e49d4da4;p=rocksndiamonds.git diff --git a/src/tools.c b/src/tools.c index cb23bae6..9a712934 100644 --- a/src/tools.c +++ b/src/tools.c @@ -108,6 +108,37 @@ void SetDrawtoField(int mode) { if (mode == DRAW_BUFFERED && setup.soft_scrolling) { +#if NEW_TILESIZE +#if NEW_SCROLL + FX = 2 * TILEX_VAR; + FY = 2 * TILEY_VAR; + BX1 = -2; + BY1 = -2; + BX2 = SCR_FIELDX + 1; + BY2 = SCR_FIELDY + 1; + redraw_x1 = 2; + redraw_y1 = 2; +#else + FX = TILEX_VAR; + FY = TILEY_VAR; + BX1 = -1; + BY1 = -1; + BX2 = SCR_FIELDX; + BY2 = SCR_FIELDY; + redraw_x1 = 1; + redraw_y1 = 1; +#endif +#else +#if NEW_SCROLL + FX = 2 * TILEX; + FY = 2 * TILEY; + BX1 = -2; + BY1 = -2; + BX2 = SCR_FIELDX + 1; + BY2 = SCR_FIELDY + 1; + redraw_x1 = 2; + redraw_y1 = 2; +#else FX = TILEX; FY = TILEY; BX1 = -1; @@ -116,6 +147,8 @@ void SetDrawtoField(int mode) BY2 = SCR_FIELDY; redraw_x1 = 1; redraw_y1 = 1; +#endif +#endif drawto_field = fieldbuffer; } @@ -251,6 +284,11 @@ void DrawMaskedBorder(int redraw_mask) effectiveGameStatus() == GAME_MODE_TITLE) return; + /* never draw masked screen borders when displaying request outside door */ + if (effectiveGameStatus() == GAME_MODE_PSEUDO_DOOR && + global.use_envelope_request) + return; + if (redraw_mask & REDRAW_ALL) DrawMaskedBorder_ALL(); else @@ -266,6 +304,65 @@ void DrawMaskedBorder(int redraw_mask) } } +void BlitScreenToBitmap(Bitmap *target_bitmap) +{ + DrawBuffer *buffer = (drawto_field == window ? backbuffer : drawto_field); + int fx = FX, fy = FY; + +#if NEW_TILESIZE + int dx = (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0); + int dy = (ScreenMovDir & (MV_UP | MV_DOWN) ? ScreenGfxPos : 0); + + int bx1, bx2, ffx, ffy; + + // fx += dx * TILESIZE_VAR / TILESIZE; + // fy += dy * TILESIZE_VAR / TILESIZE; +#else + fx += (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0); + fy += (ScreenMovDir & (MV_UP | MV_DOWN) ? ScreenGfxPos : 0); +#endif + + /* !!! THIS WORKS !!! */ + + ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx * TILESIZE_VAR / TILESIZE; + + if (EVEN(SCR_FIELDX)) + { + if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + 2 * TILEX_VAR / 2) + { + fx = fx + dx * TILESIZE_VAR / TILESIZE - MIN(ffx, TILEX_VAR / 2) + + 1 * TILEX_VAR; + } + else + { + fx = fx - (dx <= 0 ? TILEX_VAR : 0) + 1 * TILEX_VAR; + + printf("::: STOPPED\n"); + } + + printf("::: %d (%d, %d) [%d] [%d] => %d\n", + ffx, SBX_Left * TILEX_VAR, SBX_Right * TILEX_VAR, dx, FX, fx); + } + + if (border.draw_masked[GAME_MODE_PLAYING]) + { + if (buffer != backbuffer) + { + /* copy playfield buffer to backbuffer to add masked border */ + BlitBitmap(buffer, backbuffer, fx, fy, SXSIZE, SYSIZE, SX, SY); + DrawMaskedBorder(REDRAW_FIELD); + } + + BlitBitmap(backbuffer, target_bitmap, + REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, + REAL_SX, REAL_SY); + } + else + { + BlitBitmap(buffer, target_bitmap, fx, fy, SXSIZE, SYSIZE, SX, SY); + } +} + void BackToFront() { int x, y; @@ -332,7 +429,7 @@ void BackToFront() SyncDisplay(); - /* prevent drawing masked border to backbuffer when using playfield buffer */ + /* never draw masked border to backbuffer when using playfield buffer */ if (game_status != GAME_MODE_PLAYING || redraw_mask & REDRAW_FROM_BACKBUFFER || buffer == backbuffer) @@ -365,8 +462,129 @@ void BackToFront() if (setup.soft_scrolling) { +#if NEW_TILESIZE + int dx = (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0); + int dy = (ScreenMovDir & (MV_UP | MV_DOWN) ? ScreenGfxPos : 0); + + int bx1, bx2, ffx, ffy; + + // fx += dx * TILESIZE_VAR / TILESIZE; + // fy += dy * TILESIZE_VAR / TILESIZE; +#else fx += (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0); fy += (ScreenMovDir & (MV_UP | MV_DOWN) ? ScreenGfxPos : 0); +#endif + +#if 1 + +#if 0 + bx1 = SBX_Left * TILEX_VAR + TILEX_VAR / 2; + // bx1 = SBX_Left * TILEX_VAR; + bx2 = SBX_Right * TILEX_VAR - TILEX_VAR / 2; + ffx = scroll_x * TILEX_VAR + dx * TILESIZE_VAR / TILESIZE; + + if (ffx > bx1) // && ffx < bx2) + fx += dx * TILESIZE_VAR / TILESIZE; + + // fx += TILEX_VAR - (ffx - bx1) % TILEX_VAR; + + printf("::: %d (%d, %d) (%d)\n", ffx, bx1, bx2, dx); + +#if 0 + if (ffx > SBX_Left * TILEX_VAR) + fx -= MIN(ffx, TILEX_VAR / 2); + if (ffx > SBX_Left * TILEX_VAR && ffx < (SBX_Right + 1) * TILEX_VAR) + fx -= MIN(ffx, TILEX_VAR / 2); +#endif + +#else + +#if 0 + ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx * TILESIZE_VAR / TILESIZE; + + if (EVEN(SCR_FIELDX)) + { + if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2) + fx = fx + dx * TILESIZE_VAR / TILESIZE - MIN(ffx, TILEX_VAR / 2); + else + fx = fx - (dx <= 0 ? TILEX_VAR : 0); + + printf("::: %d (%d, %d) [%d] [%d] => %d\n", + ffx, SBX_Left * TILEX_VAR, SBX_Right * TILEX_VAR, dx, FX, fx); + } +#else + +#if 0 + ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx * TILESIZE_VAR / TILESIZE; + + if (EVEN(SCR_FIELDX)) + { + if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + 0 * TILEX_VAR / 2) + { + fx = fx + dx * TILESIZE_VAR / TILESIZE - MIN(ffx, TILEX_VAR / 2) + + 1 * TILEX_VAR; + } + else + { + fx = fx - (dx <= 0 ? TILEX_VAR : 0) + 1 * TILEX_VAR; + + printf("::: STOPPED\n"); + } + + printf("::: %d (%d, %d) [%d] [%d] => %d\n", + ffx, SBX_Left * TILEX_VAR, SBX_Right * TILEX_VAR, dx, FX, fx); + } +#else + /* !!! THIS WORKS !!! */ + + ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx * TILESIZE_VAR / TILESIZE; + + if (EVEN(SCR_FIELDX)) + { + if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + 2 * TILEX_VAR / 2) + { + fx = fx + dx * TILESIZE_VAR / TILESIZE - MIN(ffx, TILEX_VAR / 2) + + 1 * TILEX_VAR; + } + else + { + fx = fx - (dx <= 0 ? TILEX_VAR : 0) + 1 * TILEX_VAR; + + printf("::: STOPPED\n"); + } + + printf("::: %d (%d, %d) [%d] [%d] [%d, %d] => %d\n", + ffx, SBX_Left * TILEX_VAR, SBX_Right * TILEX_VAR, + dx, FX, ScreenMovDir, ScreenGfxPos, fx); + } + else + { + fx += dx; + } + + fy += dy; +#endif + +#endif + +#endif + +#if 0 + printf("::: %d, %d [%d, %d] [%d, %d] [%d, %d] [%d] [%d, %d]\n", + fx, fy, FX, FY, ScreenMovDir, ScreenGfxPos, + scroll_x, scroll_y, + ffx, + SBX_Left, SBX_Right); +#endif + +#endif + +#if 0 +#if NEW_TILESIZE + fx = fx * TILESIZE_VAR / TILESIZE; + fy = fy * TILESIZE_VAR / TILESIZE; +#endif +#endif } if (setup.soft_scrolling || @@ -439,12 +657,67 @@ void BackToFront() printf("::: REDRAW_TILES\n"); #endif +#if NEW_TILESIZE + +#if 1 + InitGfxClipRegion(TRUE, SX, SY, SXSIZE, SYSIZE); + + { + int sx = SX; // - (EVEN(SCR_FIELDX) ? TILEX_VAR / 2 : 0); + int sy = SY; // + (EVEN(SCR_FIELDY) ? TILEY_VAR / 2 : 0); + + int dx = 0, dy = 0; + int ffx, ffy; + int fx = FX, fy = FY; + + ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx * TILESIZE_VAR / TILESIZE; + + if (EVEN(SCR_FIELDX)) + { + if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + 2 * TILEX_VAR / 2) + { + fx = fx + dx * TILESIZE_VAR / TILESIZE - MIN(ffx, TILEX_VAR / 2) + + 1 * TILEX_VAR; + + if (fx % TILEX_VAR) + sx -= TILEX_VAR / 2; + else + sx -= TILEX_VAR; + } + else + { + fx = fx - (dx <= 0 ? TILEX_VAR : 0) + 1 * TILEX_VAR; + } + } + + for (x = 0; x < SCR_FIELDX; x++) + for (y = 0 ; y < SCR_FIELDY; y++) + if (redraw[redraw_x1 + x][redraw_y1 + y]) + BlitBitmap(buffer, window, + FX + x * TILEX_VAR, FY + y * TILEY_VAR, + TILEX_VAR, TILEY_VAR, + sx + x * TILEX_VAR, sy + y * TILEY_VAR); + } + + InitGfxClipRegion(FALSE, -1, -1, -1, -1); +#else + for (x = 0; x < SCR_FIELDX; x++) + for (y = 0 ; y < SCR_FIELDY; y++) + if (redraw[redraw_x1 + x][redraw_y1 + y]) + BlitBitmap(buffer, window, + FX + x * TILEX_VAR, FY + y * TILEY_VAR, + TILEX_VAR, TILEY_VAR, + SX + x * TILEX_VAR, SY + y * TILEY_VAR); +#endif + +#else for (x = 0; x < SCR_FIELDX; x++) for (y = 0 ; y < SCR_FIELDY; y++) if (redraw[redraw_x1 + x][redraw_y1 + y]) BlitBitmap(buffer, window, FX + x * TILEX, FY + y * TILEY, TILEX, TILEY, SX + x * TILEX, SY + y * TILEY); +#endif } if (redraw_mask & REDRAW_FPS) /* display frames per second */ @@ -795,8 +1068,22 @@ void SetDoorBackgroundImage(int graphic) void SetPanelBackground() { +#if 1 + struct GraphicInfo *gfx = &graphic_info[IMG_BACKGROUND_PANEL]; + +#if 1 + BlitBitmapTiled(gfx->bitmap, bitmap_db_panel, gfx->src_x, gfx->src_y, + gfx->width, gfx->height, 0, 0, DXSIZE, DYSIZE); +#else + /* (ClearRectangle() only needed if panel bitmap is smaller than panel) */ + ClearRectangle(bitmap_db_panel, DX, DY, DXSIZE, DYSIZE); + BlitBitmap(gfx->bitmap, bitmap_db_panel, gfx->src_x, gfx->src_y, + MIN(gfx->width, DXSIZE), MIN(gfx->height, DYSIZE), 0, 0); +#endif +#else BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, bitmap_db_panel, DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, 0, 0); +#endif SetDoorBackgroundBitmap(bitmap_db_panel); } @@ -932,8 +1219,9 @@ inline int getGraphicAnimationFrame(int graphic, int sync_frame) sync_frame); } -void getSizedGraphicSource(int graphic, int frame, int tilesize_raw, - Bitmap **bitmap, int *x, int *y) +void getSizedGraphicSourceExt(int graphic, int frame, int tilesize_raw, + Bitmap **bitmap, int *x, int *y, + boolean get_backside) { struct { @@ -959,8 +1247,15 @@ void getSizedGraphicSource(int graphic, int frame, int tilesize_raw, 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; +#if NEW_TILESIZE + int src_x = (g->src_x + (get_backside ? g->offset2_x : 0)) * + tilesize / TILESIZE; + int src_y = (g->src_y + (get_backside ? g->offset2_y : 0)) * + tilesize / TILESIZE; +#else int src_x = g->src_x * tilesize / TILESIZE; int src_y = g->src_y * tilesize / TILESIZE; +#endif int width = g->width * tilesize / TILESIZE; int height = g->height * tilesize / TILESIZE; int offset_x = g->offset_x * tilesize / TILESIZE; @@ -993,6 +1288,25 @@ void getSizedGraphicSource(int graphic, int frame, int tilesize_raw, *y = starty + src_y; } +void getFixedGraphicSourceExt(int graphic, int frame, Bitmap **bitmap, + int *x, int *y, boolean get_backside) +{ + getSizedGraphicSourceExt(graphic, frame, TILESIZE, bitmap, x, y, + get_backside); +} + +void getSizedGraphicSource(int graphic, int frame, int tilesize_raw, + Bitmap **bitmap, int *x, int *y) +{ + getSizedGraphicSourceExt(graphic, frame, tilesize_raw, bitmap, x, y, FALSE); +} + +void getFixedGraphicSource(int graphic, int frame, + Bitmap **bitmap, int *x, int *y) +{ + getSizedGraphicSourceExt(graphic, frame, TILESIZE, bitmap, x, y, FALSE); +} + void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y) { #if 1 @@ -1015,6 +1329,12 @@ inline void getGraphicSourceExt(int graphic, int frame, Bitmap **bitmap, int src_x = g->src_x + (get_backside ? g->offset2_x : 0); int src_y = g->src_y + (get_backside ? g->offset2_y : 0); +#if NEW_TILESIZE + if (TILESIZE_VAR != TILESIZE) + return getSizedGraphicSourceExt(graphic, frame, TILESIZE_VAR, bitmap, x, y, + get_backside); +#endif + *bitmap = g->bitmap; if (g->offset_y == 0) /* frames are ordered horizontally */ @@ -1056,7 +1376,28 @@ void DrawGraphic(int x, int y, int graphic, int frame) } #endif +#if NEW_TILESIZE + DrawGraphicExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR, graphic, + frame); +#else DrawGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic, frame); +#endif + MarkTileDirty(x, y); +} + +void DrawFixedGraphic(int x, int y, int graphic, int frame) +{ +#if DEBUG + if (!IN_SCR_FIELD(x, y)) + { + printf("DrawGraphic(): x = %d, y = %d, graphic = %d\n", x, y, graphic); + printf("DrawGraphic(): This should never happen!\n"); + return; + } +#endif + + DrawFixedGraphicExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic, + frame); MarkTileDirty(x, y); } @@ -1067,6 +1408,20 @@ void DrawGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic, int src_x, src_y; getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y); +#if NEW_TILESIZE + BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX_VAR, TILEY_VAR, x, y); +#else + BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y); +#endif +} + +void DrawFixedGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic, + int frame) +{ + Bitmap *src_bitmap; + int src_x, src_y; + + getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y); BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y); } @@ -1081,8 +1436,29 @@ void DrawGraphicThruMask(int x, int y, int graphic, int frame) } #endif - DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y *TILEY, graphic, +#if NEW_TILESIZE + DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR, + graphic, frame); +#else + DrawGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic, frame); +#endif + MarkTileDirty(x, y); +} + +void DrawFixedGraphicThruMask(int x, int y, int graphic, int frame) +{ +#if DEBUG + if (!IN_SCR_FIELD(x, y)) + { + printf("DrawGraphicThruMask(): x = %d,y = %d, graphic = %d\n",x,y,graphic); + printf("DrawGraphicThruMask(): This should never happen!\n"); + return; + } +#endif + + DrawFixedGraphicThruMaskExt(drawto_field, FX + x * TILEX, FY + y * TILEY, + graphic, frame); MarkTileDirty(x, y); } @@ -1094,6 +1470,24 @@ void DrawGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y, int graphic, getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y); + SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc, + dst_x - src_x, dst_y - src_y); +#if NEW_TILESIZE + BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX_VAR, TILEY_VAR, + dst_x, dst_y); +#else + BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dst_x, dst_y); +#endif +} + +void DrawFixedGraphicThruMaskExt(DrawBuffer *d, int dst_x, int dst_y, + int graphic, int frame) +{ + Bitmap *src_bitmap; + int src_x, src_y; + + getFixedGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y); + SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc, dst_x - src_x, dst_y - src_y); BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dst_x, dst_y); @@ -1214,6 +1608,15 @@ inline static void DrawGraphicShiftedNormal(int x, int y, int dx, int dy, } #endif +#if NEW_TILESIZE + width = width * TILESIZE_VAR / TILESIZE; + height = height * TILESIZE_VAR / TILESIZE; + cx = cx * TILESIZE_VAR / TILESIZE; + cy = cy * TILESIZE_VAR / TILESIZE; + dx = dx * TILESIZE_VAR / TILESIZE; + dy = dy * TILESIZE_VAR / TILESIZE; +#endif + if (width > 0 && height > 0) { getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y); @@ -1221,8 +1624,13 @@ inline static void DrawGraphicShiftedNormal(int x, int y, int dx, int dy, src_x += cx; src_y += cy; +#if NEW_TILESIZE + dst_x = FX + x * TILEX_VAR + dx; + dst_y = FY + y * TILEY_VAR + dy; +#else dst_x = FX + x * TILEX + dx; dst_y = FY + y * TILEY + dy; +#endif if (mask_mode == USE_MASKING) { @@ -1246,7 +1654,11 @@ inline static void DrawGraphicShiftedDouble(int x, int y, int dx, int dy, Bitmap *src_bitmap; int src_x, src_y; int dst_x, dst_y; +#if NEW_TILESIZE + int width = TILEX_VAR, height = TILEY_VAR; +#else int width = TILEX, height = TILEY; +#endif int x1 = x; int y1 = y; int x2 = x + SIGN(dx); @@ -1293,8 +1705,13 @@ inline static void DrawGraphicShiftedDouble(int x, int y, int dx, int dy, { getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, TRUE); +#if NEW_TILESIZE + dst_x = FX + x1 * TILEX_VAR; + dst_y = FY + y1 * TILEY_VAR; +#else dst_x = FX + x1 * TILEX; dst_y = FY + y1 * TILEY; +#endif if (mask_mode == USE_MASKING) { @@ -1315,8 +1732,13 @@ inline static void DrawGraphicShiftedDouble(int x, int y, int dx, int dy, { getGraphicSourceExt(graphic, frame, &src_bitmap, &src_x, &src_y, FALSE); +#if NEW_TILESIZE + dst_x = FX + x2 * TILEX_VAR; + dst_y = FY + y2 * TILEY_VAR; +#else dst_x = FX + x2 * TILEX; dst_y = FY + y2 * TILEY; +#endif if (mask_mode == USE_MASKING) { @@ -1486,6 +1908,15 @@ static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy, getGraphicSource(graphic, 1, &src_bitmap, &src_x, &src_y); +#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; + + BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy, + width, height, FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy); +#else width = crumbled_border_size; height = crumbled_border_size; cx = (dx > 0 ? TILEX - crumbled_border_size : 0); @@ -1493,6 +1924,7 @@ static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy, BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy, width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy); +#endif } static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame, @@ -1531,8 +1963,18 @@ static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame, } #endif +#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); +#else BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy, width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy); +#endif /* (remaining middle border part must be at least as big as corner part) */ if (!(graphic_info[graphic].style & STYLE_ACCURATE_BORDERS) || @@ -1579,8 +2021,18 @@ static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame, by = cy; } +#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); +#else BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by, width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy); +#endif } } #else @@ -2031,7 +2483,7 @@ void DrawEnvelopeBackground(int envelope_nr, int startx, int starty, int inner_sy = (height >= 3 * font_height ? font_height : 0); boolean draw_masked = graphic_info[graphic].draw_masked; - getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y); + getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y); if (src_bitmap == NULL || width < font_width || height < font_height) { @@ -2099,7 +2551,7 @@ void AnimateEnvelope(int envelope_nr, int anim_mode, int action) #if 1 DrawTextBuffer(SX + sx + font_width, SY + sy + font_height, level.envelope[envelope_nr].text, font_nr, max_xsize, - xsize - 2, ysize - 2, mask_mode, + xsize - 2, ysize - 2, 0, mask_mode, level.envelope[envelope_nr].autowrap, level.envelope[envelope_nr].centered, FALSE); #else @@ -2108,55 +2560,352 @@ void AnimateEnvelope(int envelope_nr, int anim_mode, int action) xsize - 2, ysize - 2, mask_mode); #endif - redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER; - BackToFront(); + redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER; + BackToFront(); + + WaitUntilDelayReached(&anim_delay, anim_delay_value / 2); + } +} + +void AnimateEnvelopeDoor(char *text, int anim_mode, int action) +{ +#if 1 + int envelope_nr = 0; +#endif + int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr; + Bitmap *src_bitmap = graphic_info[graphic].bitmap; + int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND); + boolean ffwd_delay = (tape.playing && tape.fast_forward); + boolean no_delay = (tape.warp_forward); + unsigned long anim_delay = 0; + int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay); + int anim_delay_value = (no_delay ? 0 : frame_delay_value); +#if 1 + int max_word_len = maxWordLengthInString(text); + int font_nr = (max_word_len > 7 ? FONT_TEXT_1 : FONT_TEXT_2); +#else + int font_nr = FONT_ENVELOPE_1 + envelope_nr; +#endif + int font_width = getFontWidth(font_nr); + int font_height = getFontHeight(font_nr); +#if 1 + +#if 1 + int max_xsize = DXSIZE / font_width; + int max_ysize = DYSIZE / font_height; +#else + int max_xsize = 7; /* tools.c: MAX_REQUEST_LINE_FONT1_LEN == 7 */ + int max_ysize = 13; /* tools.c: MAX_REQUEST_LINES == 13 */ +#endif + +#else + int max_xsize = level.envelope[envelope_nr].xsize; + int max_ysize = level.envelope[envelope_nr].ysize; +#endif + int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize : 0); + int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize : 0); + int xend = max_xsize; + int yend = (anim_mode != ANIM_DEFAULT ? max_ysize : 0); + int xstep = (xstart < xend ? 1 : 0); + int ystep = (ystart < yend || xstep == 0 ? 1 : 0); + int x, y; + +#if 1 + char *text_ptr; + char *text_copy = getStringCopy(text); +#else +#if 1 + font_nr = FONT_TEXT_2; + + if (maxWordLengthInString(text) > 7) /* MAX_REQUEST_LINE_FONT1_LEN == 7 */ + { + max_xsize = 10; /* tools.c: MAX_REQUEST_LINE_FONT2_LEN == 10 */ + font_nr = FONT_TEXT_1; + } +#else + int max_word_len = 0; + char *text_ptr; + char *text_copy = getStringCopy(text); + + font_nr = FONT_TEXT_2; + + for (text_ptr = text; *text_ptr; text_ptr++) + { + max_word_len = (*text_ptr != ' ' ? max_word_len + 1 : 0); + + if (max_word_len > 7) /* tools.c: MAX_REQUEST_LINE_FONT1_LEN == 7 */ + { + max_xsize = 10; /* tools.c: MAX_REQUEST_LINE_FONT2_LEN == 10 */ + font_nr = FONT_TEXT_1; + + break; + } + } +#endif +#endif + +#if 1 + for (text_ptr = text_copy; *text_ptr; text_ptr++) + if (*text_ptr == ' ') + *text_ptr = '\n'; +#endif + +#if 1 + dDX = SX + (SXSIZE - DXSIZE) / 2 - DX; + dDY = SY + (SYSIZE - DYSIZE) / 2 - DY; +#else + dDX = SX + SXSIZE / 2 - max_xsize * font_width / 2 - DX; + dDY = SY + SYSIZE / 2 - max_ysize * font_height / 2 - DY; +#endif + + for (x = xstart, y = ystart; x <= xend && y <= yend; x += xstep, y += ystep) + { + int xsize = (action == ACTION_CLOSING ? xend - (x - xstart) : x) + 2; + int ysize = (action == ACTION_CLOSING ? yend - (y - ystart) : y) + 2; + int sx = (SXSIZE - xsize * font_width) / 2; + int sy = (SYSIZE - ysize * font_height) / 2; + int xx, yy; + +#if 1 + BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0); +#else + SetDrawtoField(DRAW_BUFFERED); + + BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY); + + SetDrawtoField(DRAW_BACKBUFFER); +#endif + + for (yy = 0; yy < ysize; yy++) for (xx = 0; xx < xsize; xx++) + DrawEnvelopeBackground(envelope_nr, sx,sy, xx,yy, xsize, ysize, font_nr); + +#if 1 + +#if 1 + DrawTextBuffer(SX + sx + font_width, SY + sy + font_height + 8, + text_copy, font_nr, max_xsize, + xsize - 2, ysize - 2, 2, mask_mode, + FALSE, TRUE, FALSE); +#else + DrawTextBuffer(SX + sx + font_width, SY + sy + font_height, + level.envelope[envelope_nr].text, font_nr, max_xsize, + xsize - 2, ysize - 2, 0, mask_mode, + level.envelope[envelope_nr].autowrap, + level.envelope[envelope_nr].centered, FALSE); +#endif + +#else + DrawTextToTextArea(SX + sx + font_width, SY + sy + font_height, + level.envelope[envelope_nr].text, font_nr, max_xsize, + xsize - 2, ysize - 2, mask_mode); +#endif + + /* copy request gadgets to door backbuffer */ +#if 1 + if ((ysize - 2) > 13) + BlitBitmap(bitmap_db_door, drawto, + DOOR_GFX_PAGEX1 + (DXSIZE - (xsize - 2) * font_width) / 2, + DOOR_GFX_PAGEY1 + 13 * font_height, + (xsize - 2) * font_width, + (ysize - 2 - 13) * font_height, + SX + sx + font_width, + SY + sy + font_height * (1 + 13)); +#else + if ((ysize - 2) > 13) + BlitBitmap(bitmap_db_door, drawto, + DOOR_GFX_PAGEX1 + (DXSIZE - (xsize - 2) * font_width) / 2, + DOOR_GFX_PAGEY1 + 13 * font_height, + (xsize - 2) * font_width, + (ysize - 2 - 13) * font_height, + SX + sx + font_width, + SY + sy + font_height * (1 + 13)); +#endif + +#if 1 + redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER; + // redraw_mask |= REDRAW_ALL | REDRAW_FROM_BACKBUFFER; +#else + redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER; +#endif + +#if 1 + DoAnimation(); + BackToFront(); +#else + BackToFront(); +#endif + + WaitUntilDelayReached(&anim_delay, anim_delay_value / 2); + } + +#if 1 + free(text_copy); +#endif +} + +void ShowEnvelope(int envelope_nr) +{ + int element = EL_ENVELOPE_1 + envelope_nr; + int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr; + int sound_opening = element_info[element].sound[ACTION_OPENING]; + int sound_closing = element_info[element].sound[ACTION_CLOSING]; + boolean ffwd_delay = (tape.playing && tape.fast_forward); + boolean no_delay = (tape.warp_forward); + int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1); + int wait_delay_value = (no_delay ? 0 : normal_delay_value); + int anim_mode = graphic_info[graphic].anim_mode; + int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL: + anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode); + + game.envelope_active = TRUE; /* needed for RedrawPlayfield() events */ + + PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE); + + if (anim_mode == ANIM_DEFAULT) + AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING); + + AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING); + + if (tape.playing) + Delay(wait_delay_value); + else + WaitForEventToContinue(); + + PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE); + + if (anim_mode != ANIM_NONE) + AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING); - WaitUntilDelayReached(&anim_delay, anim_delay_value / 2); - } + if (anim_mode == ANIM_DEFAULT) + AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING); + + game.envelope_active = FALSE; + + SetDrawtoField(DRAW_BUFFERED); + + redraw_mask |= REDRAW_FIELD; + BackToFront(); } -void ShowEnvelope(int envelope_nr) +void ShowEnvelopeDoor(char *text, int action) { +#if 1 + int last_game_status = game_status; /* save current game status */ + // int last_draw_background_mask = gfx.draw_background_mask; + int envelope_nr = 0; +#endif int element = EL_ENVELOPE_1 + envelope_nr; int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr; int sound_opening = element_info[element].sound[ACTION_OPENING]; int sound_closing = element_info[element].sound[ACTION_CLOSING]; +#if 0 boolean ffwd_delay = (tape.playing && tape.fast_forward); boolean no_delay = (tape.warp_forward); int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1); int wait_delay_value = (no_delay ? 0 : normal_delay_value); +#endif int anim_mode = graphic_info[graphic].anim_mode; int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL: anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode); +#if 1 + if (game_status == GAME_MODE_PLAYING) + { + 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 + { + BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY); + } + } + + SetDrawtoField(DRAW_BACKBUFFER); + + // SetDrawBackgroundMask(REDRAW_NONE); + + if (action == ACTION_OPENING) + { + BlitBitmap(backbuffer, bitmap_db_store, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0); + + if (game_status != GAME_MODE_MAIN) + InitAnimation(); + } + + /* force DOOR font inside door area */ + game_status = GAME_MODE_PSEUDO_DOOR; +#endif + game.envelope_active = TRUE; /* needed for RedrawPlayfield() events */ - PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE); + if (action == ACTION_OPENING) + { + PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE); - if (anim_mode == ANIM_DEFAULT) - AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING); + if (anim_mode == ANIM_DEFAULT) + AnimateEnvelopeDoor(text, ANIM_DEFAULT, ACTION_OPENING); - AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING); + AnimateEnvelopeDoor(text, main_anim_mode, ACTION_OPENING); - if (tape.playing) - Delay(wait_delay_value); +#if 0 + if (tape.playing) + Delay(wait_delay_value); + else + WaitForEventToContinue(); +#endif + } else - WaitForEventToContinue(); - - PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE); + { + PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE); - if (anim_mode != ANIM_NONE) - AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING); + if (anim_mode != ANIM_NONE) + AnimateEnvelopeDoor(text, main_anim_mode, ACTION_CLOSING); - if (anim_mode == ANIM_DEFAULT) - AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING); + if (anim_mode == ANIM_DEFAULT) + AnimateEnvelopeDoor(text, ANIM_DEFAULT, ACTION_CLOSING); + } game.envelope_active = FALSE; +#if 1 + // game_status = last_game_status; /* restore current game status */ + + if (action == ACTION_CLOSING) + { + if (game_status != GAME_MODE_MAIN) + StopAnimation(); + + BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0); + } +#else SetDrawtoField(DRAW_BUFFERED); +#endif + // SetDrawBackgroundMask(last_draw_background_mask); + +#if 1 + redraw_mask = REDRAW_FIELD; + // redraw_mask |= REDRAW_ALL; +#else redraw_mask |= REDRAW_FIELD; +#endif + +#if 1 + if (game_status == GAME_MODE_MAIN) + DoAnimation(); + + BackToFront(); + + /* (important: after "BackToFront()", but before "SetDrawtoField()") */ + game_status = last_game_status; /* restore current game status */ + + if (game_status == GAME_MODE_PLAYING && + level.game_engine_type == GAME_ENGINE_TYPE_RND) + SetDrawtoField(DRAW_BUFFERED); +#else BackToFront(); +#endif } void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize) @@ -2533,6 +3282,18 @@ inline void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y, DrawGraphicExt(dst_bitmap, x, y, graphic, frame); } +inline void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y, + int graphic, int sync_frame, + int mask_mode) +{ + int frame = getGraphicAnimationFrame(graphic, sync_frame); + + if (mask_mode == USE_MASKING) + DrawFixedGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame); + else + DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame); +} + inline void DrawGraphicAnimation(int x, int y, int graphic) { int lx = LEVELX(x), ly = LEVELY(y); @@ -2540,6 +3301,23 @@ inline void DrawGraphicAnimation(int x, int y, int graphic) if (!IN_SCR_FIELD(x, y)) return; +#if NEW_TILESIZE + DrawGraphicAnimationExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR, + graphic, GfxFrame[lx][ly], NO_MASKING); +#else + DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY, + graphic, GfxFrame[lx][ly], NO_MASKING); +#endif + MarkTileDirty(x, y); +} + +inline void DrawFixedGraphicAnimation(int x, int y, int graphic) +{ + int lx = LEVELX(x), ly = LEVELY(y); + + if (!IN_SCR_FIELD(x, y)) + return; + DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY, graphic, GfxFrame[lx][ly], NO_MASKING); MarkTileDirty(x, y); @@ -3084,9 +3862,23 @@ boolean Request(char *text, unsigned int req_state) int last_game_status = game_status; /* save current game status */ int max_request_line_len = MAX_REQUEST_LINE_FONT1_LEN; int font_nr = FONT_TEXT_2; +#if 0 int max_word_len = 0; +#endif char *text_ptr; + int i; + +#if 1 + global.use_envelope_request = 0; +#endif +#if 1 + if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN) + { + max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN; + font_nr = FONT_TEXT_1; + } +#else for (text_ptr = text; *text_ptr; text_ptr++) { max_word_len = (*text_ptr != ' ' ? max_word_len + 1 : 0); @@ -3103,6 +3895,7 @@ boolean Request(char *text, unsigned int req_state) break; } } +#endif if (game_status == GAME_MODE_PLAYING) { @@ -3134,9 +3927,21 @@ boolean Request(char *text, unsigned int req_state) UnmapAllGadgets(); + /* draw released gadget before proceeding */ + // BackToFront(); + +#if 0 + if (old_door_state & DOOR_OPEN_1 && !global.use_envelope_request) +#else if (old_door_state & DOOR_OPEN_1) +#endif { +#if 1 + if (!global.use_envelope_request) + CloseDoor(DOOR_CLOSE_1); +#else CloseDoor(DOOR_CLOSE_1); +#endif /* save old door content */ BlitBitmap(bitmap_db_door, bitmap_db_door, @@ -3157,40 +3962,49 @@ boolean Request(char *text, unsigned int req_state) game_status = GAME_MODE_PSEUDO_DOOR; /* write text for request */ - for (ty = 0; ty < MAX_REQUEST_LINES; ty++) + for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++) { char text_line[max_request_line_len + 1]; int tx, tl, tc = 0; - if (!*text) + if (!*text_ptr) break; for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++) { - tc = *(text + tx); + tc = *(text_ptr + tx); if (!tc || tc == ' ') break; } if (!tl) { - text++; + text_ptr++; ty--; continue; } - strncpy(text_line, text, tl); + strncpy(text_line, text_ptr, tl); text_line[tl] = 0; DrawText(DX + (DXSIZE - tl * getFontWidth(font_nr)) / 2, DY + 8 + ty * (getFontHeight(font_nr) + 2), text_line, font_nr); - text += tl + (tc == ' ' ? 1 : 0); + text_ptr += tl + (tc == ' ' ? 1 : 0); } game_status = last_game_status; /* restore current game status */ +#if 1 + if (global.use_envelope_request) + { + /* !!! TMP !!! */ + FreeToolButtons(); + CreateToolButtons(); + } +#endif + if (req_state & REQ_ASK) { MapGadget(tool_gadget[TOOL_CTRL_ID_YES]); @@ -3213,7 +4027,36 @@ boolean Request(char *text, unsigned int req_state) DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1); +#if 1 + if (global.use_envelope_request) + { + ShowEnvelopeDoor(text, ACTION_OPENING); + + for (i = 0; i < NUM_TOOL_BUTTONS; i++) + { + if ((req_state & REQ_ASK && (i == TOOL_CTRL_ID_YES || + i == TOOL_CTRL_ID_NO)) || + (req_state & REQ_CONFIRM && i == TOOL_CTRL_ID_CONFIRM) || + (req_state & REQ_PLAYER && (i == TOOL_CTRL_ID_PLAYER_1 && + i == TOOL_CTRL_ID_PLAYER_2 && + i == TOOL_CTRL_ID_PLAYER_3 && + i == TOOL_CTRL_ID_PLAYER_4))) + { + int x = tool_gadget[i]->x + dDX; + int y = tool_gadget[i]->y + dDY; + + ModifyGadget(tool_gadget[i], GDI_X, x, GDI_Y, y, GDI_END); + } + } + } +#endif + +#if 1 + if (!global.use_envelope_request) + OpenDoor(DOOR_OPEN_1); +#else OpenDoor(DOOR_OPEN_1); +#endif if (!(req_state & REQUEST_WAIT_FOR_INPUT)) { @@ -3230,8 +4073,13 @@ boolean Request(char *text, unsigned int req_state) return FALSE; } +#if 1 + if (game_status != GAME_MODE_MAIN && !global.use_envelope_request) + InitAnimation(); +#else if (game_status != GAME_MODE_MAIN) InitAnimation(); +#endif button_status = MB_RELEASED; @@ -3368,8 +4216,16 @@ boolean Request(char *text, unsigned int req_state) Delay(10); } +#if 1 + game_status = GAME_MODE_PSEUDO_DOOR; +#endif + BackToFront(); +#if 1 + game_status = last_game_status; /* restore current game status */ +#endif + #else DoAnimation(); @@ -3390,7 +4246,16 @@ boolean Request(char *text, unsigned int req_state) UnmapToolButtons(); +#if 1 + if (global.use_envelope_request) + ShowEnvelopeDoor(text, ACTION_CLOSING); +#endif + +#if 1 + if (!(req_state & REQ_STAY_OPEN) && !global.use_envelope_request) +#else if (!(req_state & REQ_STAY_OPEN)) +#endif { CloseDoor(DOOR_CLOSE_1); @@ -6415,6 +7280,12 @@ inline static int get_effective_element_EM(int tile, int frame_em) case Yacid_splash_wB: return (frame_em > 5 ? EL_EMPTY : element); +#if 0 + case Ydiamond_stone: + // if (!game.use_native_emc_graphics_engine) + return EL_ROCK; +#endif + default: return element; } @@ -6492,6 +7363,11 @@ inline static boolean check_linear_animation_EM(int tile) case Ytank_s_e: case Ytank_w_s: case Ytank_n_w: +#if 1 + case Yacid_splash_eB: + case Yacid_splash_wB: + case Yemerald_stone: +#endif return TRUE; } @@ -7100,6 +7976,23 @@ void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em, #endif +#if 0 + if (tile == Ydiamond_stone) + printf("::: stone smashing diamond... %d: %d, %d, %d, %d, %d -> %d [%d, %d, %d, %d, %d, %d] [%d]\n", + frame_em, + g->anim_frames, + g->anim_delay, + g->anim_mode, + g->anim_start_frame, + sync_frame, + frame, + g_em->src_x, g_em->src_y, + g_em->src_offset_x, g_em->src_offset_y, + g_em->dst_offset_x, g_em->dst_offset_y, + graphic); +#endif + + #if 0 return; #endif @@ -7942,6 +8835,48 @@ void InitGraphicInfo_EM(void) #endif } +void CheckSingleStepMode_EM(byte action[MAX_PLAYERS], int frame, + boolean any_player_moving, + boolean player_is_dropping) +{ + int i; + + if (tape.single_step && tape.recording && !tape.pausing) + { + boolean active_players = FALSE; + + for (i = 0; i < MAX_PLAYERS; i++) + if (action[i] != JOY_NO_ACTION) + active_players = TRUE; + + // if (frame == 0) + if (frame == 0 && !player_is_dropping) + TapeTogglePause(TAPE_TOGGLE_AUTOMATIC); + } +} + +void CheckSingleStepMode_SP(boolean murphy_is_waiting, + boolean murphy_is_dropping) +{ +#if 0 + printf("::: waiting: %d, dropping: %d\n", + murphy_is_waiting, murphy_is_dropping); +#endif + + if (tape.single_step && tape.recording && !tape.pausing) + { + // if (murphy_is_waiting || murphy_is_dropping) + if (murphy_is_waiting) + { +#if 0 + printf("::: murphy is waiting -> pause mode\n"); +#endif + + TapeTogglePause(TAPE_TOGGLE_AUTOMATIC); + } + } +} + void getGraphicSource_SP(struct GraphicInfo_SP *g_sp, int graphic, int sync_frame, int x, int y) { @@ -8101,8 +9036,33 @@ void ChangeViewportPropertiesIfNeeded() int border_size = vp_playfield->border_size; int new_sx = vp_playfield->x + border_size; int new_sy = vp_playfield->y + border_size; + int new_sxsize = vp_playfield->width - 2 * border_size; + int new_sysize = vp_playfield->height - 2 * border_size; + int new_real_sx = vp_playfield->x; + int new_real_sy = vp_playfield->y; + int new_full_sxsize = vp_playfield->width; + int new_full_sysize = vp_playfield->height; +#if NEW_TILESIZE + int new_tilesize_var = TILESIZE / (setup.small_game_graphics ? 2 : 1); + 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; + int new_scr_fieldy = new_sysize / tilesize; + int new_scr_fieldx_buffers = new_sxsize / new_tilesize_var; + int new_scr_fieldy_buffers = new_sysize / new_tilesize_var; +#else int new_scr_fieldx = (vp_playfield->width - 2 * border_size) / TILESIZE; int new_scr_fieldy = (vp_playfield->height - 2 * border_size) / TILESIZE; +#endif + boolean init_gfx_buffers = FALSE; + boolean init_video_buffer = FALSE; + boolean init_gadgets_and_toons = FALSE; + +#if 0 + /* !!! TEST ONLY !!! */ + // InitGfxBuffers(); + return; +#endif if (viewport.window.width != WIN_XSIZE || viewport.window.height != WIN_YSIZE) @@ -8110,6 +9070,10 @@ void ChangeViewportPropertiesIfNeeded() WIN_XSIZE = viewport.window.width; WIN_YSIZE = viewport.window.height; +#if 1 + init_video_buffer = TRUE; + init_gfx_buffers = TRUE; +#else InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen); InitGfxBuffers(); @@ -8119,37 +9083,124 @@ void ChangeViewportPropertiesIfNeeded() // RedrawBackground(); #endif +#endif + + // printf("::: video: init_video_buffer, init_gfx_buffers\n"); } if (new_scr_fieldx != SCR_FIELDX || - new_scr_fieldy != SCR_FIELDY || - new_sx != SX || + new_scr_fieldy != SCR_FIELDY) + { + /* this always toggles between MAIN and GAME when using small tile size */ + + SCR_FIELDX = new_scr_fieldx; + SCR_FIELDY = new_scr_fieldy; + + // printf("::: new_scr_fieldx != SCR_FIELDX ...\n"); + } + +#if 0 + if (new_tilesize_var != TILESIZE_VAR && + gfx_game_mode == GAME_MODE_PLAYING) + { + /* doing this outside GAME_MODE_PLAYING would give wrong playfield size */ + + TILESIZE_VAR = new_tilesize_var; + + init_gfx_buffers = TRUE; + + // printf("::: tilesize: init_gfx_buffers\n"); + } +#endif + + if (new_sx != SX || new_sy != SY || - vp_playfield->x != REAL_SX || - vp_playfield->y != REAL_SY || + new_sxsize != SXSIZE || + new_sysize != SYSIZE || + new_real_sx != REAL_SX || + new_real_sy != REAL_SY || + new_full_sxsize != FULL_SXSIZE || + new_full_sysize != FULL_SYSIZE || + new_tilesize_var != TILESIZE_VAR || vp_door_1->x != *door_1_x || vp_door_1->y != *door_1_y || vp_door_2->x != *door_2_x || vp_door_2->y != *door_2_y) { - SCR_FIELDX = new_scr_fieldx; - SCR_FIELDY = new_scr_fieldy; SX = new_sx; SY = new_sy; - REAL_SX = vp_playfield->x; - REAL_SY = vp_playfield->y; + SXSIZE = new_sxsize; + SYSIZE = new_sysize; + REAL_SX = new_real_sx; + REAL_SY = new_real_sy; + FULL_SXSIZE = new_full_sxsize; + FULL_SYSIZE = new_full_sysize; + TILESIZE_VAR = new_tilesize_var; + +#if 0 + printf("::: %d, %d, %d [%d]\n", + SCR_FIELDX, SCR_FIELDY, TILESIZE_VAR, + setup.small_game_graphics); +#endif *door_1_x = vp_door_1->x; *door_1_y = vp_door_1->y; *door_2_x = vp_door_2->x; *door_2_y = vp_door_2->y; +#if 1 + init_gfx_buffers = TRUE; + + // printf("::: viewports: init_gfx_buffers\n"); +#else InitGfxBuffers(); +#endif if (gfx_game_mode == GAME_MODE_MAIN) { +#if 1 + init_gadgets_and_toons = TRUE; + + // printf("::: viewports: init_gadgets_and_toons\n"); +#else InitGadgets(); InitToons(); +#endif } } + + if (init_gfx_buffers) + { + // printf("::: init_gfx_buffers\n"); + + SCR_FIELDX = new_scr_fieldx_buffers; + SCR_FIELDY = new_scr_fieldy_buffers; + + InitGfxBuffers(); + + SCR_FIELDX = new_scr_fieldx; + SCR_FIELDY = new_scr_fieldy; + } + + if (init_video_buffer) + { + // printf("::: init_video_buffer\n"); + + InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen); + + SetDrawDeactivationMask(REDRAW_NONE); + SetDrawBackgroundMask(REDRAW_FIELD); + } + + if (init_gadgets_and_toons) + { + // printf("::: init_gadgets_and_toons\n"); + + InitGadgets(); + InitToons(); + } + +#if 0 + printf("::: %d, %d / %d, %d [%d]\n", VX, VY, EX, EY, game_status); +#endif }