#include "libgame/libgame.h"
#include "tools.h"
+#include "init.h"
#include "game.h"
#include "events.h"
#include "cartoons.h"
{
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;
BY2 = SCR_FIELDY;
redraw_x1 = 1;
redraw_y1 = 1;
+#endif
+#endif
drawto_field = fieldbuffer;
}
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
}
}
+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 dx_var = dx * TILESIZE_VAR / TILESIZE;
+ int dy_var = dy * TILESIZE_VAR / TILESIZE;
+ int 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
+
+ ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx_var;
+ ffy = (scroll_y - SBY_Upper) * TILEY_VAR + dy_var;
+
+ if (EVEN(SCR_FIELDX))
+ {
+ if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + TILEX_VAR)
+ fx += dx_var - MIN(ffx, TILEX_VAR / 2) + TILEX_VAR;
+ else
+ fx += (dx_var > 0 ? TILEX_VAR : 0);
+ }
+ else
+ {
+ fx += dx_var;
+ }
+
+ if (EVEN(SCR_FIELDY))
+ {
+ if (ffy < SBY_Lower * TILEY_VAR + TILEY_VAR / 2 + TILEY_VAR)
+ fy += dy_var - MIN(ffy, TILEY_VAR / 2) + TILEY_VAR;
+ else
+ fy += (dy_var > 0 ? TILEY_VAR : 0);
+ }
+ else
+ {
+ fy += dy_var;
+ }
+
+#if 0
+ printf("::: (%d, %d) [(%d / %d, %d / %d)] => %d, %d\n",
+ scroll_x, scroll_y,
+ SBX_Left, SBX_Right,
+ SBY_Upper, SBY_Lower,
+ fx, fy);
+#endif
+
+ 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;
if (redraw_mask & REDRAW_TILES && redraw_tiles > REDRAWTILES_THRESHOLD)
redraw_mask |= REDRAW_FIELD;
+#if 0
+ // never redraw single tiles, always redraw the whole field
+ // (redrawing single tiles up to a certain threshold was faster on old,
+ // now legacy graphics, but slows things down on modern graphics now)
+ // UPDATE: this is now globally defined by value of REDRAWTILES_THRESHOLD
+ if (redraw_mask & REDRAW_TILES)
+ redraw_mask |= REDRAW_FIELD;
+#endif
+
+#if 0
+ /* !!! TEST ONLY !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+ /* (force full redraw) */
+ if (game_status == GAME_MODE_PLAYING)
+ redraw_mask |= REDRAW_FIELD;
+#endif
+
if (redraw_mask & REDRAW_FIELD)
redraw_mask &= ~REDRAW_TILES;
if (redraw_mask == REDRAW_NONE)
return;
+#if 0
+ printf("::: ");
+ if (redraw_mask & REDRAW_ALL)
+ printf("[REDRAW_ALL]");
+ if (redraw_mask & REDRAW_FIELD)
+ printf("[REDRAW_FIELD]");
+ if (redraw_mask & REDRAW_TILES)
+ printf("[REDRAW_TILES]");
+ if (redraw_mask & REDRAW_DOOR_1)
+ printf("[REDRAW_DOOR_1]");
+ if (redraw_mask & REDRAW_DOOR_2)
+ printf("[REDRAW_DOOR_2]");
+ if (redraw_mask & REDRAW_FROM_BACKBUFFER)
+ printf("[REDRAW_FROM_BACKBUFFER]");
+ printf(" [%d]\n", FrameCounter);
+#endif
+
if (redraw_mask & REDRAW_TILES &&
game_status == GAME_MODE_PLAYING &&
border.draw_masked[GAME_MODE_PLAYING])
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)
if (redraw_mask & REDRAW_FIELD)
{
+#if 0
+ printf("::: REDRAW_FIELD\n");
+#endif
+
if (game_status != GAME_MODE_PLAYING ||
redraw_mask & REDRAW_FROM_BACKBUFFER)
{
}
else
{
+#if 1
+ BlitScreenToBitmap(window);
+#else
int fx = FX, fy = FY;
- 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 dx_var = dx * TILESIZE_VAR / TILESIZE;
+ int dy_var = dy * TILESIZE_VAR / TILESIZE;
+ int 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 !!! */
+
+ printf("::: %d, %d\n", scroll_x, scroll_y);
+
+ ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx_var;
+ ffy = (scroll_y - SBY_Upper) * TILEY_VAR + dy_var;
+
+ if (EVEN(SCR_FIELDX))
{
- fx += (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0);
- fy += (ScreenMovDir & (MV_UP | MV_DOWN) ? ScreenGfxPos : 0);
+ if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + TILEX_VAR)
+ fx += dx_var - MIN(ffx, TILEX_VAR / 2) + TILEX_VAR;
+ else
+ fx += (dx > 0 ? TILEX_VAR : 0);
}
-
- if (setup.soft_scrolling ||
- ABS(ScreenMovPos) + ScrollStepSize == TILEX ||
- ABS(ScreenMovPos) == ScrollStepSize ||
- redraw_tiles > REDRAWTILES_THRESHOLD)
+ else
{
- 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);
- }
+ fx += dx;
+ }
- BlitBitmap(backbuffer, window,
- REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
- REAL_SX, REAL_SY);
- }
+ if (EVEN(SCR_FIELDY))
+ {
+ if (ffy < SBY_Lower * TILEY_VAR + TILEY_VAR / 2 + TILEY_VAR)
+ fy += dy_var - MIN(ffy, TILEY_VAR / 2) + TILEY_VAR;
else
+ fy += (dy > 0 ? TILEY_VAR : 0);
+ }
+ else
+ {
+ fy += dy;
+ }
+
+ if (border.draw_masked[GAME_MODE_PLAYING])
+ {
+ if (buffer != backbuffer)
{
- BlitBitmap(buffer, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
+ /* copy playfield buffer to backbuffer to add masked border */
+ BlitBitmap(buffer, backbuffer, fx, fy, SXSIZE, SYSIZE, SX, SY);
+ DrawMaskedBorder(REDRAW_FIELD);
}
+ BlitBitmap(backbuffer, window,
+ REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
+ REAL_SX, REAL_SY);
+ }
+ else
+ {
+ BlitBitmap(buffer, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
+ }
+#endif
+
#if 0
#ifdef DEBUG
- printf("redrawing all (ScreenGfxPos == %d) because %s\n",
- ScreenGfxPos,
- (setup.soft_scrolling ?
- "setup.soft_scrolling" :
- ABS(ScreenGfxPos) + ScrollStepSize == TILEX ?
- "ABS(ScreenGfxPos) + ScrollStepSize == TILEX" :
- ABS(ScreenGfxPos) == ScrollStepSize ?
- "ABS(ScreenGfxPos) == ScrollStepSize" :
- "redraw_tiles > REDRAWTILES_THRESHOLD"));
+ printf("redrawing all (ScreenGfxPos == %d) because %s\n",
+ ScreenGfxPos,
+ (setup.soft_scrolling ?
+ "setup.soft_scrolling" :
+ ABS(ScreenGfxPos) + ScrollStepSize == TILEX ?
+ "ABS(ScreenGfxPos) + ScrollStepSize == TILEX" :
+ ABS(ScreenGfxPos) == ScrollStepSize ?
+ "ABS(ScreenGfxPos) == ScrollStepSize" :
+ "redraw_tiles > REDRAWTILES_THRESHOLD"));
#endif
#endif
- }
}
redraw_mask &= ~REDRAW_MAIN;
if (redraw_mask & REDRAW_TILES)
{
+#if 0
+ 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 dx_var = dx * TILESIZE_VAR / TILESIZE;
+ int dy_var = dy * TILESIZE_VAR / TILESIZE;
+ int ffx, ffy;
+ int fx = FX, fy = FY;
+
+ int scr_fieldx = SCR_FIELDX + (EVEN(SCR_FIELDX) ? 2 : 0);
+ int scr_fieldy = SCR_FIELDY + (EVEN(SCR_FIELDY) ? 2 : 0);
+
+ ffx = (scroll_x - SBX_Left) * TILEX_VAR + dx_var;
+ ffy = (scroll_y - SBY_Upper) * TILEY_VAR + dy_var;
+
+ if (EVEN(SCR_FIELDX))
+ {
+ if (ffx < SBX_Right * TILEX_VAR + TILEX_VAR / 2 + TILEX_VAR)
+ {
+ fx += dx_var - MIN(ffx, TILEX_VAR / 2) + TILEX_VAR;
+
+ if (fx % TILEX_VAR)
+ sx -= TILEX_VAR / 2;
+ else
+ sx -= TILEX_VAR;
+ }
+ else
+ {
+ fx += (dx_var > 0 ? TILEX_VAR : 0);
+ }
+ }
+
+ if (EVEN(SCR_FIELDY))
+ {
+ if (ffy < SBY_Lower * TILEY_VAR + TILEY_VAR / 2 + TILEY_VAR)
+ {
+ fy += dy_var - MIN(ffy, TILEY_VAR / 2) + TILEY_VAR;
+
+ if (fy % TILEY_VAR)
+ sy -= TILEY_VAR / 2;
+ else
+ sy -= TILEY_VAR;
+ }
+ else
+ {
+ fy += (dy_var > 0 ? TILEY_VAR : 0);
+ }
+ }
+
+#if 0
+ printf("::: %d, %d, %d, %d\n", sx, sy, SCR_FIELDX, SCR_FIELDY);
+#endif
+
+ 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 */
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);
}
ClearRectangleOnBackground(backbuffer, x, y, width, height);
#endif
+#if 1
+ /* (this only works for the current arrangement of playfield and panels) */
+ if (x < gfx.dx)
+ redraw_mask |= REDRAW_FIELD;
+ else if (y < gfx.vy)
+ redraw_mask |= REDRAW_DOOR_1;
+ else
+ redraw_mask |= REDRAW_DOOR_2;
+#else
+ /* (this is just wrong (when drawing to one of the two door panel areas)) */
redraw_mask |= REDRAW_FIELD;
+#endif
}
void DrawBackgroundForFont(int x, int y, int width, int height, int font_nr)
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
{
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;
*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
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 */
}
#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);
}
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);
}
}
#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);
}
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);
}
#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);
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)
{
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);
{
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)
{
{
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)
{
(e) == EL_QUICKSAND_EMPTYING || \
(e) == EL_QUICKSAND_FAST_EMPTYING))
-static void DrawLevelFieldCrumbledSandExtBlitInner(int x, int y, int dx, int dy,
- int graphic)
+static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy,
+ int graphic)
{
Bitmap *src_bitmap;
int src_x, src_y;
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);
BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy);
+#endif
}
-static void DrawLevelFieldCrumbledSandExtBlit(int x, int y,
- int graphic, int frame, int dir)
+static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
+ int dir)
{
Bitmap *src_bitmap;
int src_x, src_y;
/* draw simple, sloppy, non-corner-accurate crumbled border */
-#if 0
+#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);
}
#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) ||
/* correct corners of crumbled border, if needed */
-#if 0
+#if 1
for (i = -1; i <= 1; i+=2)
{
int xx = x + (dir == 0 || dir == 3 ? i : 0);
int element = (IN_LEV_FIELD(xx, yy) ? TILE_GFX_ELEMENT(xx, yy) :
BorderElement);
- /* ... */
-
/* check if neighbour field is of same crumble type */
if (IS_CRUMBLED_TILE(xx, yy, element) &&
graphic_info[graphic].class ==
{
/* 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);
+
width = crumbled_border_size;
height = crumbled_border_size;
- cx = (dir == 2 ? TILEX - crumbled_border_size : 0);
- cy = (i == 1 ? TILEX - crumbled_border_size : 0);
- bx = cx;
- by = (i == 1 ? crumbled_border_size :
- TILEY - 2 * crumbled_border_size);
- BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
- width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy);
- }
- }
-#else
- if (dir == 1 || dir == 2) /* left or right crumbled border */
- {
+ if (dir == 1 || dir == 2)
+ {
+ cx = c1;
+ cy = c2;
+ bx = cx;
+ by = b1;
+ }
+ else
+ {
+ cx = c2;
+ cy = c1;
+ bx = b1;
+ 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
+ if (dir == 1 || dir == 2) /* left or right crumbled border */
+ {
for (i = -1; i <= 1; i+=2)
{
int xx = x;
width = crumbled_border_size;
height = crumbled_border_size;
cx = (dir == 2 ? TILEX - crumbled_border_size : 0);
- cy = (i == 1 ? TILEX - crumbled_border_size : 0);
+ cy = (i == 1 ? TILEY - crumbled_border_size : 0);
bx = cx;
by = (i == 1 ? crumbled_border_size :
TILEY - 2 * crumbled_border_size);
cx = (i == 1 ? TILEX - crumbled_border_size : 0);
cy = (dir == 3 ? TILEY - crumbled_border_size : 0);
bx = (i == 1 ? crumbled_border_size :
- TILEY - 2 * crumbled_border_size);
+ TILEX - 2 * crumbled_border_size);
by = cy;
BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
#endif
}
-static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
+static void DrawLevelFieldCrumbledExt(int x, int y, int graphic, int frame)
{
int sx = SCREENX(x), sy = SCREENY(y);
int element;
continue;
#endif
- DrawLevelFieldCrumbledSandExtBlit(x, y, graphic, frame, i);
+ DrawLevelFieldCrumbledBorders(x, y, graphic, frame, i);
}
- if ((graphic_info[graphic].style & STYLE_WITH_INNER_CORNERS) &&
+ if ((graphic_info[graphic].style & STYLE_INNER_CORNERS) &&
graphic_info[graphic].anim_frames == 2)
{
for (i = 0; i < 4; i++)
int dx = (i & 1 ? +1 : -1);
int dy = (i & 2 ? +1 : -1);
- DrawLevelFieldCrumbledSandExtBlitInner(x, y, dx, dy, graphic);
+ DrawLevelFieldCrumbledInnerCorners(x, y, dx, dy, graphic);
}
}
graphic = el_act2crm(element, ACTION_DEFAULT);
- DrawLevelFieldCrumbledSandExtBlit(xx, yy, graphic, 0, 3 - i);
+ DrawLevelFieldCrumbledBorders(xx, yy, graphic, 0, 3 - i);
MarkTileDirty(sxx, syy);
}
}
}
-void DrawLevelFieldCrumbledSand(int x, int y)
+void DrawLevelFieldCrumbled(int x, int y)
{
int graphic;
GfxElement[x][y] != EL_UNDEFINED &&
GFX_CRUMBLED(GfxElement[x][y]))
{
- DrawLevelFieldCrumbledSandDigging(x, y, GfxDir[x][y], GfxFrame[x][y]);
+ DrawLevelFieldCrumbledDigging(x, y, GfxDir[x][y], GfxFrame[x][y]);
return;
}
graphic = el_act2crm(Feld[x][y], ACTION_DEFAULT);
#endif
- DrawLevelFieldCrumbledSandExt(x, y, graphic, 0);
+ DrawLevelFieldCrumbledExt(x, y, graphic, 0);
}
-void DrawLevelFieldCrumbledSandDigging(int x, int y, int direction,
- int step_frame)
+void DrawLevelFieldCrumbledDigging(int x, int y, int direction,
+ int step_frame)
{
int graphic1 = el_act_dir2img(GfxElement[x][y], ACTION_DIGGING, direction);
int graphic2 = el_act_dir2crm(GfxElement[x][y], ACTION_DIGGING, direction);
int sx = SCREENX(x), sy = SCREENY(y);
DrawGraphic(sx, sy, graphic1, frame1);
- DrawLevelFieldCrumbledSandExt(x, y, graphic2, frame2);
+ DrawLevelFieldCrumbledExt(x, y, graphic2, frame2);
}
-void DrawLevelFieldCrumbledSandNeighbours(int x, int y)
+void DrawLevelFieldCrumbledNeighbours(int x, int y)
{
int sx = SCREENX(x), sy = SCREENY(y);
static int xy[4][2] =
};
int i;
-#if 0
- int element = TILE_GFX_ELEMENT(x, y);
- int graphic = el_act2crm(element, ACTION_DEFAULT);
-
- if (graphic_info[graphic].style & STYLE_WITH_INNER_CORNERS)
- {
- int dx, dy;
-
- for (dy = -1; dy < 2; dy++)
- {
- for (dx = -1; dx < 2; dx++)
- {
- if (dx != 0 || dy != 0)
- {
- int xx = x + dx;
- int yy = y + dy;
- int sxx = sx + dx;
- int syy = sy + dy;
-
- if (!IN_LEV_FIELD(xx, yy) ||
- !IN_SCR_FIELD(sxx, syy) ||
- !GFX_CRUMBLED(Feld[xx][yy]) ||
- IS_MOVING(xx, yy))
- continue;
-
- DrawLevelField(xx, yy);
- }
- }
- }
- }
- else
- {
- for (i = 0; i < 4; i++)
- {
- int xx = x + xy[i][0];
- int yy = y + xy[i][1];
- int sxx = sx + xy[i][0];
- int syy = sy + xy[i][1];
-
- if (!IN_LEV_FIELD(xx, yy) ||
- !IN_SCR_FIELD(sxx, syy) ||
- !GFX_CRUMBLED(Feld[xx][yy]) ||
- IS_MOVING(xx, yy))
- continue;
-
- DrawLevelField(xx, yy);
- }
- }
-#else
for (i = 0; i < 4; i++)
{
int xx = x + xy[i][0];
DrawLevelField(xx, yy);
}
-#endif
}
static int getBorderElement(int x, int y)
void DrawScreenElement(int x, int y, int element)
{
DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, NO_MASKING);
- DrawLevelFieldCrumbledSand(LEVELX(x), LEVELY(y));
+ DrawLevelFieldCrumbled(LEVELX(x), LEVELY(y));
}
void DrawLevelElement(int x, int y, int element)
DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
}
-void DrawEnvelopeBackground(int envelope_nr, int startx, int starty,
- int x, int y, int xsize, int ysize, int font_nr)
+void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
+ int x, int y, int xsize, int ysize,
+ int tile_width, int tile_height)
{
- int font_width = getFontWidth(font_nr);
- int font_height = getFontHeight(font_nr);
- int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
Bitmap *src_bitmap;
int src_x, src_y;
- int dst_x = SX + startx + x * font_width;
- int dst_y = SY + starty + y * font_height;
+ int dst_x = startx + x * tile_width;
+ int dst_y = starty + y * tile_height;
int width = graphic_info[graphic].width;
int height = graphic_info[graphic].height;
- int inner_width = MAX(width - 2 * font_width, font_width);
- int inner_height = MAX(height - 2 * font_height, font_height);
- int inner_sx = (width >= 3 * font_width ? font_width : 0);
- int inner_sy = (height >= 3 * font_height ? font_height : 0);
+ int inner_width_raw = MAX(width - 2 * tile_width, tile_width);
+ int inner_height_raw = MAX(height - 2 * tile_height, tile_height);
+ int inner_width = inner_width_raw - (inner_width_raw % tile_width);
+ int inner_height = inner_height_raw - (inner_height_raw % tile_height);
+ int inner_sx = (width >= 3 * tile_width ? tile_width : 0);
+ int inner_sy = (height >= 3 * tile_height ? tile_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)
+ if (src_bitmap == NULL || width < tile_width || height < tile_height)
{
- ClearRectangle(drawto, dst_x, dst_y, font_width, font_height);
+ ClearRectangle(drawto, dst_x, dst_y, tile_width, tile_height);
return;
}
- src_x += (x == 0 ? 0 : x == xsize - 1 ? width - font_width :
- inner_sx + (x - 1) * font_width % inner_width);
- src_y += (y == 0 ? 0 : y == ysize - 1 ? height - font_height :
- inner_sy + (y - 1) * font_height % inner_height);
+ src_x += (x == 0 ? 0 : x == xsize - 1 ? width - tile_width :
+ inner_sx + (x - 1) * tile_width % inner_width);
+ src_y += (y == 0 ? 0 : y == ysize - 1 ? height - tile_height :
+ inner_sy + (y - 1) * tile_height % inner_height);
if (draw_masked)
{
SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc,
dst_x - src_x, dst_y - src_y);
- BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, font_width, font_height,
+ BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
dst_x, dst_y);
}
else
- BlitBitmap(src_bitmap, drawto, src_x, src_y, font_width, font_height,
+ BlitBitmap(src_bitmap, drawto, src_x, src_y, tile_width, tile_height,
dst_x, dst_y);
}
+void DrawEnvelopeBackground(int graphic, int startx, int starty,
+ int x, int y, int xsize, int ysize, int font_nr)
+{
+ int font_width = getFontWidth(font_nr);
+ int font_height = getFontHeight(font_nr);
+
+ DrawEnvelopeBackgroundTiles(graphic, startx, starty, x, y, xsize, ysize,
+ font_width, font_height);
+}
+
void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
{
int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
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;
+ unsigned int anim_delay = 0;
int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
int anim_delay_value = (no_delay ? 0 : frame_delay_value);
int font_nr = FONT_ENVELOPE_1 + envelope_nr;
{
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 sx = SX + (SXSIZE - xsize * font_width) / 2;
+ int sy = SY + (SYSIZE - ysize * font_height) / 2;
int xx, yy;
SetDrawtoField(DRAW_BUFFERED);
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
+#endif
SetDrawtoField(DRAW_BACKBUFFER);
- for (yy = 0; yy < ysize; yy++) for (xx = 0; xx < xsize; xx++)
- DrawEnvelopeBackground(envelope_nr, sx,sy, xx,yy, xsize, ysize, font_nr);
+ for (yy = 0; yy < ysize; yy++)
+ for (xx = 0; xx < xsize; xx++)
+ DrawEnvelopeBackground(graphic, sx, sy, xx, yy, xsize, ysize, font_nr);
#if 1
- DrawTextBuffer(SX + sx + font_width, SY + sy + font_height,
+ DrawTextBuffer(sx + font_width, 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
- DrawTextToTextArea(SX + sx + font_width, SY + sy + font_height,
+ DrawTextToTextArea(sx + font_width, sy + font_height,
level.envelope[envelope_nr].text, font_nr, max_xsize,
xsize - 2, ysize - 2, mask_mode);
#endif
BackToFront();
}
-void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
+static void setRequestPosition(int *x, int *y, boolean add_border_size)
{
- Bitmap *src_bitmap;
- int src_x, src_y;
- int graphic = el2preimg(element);
+ int border_size = request.border_size;
+ int sx_center = (request.x != -1 ? request.x : SX + SXSIZE / 2);
+ int sy_center = (request.y != -1 ? request.y : SY + SYSIZE / 2);
+ int sx = sx_center - request.width / 2;
+ int sy = sy_center - request.height / 2;
- getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
- BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize, dst_x,dst_y);
+ if (add_border_size)
+ {
+ sx += border_size;
+ sy += border_size;
+ }
+
+ *x = sx;
+ *y = sy;
}
-void DrawLevel()
+void DrawEnvelopeRequest(char *text)
{
- int x,y;
+ char *text_final = text;
+ char *text_door_style = NULL;
+ int graphic = IMG_BACKGROUND_REQUEST;
+ Bitmap *src_bitmap = graphic_info[graphic].bitmap;
+ int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
+ int font_nr = FONT_REQUEST;
+ int font_width = getFontWidth(font_nr);
+ int font_height = getFontHeight(font_nr);
+ int border_size = request.border_size;
+ int line_spacing = request.line_spacing;
+ int line_height = font_height + line_spacing;
+ int text_width = request.width - 2 * border_size;
+ int text_height = request.height - 2 * border_size;
+ int line_length = text_width / font_width;
+ int max_lines = text_height / line_height;
+ int width = request.width;
+ int height = request.height;
+ int tile_size = request.step_offset;
+ int x_steps = width / tile_size;
+ int y_steps = height / tile_size;
+ int sx, sy;
+ int i, x, y;
+
+ if (request.wrap_single_words)
+ {
+ char *src_text_ptr, *dst_text_ptr;
+
+ text_door_style = checked_malloc(2 * strlen(text) + 1);
+
+ src_text_ptr = text;
+ dst_text_ptr = text_door_style;
+
+ while (*src_text_ptr)
+ {
+ if (*src_text_ptr == ' ' ||
+ *src_text_ptr == '?' ||
+ *src_text_ptr == '!')
+ *dst_text_ptr++ = '\n';
-#if 1
- SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
- SetDrawBackgroundMask(REDRAW_FIELD);
-#else
- SetDrawBackgroundMask(REDRAW_NONE);
-#endif
+ if (*src_text_ptr != ' ')
+ *dst_text_ptr++ = *src_text_ptr;
- ClearField();
+ src_text_ptr++;
+ }
- for (x = BX1; x <= BX2; x++)
- for (y = BY1; y <= BY2; y++)
- DrawScreenField(x, y);
+ *dst_text_ptr = '\0';
- redraw_mask |= REDRAW_FIELD;
-}
+ text_final = text_door_style;
+ }
-void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
-{
- int x,y;
+ setRequestPosition(&sx, &sy, FALSE);
- for (x = 0; x < size_x; x++)
- for (y = 0; y < size_y; y++)
- DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
+ ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
- redraw_mask |= REDRAW_FIELD;
-}
+ for (y = 0; y < y_steps; y++)
+ for (x = 0; x < x_steps; x++)
+ DrawEnvelopeBackgroundTiles(graphic, sx, sy,
+ x, y, x_steps, y_steps,
+ tile_size, tile_size);
-static void DrawPreviewLevelExt(int from_x, int from_y)
-{
- boolean show_level_border = (BorderElement != EL_EMPTY);
- int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
- int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
- int tile_size = preview.tile_size;
- int preview_width = preview.xsize * tile_size;
- int preview_height = preview.ysize * tile_size;
- int real_preview_xsize = MIN(level_xsize, preview.xsize);
- int real_preview_ysize = MIN(level_ysize, preview.ysize);
- int dst_x = SX + ALIGNED_XPOS(preview.x, preview_width, preview.align);
- int dst_y = SY + ALIGNED_YPOS(preview.y, preview_height, preview.valign);
- int x, y;
+ DrawTextBuffer(sx + border_size, sy + border_size, text_final, font_nr,
+ line_length, -1, max_lines, line_spacing, mask_mode,
+ request.autowrap, request.centered, FALSE);
- DrawBackground(dst_x, dst_y, preview_width, preview_height);
+ for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+ RedrawGadget(tool_gadget[i]);
- dst_x += (preview_width - real_preview_xsize * tile_size) / 2;
- dst_y += (preview_height - real_preview_ysize * tile_size) / 2;
+ // store readily prepared envelope request for later use when animating
+ BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
- for (x = 0; x < real_preview_xsize; x++)
- {
- for (y = 0; y < real_preview_ysize; y++)
- {
- int lx = from_x + x + (show_level_border ? -1 : 0);
- int ly = from_y + y + (show_level_border ? -1 : 0);
- int element = (IN_LEV_FIELD(lx, ly) ? level.field[lx][ly] :
- getBorderElement(lx, ly));
+#if 0
+ // !!! TEST !!!
+ BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ BlitBitmap(bitmap_db_cross, backbuffer, sx, sy, width, height, sx, sy);
- DrawPreviewElement(dst_x + x * tile_size, dst_y + y * tile_size,
- element, tile_size);
- }
- }
+ redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+ BackToFront();
- redraw_mask |= REDRAW_MICROLEVEL;
-}
+ Delay(3000);
-#define MICROLABEL_EMPTY 0
-#define MICROLABEL_LEVEL_NAME 1
-#define MICROLABEL_LEVEL_AUTHOR_HEAD 2
-#define MICROLABEL_LEVEL_AUTHOR 3
-#define MICROLABEL_IMPORTED_FROM_HEAD 4
-#define MICROLABEL_IMPORTED_FROM 5
-#define MICROLABEL_IMPORTED_BY_HEAD 6
-#define MICROLABEL_IMPORTED_BY 7
+ BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
-static int getMaxTextLength(struct TextPosInfo *pos, int font_nr)
-{
- int max_text_width = SXSIZE;
- int font_width = getFontWidth(font_nr);
+ redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+ BackToFront();
- if (pos->align == ALIGN_CENTER)
- max_text_width = (pos->x < SXSIZE / 2 ? pos->x * 2 : (SXSIZE - pos->x) * 2);
- else if (pos->align == ALIGN_RIGHT)
- max_text_width = pos->x;
- else
- max_text_width = SXSIZE - pos->x;
+ Delay(1000);
+#endif
- return max_text_width / font_width;
+ if (text_door_style)
+ free(text_door_style);
}
-static void DrawPreviewLevelLabelExt(int mode)
-{
- struct TextPosInfo *pos = &menu.main.text.level_info_2;
- char label_text[MAX_OUTPUT_LINESIZE + 1];
- int max_len_label_text;
#if 1
- int font_nr = pos->font;
- int i;
- if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
- mode == MICROLABEL_IMPORTED_FROM_HEAD ||
- mode == MICROLABEL_IMPORTED_BY_HEAD)
- font_nr = pos->font_alt;
+void AnimateEnvelopeRequest(int anim_mode, int action)
+{
+ int graphic = IMG_BACKGROUND_REQUEST;
+ boolean draw_masked = graphic_info[graphic].draw_masked;
+#if 1
+ int delay_value_normal = request.step_delay;
+ int delay_value_fast = delay_value_normal / 2;
#else
- int font_nr = FONT_TEXT_2;
- int i;
-
- if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
- mode == MICROLABEL_IMPORTED_FROM_HEAD ||
- mode == MICROLABEL_IMPORTED_BY_HEAD)
- font_nr = FONT_TEXT_3;
+ int delay_value_normal = GameFrameDelay;
+ int delay_value_fast = FfwdFrameDelay;
#endif
+ boolean ffwd_delay = (tape.playing && tape.fast_forward);
+ boolean no_delay = (tape.warp_forward);
+ int delay_value = (ffwd_delay ? delay_value_fast : delay_value_normal);
+ int anim_delay_value = (no_delay ? 0 : delay_value + 500 * 0);
+ unsigned int anim_delay = 0;
+
+ int width = request.width;
+ int height = request.height;
+ int tile_size = request.step_offset;
+ int max_xsize = width / tile_size;
+ int max_ysize = height / tile_size;
+ int max_xsize_inner = max_xsize - 2;
+ int max_ysize_inner = max_ysize - 2;
+
+ int xstart = (anim_mode & ANIM_VERTICAL ? max_xsize_inner : 0);
+ int ystart = (anim_mode & ANIM_HORIZONTAL ? max_ysize_inner : 0);
+ int xend = max_xsize_inner;
+ int yend = (anim_mode != ANIM_DEFAULT ? max_ysize_inner : 0);
+ int xstep = (xstart < xend ? 1 : 0);
+ int ystep = (ystart < yend || xstep == 0 ? 1 : 0);
+ int x, y;
+
+ 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_center = (request.x != -1 ? request.x : SX + SXSIZE / 2);
+ int sy_center = (request.y != -1 ? request.y : SY + SYSIZE / 2);
+ int src_x = sx_center - width / 2;
+ int src_y = sy_center - height / 2;
+ int dst_x = sx_center - xsize * tile_size / 2;
+ int dst_y = sy_center - ysize * tile_size / 2;
+ int xsize_size_left = (xsize - 1) * tile_size;
+ int ysize_size_top = (ysize - 1) * tile_size;
+ int max_xsize_pos = (max_xsize - 1) * tile_size;
+ int max_ysize_pos = (max_ysize - 1) * tile_size;
+ int xx, yy;
+
+ BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
#if 1
- max_len_label_text = getMaxTextLength(pos, font_nr);
+ for (yy = 0; yy < 2; yy++)
+ {
+ for (xx = 0; xx < 2; xx++)
+ {
+ int src_xx = src_x + xx * max_xsize_pos;
+ int src_yy = src_y + yy * max_ysize_pos;
+ int dst_xx = dst_x + xx * xsize_size_left;
+ int dst_yy = dst_y + yy * ysize_size_top;
+ int xx_size = (xx ? tile_size : xsize_size_left);
+ int yy_size = (yy ? tile_size : ysize_size_top);
+
+ if (draw_masked)
+ BlitBitmapMasked(bitmap_db_cross, backbuffer,
+ src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
+ else
+ BlitBitmap(bitmap_db_cross, backbuffer,
+ src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
+ }
+ }
#else
- max_len_label_text = SXSIZE / getFontWidth(font_nr);
+ BlitBitmap(bitmap_db_cross, backbuffer,
+ src_x, src_y,
+ xsize_size_left, ysize_size_top,
+ dst_x, dst_y);
+ BlitBitmap(bitmap_db_cross, backbuffer,
+ src_x + max_xsize_pos, src_y,
+ tile_size, ysize_size_top,
+ dst_x + xsize_size_left, dst_y);
+ BlitBitmap(bitmap_db_cross, backbuffer,
+ src_x, src_y + max_ysize_pos,
+ xsize_size_left, tile_size,
+ dst_x, dst_y + ysize_size_top);
+ BlitBitmap(bitmap_db_cross, backbuffer,
+ src_x + max_xsize_pos, src_y + max_ysize_pos,
+ tile_size, tile_size,
+ dst_x + xsize_size_left, dst_y + ysize_size_top);
#endif
#if 1
- if (pos->size != -1)
- max_len_label_text = pos->size;
+ redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+ // redraw_mask |= REDRAW_ALL | REDRAW_FROM_BACKBUFFER;
+#else
+ redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
#endif
- for (i = 0; i < max_len_label_text; i++)
- label_text[i] = ' ';
- label_text[max_len_label_text] = '\0';
-
- if (strlen(label_text) > 0)
- {
#if 1
- DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
+ DoAnimation();
+ BackToFront();
#else
- int lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
- int lypos = MICROLABEL2_YPOS;
-
- DrawText(lxpos, lypos, label_text, font_nr);
+ BackToFront();
#endif
+
+ WaitUntilDelayReached(&anim_delay, anim_delay_value / 2);
}
+}
- strncpy(label_text,
- (mode == MICROLABEL_LEVEL_NAME ? level.name :
- mode == MICROLABEL_LEVEL_AUTHOR_HEAD ? "created by" :
- mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
- mode == MICROLABEL_IMPORTED_FROM_HEAD ? "imported from" :
- mode == MICROLABEL_IMPORTED_FROM ? leveldir_current->imported_from :
- mode == MICROLABEL_IMPORTED_BY_HEAD ? "imported by" :
- mode == MICROLABEL_IMPORTED_BY ? leveldir_current->imported_by :""),
- max_len_label_text);
- label_text[max_len_label_text] = '\0';
+#else
- if (strlen(label_text) > 0)
- {
+void AnimateEnvelopeRequest(char *text, int anim_mode, int action)
+{
+#if 0
+ int envelope_nr = 0;
+#endif
#if 1
- DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
+ int graphic = IMG_BACKGROUND_REQUEST;
#else
- int lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
- int lypos = MICROLABEL2_YPOS;
-
- DrawText(lxpos, lypos, label_text, font_nr);
+ int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
#endif
- }
+ 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 int anim_delay = 0;
+ int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
+ int anim_delay_value = (no_delay ? 0 : frame_delay_value + 500 * 0);
+#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);
+ int line_spacing = 2 * 1;
+#if 1
- redraw_mask |= REDRAW_MICROLEVEL;
-}
+#if 1
+ int max_xsize = DXSIZE / font_width;
+ // int max_ysize = DYSIZE / font_height;
+ int max_ysize = DYSIZE / (font_height + line_spacing);
+#else
+ int max_xsize = 7; /* tools.c: MAX_REQUEST_LINE_FONT1_LEN == 7 */
+ int max_ysize = 13; /* tools.c: MAX_REQUEST_LINES == 13 */
+#endif
-void DrawPreviewLevel(boolean restart)
-{
- static unsigned long scroll_delay = 0;
- static unsigned long label_delay = 0;
- static int from_x, from_y, scroll_direction;
- static int label_state, label_counter;
- unsigned long scroll_delay_value = preview.step_delay;
- boolean show_level_border = (BorderElement != EL_EMPTY);
- int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
- int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
- int last_game_status = game_status; /* save current game status */
-
-#if 0
- /* force PREVIEW font on preview level */
- game_status = GAME_MODE_PSEUDO_PREVIEW;
+#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 (restart)
+#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 */
{
- from_x = 0;
- from_y = 0;
+ 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);
- if (preview.anim_mode == ANIM_CENTERED)
+ 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 */
{
- if (level_xsize > preview.xsize)
- from_x = (level_xsize - preview.xsize) / 2;
- if (level_ysize > preview.ysize)
- from_y = (level_ysize - preview.ysize) / 2;
+ max_xsize = 10; /* tools.c: MAX_REQUEST_LINE_FONT2_LEN == 10 */
+ font_nr = FONT_TEXT_1;
+
+ break;
}
+ }
+#endif
+#endif
- from_x += preview.xoffset;
- from_y += preview.yoffset;
+#if 1
+ for (text_ptr = text_copy; *text_ptr; text_ptr++)
+ if (*text_ptr == ' ')
+ *text_ptr = '\n';
+#endif
- scroll_direction = MV_RIGHT;
- label_state = 1;
- label_counter = 0;
+#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
- DrawPreviewLevelExt(from_x, from_y);
- DrawPreviewLevelLabelExt(label_state);
+ 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 = SX + (SXSIZE - xsize * font_width) / 2;
+ // int sy = SX + (SYSIZE - ysize * font_height) / 2;
+ int sy = SY + (SYSIZE - ysize * (font_height + line_spacing)) / 2;
+ int xx, yy;
- /* initialize delay counters */
- DelayReached(&scroll_delay, 0);
- DelayReached(&label_delay, 0);
+#if 1
+ BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+#else
+ SetDrawtoField(DRAW_BUFFERED);
- if (leveldir_current->name)
- {
- struct TextPosInfo *pos = &menu.main.text.level_info_1;
- char label_text[MAX_OUTPUT_LINESIZE + 1];
#if 1
- int font_nr = pos->font;
+ BlitScreenToBitmap(backbuffer);
#else
- int font_nr = FONT_TEXT_1;
+ BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
#endif
+
+ SetDrawtoField(DRAW_BACKBUFFER);
+#endif
+
+ for (yy = 0; yy < ysize; yy++)
+ for (xx = 0; xx < xsize; xx++)
+ DrawEnvelopeBackgroundTiles(graphic, sx, sy, xx, yy, xsize, ysize,
+ getFontWidth(font_nr),
+ getFontHeight(font_nr) + line_spacing);
+
#if 1
- int max_len_label_text = getMaxTextLength(pos, font_nr);
+
+#if 1
+ DrawTextBuffer(sx + font_width, sy + font_height + 8,
+ text_copy, font_nr, max_xsize,
+ xsize - 2, ysize - 2, line_spacing, mask_mode,
+ FALSE, TRUE, FALSE);
#else
- int max_len_label_text = SXSIZE / getFontWidth(font_nr);
+ DrawTextBuffer(sx + font_width, 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
-#if 0
- int text_width;
- int lxpos, lypos;
+
+#else
+ DrawTextToTextArea(sx + font_width, 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 (pos->size != -1)
- max_len_label_text = pos->size;
+ /*
+ 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 + font_width,
+ sy + font_height * (1 + 13));
+ */
+ if ((ysize - 2) > 13)
+ BlitBitmap(bitmap_db_door, drawto,
+ DOOR_GFX_PAGEX1 + (DXSIZE - (xsize - 2) * font_width) / 2,
+ DOOR_GFX_PAGEY1 + 11 * (font_height + line_spacing * 0),
+ (xsize - 2) * font_width,
+ (ysize - 2 - 13) * (font_height + line_spacing),
+ sx + font_width,
+ sy + (font_height + line_spacing) * (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 + font_width,
+ sy + font_height * (1 + 13));
#endif
- strncpy(label_text, leveldir_current->name, max_len_label_text);
- label_text[max_len_label_text] = '\0';
+#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
- DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
+ DoAnimation();
+ BackToFront();
#else
- lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
- lypos = SY + MICROLABEL1_YPOS;
+ BackToFront();
+#endif
- DrawText(lxpos, lypos, label_text, font_nr);
+ WaitUntilDelayReached(&anim_delay, anim_delay_value / 2);
+ }
+
+#if 1
+ free(text_copy);
#endif
- }
+}
- game_status = last_game_status; /* restore current game status */
+#endif
- return;
- }
+void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
+{
+#if 1
+ int last_game_status = game_status; /* save current game status */
+ // int last_draw_background_mask = gfx.draw_background_mask;
+#endif
+#if 1
+ int graphic = IMG_BACKGROUND_REQUEST;
+ int sound_opening = SND_REQUEST_OPENING;
+ int sound_closing = SND_REQUEST_CLOSING;
+#else
+ int envelope_nr = 0;
+ 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];
+#endif
+#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 0
+ char *text_copy = getStringCopy(text);
+ char *text_ptr;
- /* scroll preview level, if needed */
- if (preview.anim_mode != ANIM_NONE &&
- (level_xsize > preview.xsize || level_ysize > preview.ysize) &&
- DelayReached(&scroll_delay, scroll_delay_value))
+ for (text_ptr = text_copy; *text_ptr; text_ptr++)
+ if (*text_ptr == ' ')
+ *text_ptr = '\n';
+#endif
+
+#if 1
+ if (game_status == GAME_MODE_PLAYING)
{
- switch (scroll_direction)
+ 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
{
- case MV_LEFT:
- if (from_x > 0)
- {
- from_x -= preview.step_offset;
- from_x = (from_x < 0 ? 0 : from_x);
- }
- else
- scroll_direction = MV_UP;
- break;
+ BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
+ }
+ }
- case MV_RIGHT:
- if (from_x < level_xsize - preview.xsize)
- {
- from_x += preview.step_offset;
- from_x = (from_x > level_xsize - preview.xsize ?
- level_xsize - preview.xsize : from_x);
- }
- else
- scroll_direction = MV_DOWN;
- break;
+ SetDrawtoField(DRAW_BACKBUFFER);
- case MV_UP:
- if (from_y > 0)
- {
- from_y -= preview.step_offset;
- from_y = (from_y < 0 ? 0 : from_y);
- }
- else
- scroll_direction = MV_RIGHT;
- break;
+ // SetDrawBackgroundMask(REDRAW_NONE);
- case MV_DOWN:
- if (from_y < level_ysize - preview.ysize)
- {
- from_y += preview.step_offset;
- from_y = (from_y > level_ysize - preview.ysize ?
- level_ysize - preview.ysize : from_y);
- }
- else
- scroll_direction = MV_LEFT;
- break;
+ if (action == ACTION_OPENING)
+ {
+ BlitBitmap(backbuffer, bitmap_db_store, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
- default:
- break;
- }
+#if 1
+ if (req_state & REQ_ASK)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
+ }
+ else if (req_state & REQ_CONFIRM)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
+ }
+ else if (req_state & REQ_PLAYER)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
+ }
+#endif
+
+#if 1
+ DrawEnvelopeRequest(text);
+#else
+ DrawEnvelopeRequest(text_copy);
+#endif
- DrawPreviewLevelExt(from_x, from_y);
+ if (game_status != GAME_MODE_MAIN)
+ InitAnimation();
}
- /* !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!! */
- /* redraw micro level label, if needed */
- if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
- !strEqual(level.author, ANONYMOUS_NAME) &&
- !strEqual(level.author, leveldir_current->name) &&
- DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
+ /* force DOOR font inside door area */
+ game_status = GAME_MODE_PSEUDO_DOOR;
+#endif
+
+ game.envelope_active = TRUE; /* needed for RedrawPlayfield() events */
+
+ if (action == ACTION_OPENING)
{
- int max_label_counter = 23;
+ PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
- if (leveldir_current->imported_from != NULL &&
- strlen(leveldir_current->imported_from) > 0)
- max_label_counter += 14;
- if (leveldir_current->imported_by != NULL &&
- strlen(leveldir_current->imported_by) > 0)
- max_label_counter += 14;
+ if (anim_mode == ANIM_DEFAULT)
+ AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
- label_counter = (label_counter + 1) % max_label_counter;
- label_state = (label_counter >= 0 && label_counter <= 7 ?
- MICROLABEL_LEVEL_NAME :
- label_counter >= 9 && label_counter <= 12 ?
- MICROLABEL_LEVEL_AUTHOR_HEAD :
- label_counter >= 14 && label_counter <= 21 ?
- MICROLABEL_LEVEL_AUTHOR :
- label_counter >= 23 && label_counter <= 26 ?
- MICROLABEL_IMPORTED_FROM_HEAD :
- label_counter >= 28 && label_counter <= 35 ?
- MICROLABEL_IMPORTED_FROM :
- label_counter >= 37 && label_counter <= 40 ?
- MICROLABEL_IMPORTED_BY_HEAD :
- label_counter >= 42 && label_counter <= 49 ?
- MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
+ AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
- if (leveldir_current->imported_from == NULL &&
- (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
- label_state == MICROLABEL_IMPORTED_FROM))
- label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
- MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
+#if 0
+ if (tape.playing)
+ Delay(wait_delay_value);
+ else
+ WaitForEventToContinue();
+#endif
+ }
+ else
+ {
+ PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
- DrawPreviewLevelLabelExt(label_state);
+ if (anim_mode != ANIM_NONE)
+ AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
+
+ if (anim_mode == ANIM_DEFAULT)
+ AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
}
- game_status = last_game_status; /* restore current game status */
-}
+ game.envelope_active = FALSE;
-inline void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
- int graphic, int sync_frame, int mask_mode)
-{
- int frame = getGraphicAnimationFrame(graphic, sync_frame);
+#if 1
+ // game_status = last_game_status; /* restore current game status */
- if (mask_mode == USE_MASKING)
- DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
- else
- DrawGraphicExt(dst_bitmap, x, y, graphic, frame);
-}
+ if (action == ACTION_CLOSING)
+ {
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
-inline void DrawGraphicAnimation(int x, int y, int graphic)
-{
- int lx = LEVELX(x), ly = LEVELY(y);
+ BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ }
+#else
+ SetDrawtoField(DRAW_BUFFERED);
+#endif
- if (!IN_SCR_FIELD(x, y))
- return;
+ // SetDrawBackgroundMask(last_draw_background_mask);
- DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
- graphic, GfxFrame[lx][ly], NO_MASKING);
- MarkTileDirty(x, y);
-}
+#if 1
+ redraw_mask = REDRAW_FIELD;
+ // redraw_mask |= REDRAW_ALL;
+#else
+ redraw_mask |= REDRAW_FIELD;
+#endif
-void DrawLevelGraphicAnimation(int x, int y, int graphic)
-{
- DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
-}
+#if 1
+ if (game_status == GAME_MODE_MAIN)
+ DoAnimation();
-void DrawLevelElementAnimation(int x, int y, int element)
-{
- int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
+ BackToFront();
- DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+ /* (important: after "BackToFront()", but before "SetDrawtoField()") */
+ game_status = last_game_status; /* restore current game status */
+
+#if 1
+ if (action == ACTION_CLOSING &&
+ game_status == GAME_MODE_PLAYING &&
+ level.game_engine_type == GAME_ENGINE_TYPE_RND)
+ SetDrawtoField(DRAW_BUFFERED);
+#else
+ if (game_status == GAME_MODE_PLAYING &&
+ level.game_engine_type == GAME_ENGINE_TYPE_RND)
+ SetDrawtoField(DRAW_BUFFERED);
+#endif
+
+#else
+ BackToFront();
+#endif
+
+#if 0
+ free(text_copy);
+#endif
}
-inline void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
+void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
{
- int sx = SCREENX(x), sy = SCREENY(y);
-
- if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
- return;
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+ int graphic = el2preimg(element);
- if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
- return;
+ getSizedGraphicSource(graphic, 0, tilesize, &src_bitmap, &src_x, &src_y);
+ BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize, dst_x,dst_y);
+}
- DrawGraphicAnimation(sx, sy, graphic);
+void DrawLevel()
+{
+ int x,y;
#if 1
- if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
- DrawLevelFieldCrumbledSand(x, y);
+ SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
+ SetDrawBackgroundMask(REDRAW_FIELD);
#else
- if (GFX_CRUMBLED(Feld[x][y]))
- DrawLevelFieldCrumbledSand(x, y);
+ SetDrawBackgroundMask(REDRAW_NONE);
#endif
-}
-void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
-{
- int sx = SCREENX(x), sy = SCREENY(y);
- int graphic;
+ ClearField();
- if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
- return;
+ for (x = BX1; x <= BX2; x++)
+ for (y = BY1; y <= BY2; y++)
+ DrawScreenField(x, y);
- graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
+ redraw_mask |= REDRAW_FIELD;
+}
- if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
- return;
+void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y)
+{
+ int x,y;
- DrawGraphicAnimation(sx, sy, graphic);
+ for (x = 0; x < size_x; x++)
+ for (y = 0; y < size_y; y++)
+ DrawMiniElementOrWall(x, y, scroll_x, scroll_y);
- if (GFX_CRUMBLED(element))
- DrawLevelFieldCrumbledSand(x, y);
+ redraw_mask |= REDRAW_FIELD;
}
-static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
+static void DrawPreviewLevelPlayfieldExt(int from_x, int from_y)
{
- if (player->use_murphy)
- {
- /* this works only because currently only one player can be "murphy" ... */
- static int last_horizontal_dir = MV_LEFT;
- int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
+ boolean show_level_border = (BorderElement != EL_EMPTY);
+ int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
+ int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
+ int tile_size = preview.tile_size;
+ int preview_width = preview.xsize * tile_size;
+ int preview_height = preview.ysize * tile_size;
+ int real_preview_xsize = MIN(level_xsize, preview.xsize);
+ int real_preview_ysize = MIN(level_ysize, preview.ysize);
+ int dst_x = SX + ALIGNED_XPOS(preview.x, preview_width, preview.align);
+ int dst_y = SY + ALIGNED_YPOS(preview.y, preview_height, preview.valign);
+ int x, y;
- if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
- last_horizontal_dir = move_dir;
+ DrawBackground(dst_x, dst_y, preview_width, preview_height);
- if (graphic == IMG_SP_MURPHY) /* undefined => use special graphic */
+ dst_x += (preview_width - real_preview_xsize * tile_size) / 2;
+ dst_y += (preview_height - real_preview_ysize * tile_size) / 2;
+
+ for (x = 0; x < real_preview_xsize; x++)
+ {
+ for (y = 0; y < real_preview_ysize; y++)
{
- int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
+ int lx = from_x + x + (show_level_border ? -1 : 0);
+ int ly = from_y + y + (show_level_border ? -1 : 0);
+ int element = (IN_LEV_FIELD(lx, ly) ? level.field[lx][ly] :
+ getBorderElement(lx, ly));
- graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
+ DrawPreviewElement(dst_x + x * tile_size, dst_y + y * tile_size,
+ element, tile_size);
}
-
- return graphic;
}
- else
- return el_act_dir2img(player->artwork_element, player->GfxAction,move_dir);
+
+ redraw_mask |= REDRAW_MICROLEVEL;
}
-static boolean equalGraphics(int graphic1, int graphic2)
+#define MICROLABEL_EMPTY 0
+#define MICROLABEL_LEVEL_NAME 1
+#define MICROLABEL_LEVEL_AUTHOR_HEAD 2
+#define MICROLABEL_LEVEL_AUTHOR 3
+#define MICROLABEL_IMPORTED_FROM_HEAD 4
+#define MICROLABEL_IMPORTED_FROM 5
+#define MICROLABEL_IMPORTED_BY_HEAD 6
+#define MICROLABEL_IMPORTED_BY 7
+
+static int getMaxTextLength(struct TextPosInfo *pos, int font_nr)
{
- struct GraphicInfo *g1 = &graphic_info[graphic1];
- struct GraphicInfo *g2 = &graphic_info[graphic2];
+ int max_text_width = SXSIZE;
+ int font_width = getFontWidth(font_nr);
- return (g1->bitmap == g2->bitmap &&
- g1->src_x == g2->src_x &&
- g1->src_y == g2->src_y &&
- g1->anim_frames == g2->anim_frames &&
- g1->anim_delay == g2->anim_delay &&
- g1->anim_mode == g2->anim_mode);
+ if (pos->align == ALIGN_CENTER)
+ max_text_width = (pos->x < SXSIZE / 2 ? pos->x * 2 : (SXSIZE - pos->x) * 2);
+ else if (pos->align == ALIGN_RIGHT)
+ max_text_width = pos->x;
+ else
+ max_text_width = SXSIZE - pos->x;
+
+ return max_text_width / font_width;
}
-void DrawAllPlayers()
+static void DrawPreviewLevelLabelExt(int mode)
{
+ struct TextPosInfo *pos = &menu.main.text.level_info_2;
+ char label_text[MAX_OUTPUT_LINESIZE + 1];
+ int max_len_label_text;
+#if 1
+ int font_nr = pos->font;
int i;
- for (i = 0; i < MAX_PLAYERS; i++)
- if (stored_player[i].active)
- DrawPlayer(&stored_player[i]);
-}
+ if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
+ mode == MICROLABEL_IMPORTED_FROM_HEAD ||
+ mode == MICROLABEL_IMPORTED_BY_HEAD)
+ font_nr = pos->font_alt;
+#else
+ int font_nr = FONT_TEXT_2;
+ int i;
-void DrawPlayerField(int x, int y)
-{
- if (!IS_PLAYER(x, y))
- return;
+ if (mode == MICROLABEL_LEVEL_AUTHOR_HEAD ||
+ mode == MICROLABEL_IMPORTED_FROM_HEAD ||
+ mode == MICROLABEL_IMPORTED_BY_HEAD)
+ font_nr = FONT_TEXT_3;
+#endif
- DrawPlayer(PLAYERINFO(x, y));
-}
+#if 1
+ max_len_label_text = getMaxTextLength(pos, font_nr);
+#else
+ max_len_label_text = SXSIZE / getFontWidth(font_nr);
+#endif
-#define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
+#if 1
+ if (pos->size != -1)
+ max_len_label_text = pos->size;
+#endif
-void DrawPlayer(struct PlayerInfo *player)
-{
- int jx = player->jx;
- int jy = player->jy;
- int move_dir = player->MovDir;
- int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
- int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? +1 : 0);
- int last_jx = (player->is_moving ? jx - dx : jx);
- int last_jy = (player->is_moving ? jy - dy : jy);
- int next_jx = jx + dx;
- int next_jy = jy + dy;
- boolean player_is_moving = (player->MovPos ? TRUE : FALSE);
- boolean player_is_opaque = FALSE;
- int sx = SCREENX(jx), sy = SCREENY(jy);
- int sxx = 0, syy = 0;
- int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
- int graphic;
- int action = ACTION_DEFAULT;
- int last_player_graphic = getPlayerGraphic(player, move_dir);
- int last_player_frame = player->Frame;
- int frame = 0;
+ for (i = 0; i < max_len_label_text; i++)
+ label_text[i] = ' ';
+ label_text[max_len_label_text] = '\0';
- /* GfxElement[][] is set to the element the player is digging or collecting;
- remove also for off-screen player if the player is not moving anymore */
+ if (strlen(label_text) > 0)
+ {
+#if 1
+ DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
+#else
+ int lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
+ int lypos = MICROLABEL2_YPOS;
+
+ DrawText(lxpos, lypos, label_text, font_nr);
+#endif
+ }
+
+ strncpy(label_text,
+ (mode == MICROLABEL_LEVEL_NAME ? level.name :
+ mode == MICROLABEL_LEVEL_AUTHOR_HEAD ? "created by" :
+ mode == MICROLABEL_LEVEL_AUTHOR ? level.author :
+ mode == MICROLABEL_IMPORTED_FROM_HEAD ? "imported from" :
+ mode == MICROLABEL_IMPORTED_FROM ? leveldir_current->imported_from :
+ mode == MICROLABEL_IMPORTED_BY_HEAD ? "imported by" :
+ mode == MICROLABEL_IMPORTED_BY ? leveldir_current->imported_by :""),
+ max_len_label_text);
+ label_text[max_len_label_text] = '\0';
+
+ if (strlen(label_text) > 0)
+ {
+#if 1
+ DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
+#else
+ int lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
+ int lypos = MICROLABEL2_YPOS;
+
+ DrawText(lxpos, lypos, label_text, font_nr);
+#endif
+ }
+
+ redraw_mask |= REDRAW_MICROLEVEL;
+}
+
+static void DrawPreviewLevelExt(boolean restart)
+{
+ static unsigned int scroll_delay = 0;
+ static unsigned int label_delay = 0;
+ static int from_x, from_y, scroll_direction;
+ static int label_state, label_counter;
+ unsigned int scroll_delay_value = preview.step_delay;
+ boolean show_level_border = (BorderElement != EL_EMPTY);
+ int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
+ int level_ysize = lev_fieldy + (show_level_border ? 2 : 0);
+ int last_game_status = game_status; /* save current game status */
+
+#if 0
+ /* force PREVIEW font on preview level */
+ game_status = GAME_MODE_PSEUDO_PREVIEW;
+#endif
+
+ if (restart)
+ {
+ from_x = 0;
+ from_y = 0;
+
+ if (preview.anim_mode == ANIM_CENTERED)
+ {
+ if (level_xsize > preview.xsize)
+ from_x = (level_xsize - preview.xsize) / 2;
+ if (level_ysize > preview.ysize)
+ from_y = (level_ysize - preview.ysize) / 2;
+ }
+
+ from_x += preview.xoffset;
+ from_y += preview.yoffset;
+
+ scroll_direction = MV_RIGHT;
+ label_state = 1;
+ label_counter = 0;
+
+ DrawPreviewLevelPlayfieldExt(from_x, from_y);
+ DrawPreviewLevelLabelExt(label_state);
+
+ /* initialize delay counters */
+ DelayReached(&scroll_delay, 0);
+ DelayReached(&label_delay, 0);
+
+ if (leveldir_current->name)
+ {
+ struct TextPosInfo *pos = &menu.main.text.level_info_1;
+ char label_text[MAX_OUTPUT_LINESIZE + 1];
+#if 1
+ int font_nr = pos->font;
+#else
+ int font_nr = FONT_TEXT_1;
+#endif
+#if 1
+ int max_len_label_text = getMaxTextLength(pos, font_nr);
+#else
+ int max_len_label_text = SXSIZE / getFontWidth(font_nr);
+#endif
+#if 0
+ int text_width;
+ int lxpos, lypos;
+#endif
+
+#if 1
+ if (pos->size != -1)
+ max_len_label_text = pos->size;
+#endif
+
+ strncpy(label_text, leveldir_current->name, max_len_label_text);
+ label_text[max_len_label_text] = '\0';
+
+#if 1
+ DrawTextSAligned(pos->x, pos->y, label_text, font_nr, pos->align);
+#else
+ lxpos = SX + (SXSIZE - getTextWidth(label_text, font_nr)) / 2;
+ lypos = SY + MICROLABEL1_YPOS;
+
+ DrawText(lxpos, lypos, label_text, font_nr);
+#endif
+ }
+
+ game_status = last_game_status; /* restore current game status */
+
+ return;
+ }
+
+ /* scroll preview level, if needed */
+ if (preview.anim_mode != ANIM_NONE &&
+ (level_xsize > preview.xsize || level_ysize > preview.ysize) &&
+ DelayReached(&scroll_delay, scroll_delay_value))
+ {
+ switch (scroll_direction)
+ {
+ case MV_LEFT:
+ if (from_x > 0)
+ {
+ from_x -= preview.step_offset;
+ from_x = (from_x < 0 ? 0 : from_x);
+ }
+ else
+ scroll_direction = MV_UP;
+ break;
+
+ case MV_RIGHT:
+ if (from_x < level_xsize - preview.xsize)
+ {
+ from_x += preview.step_offset;
+ from_x = (from_x > level_xsize - preview.xsize ?
+ level_xsize - preview.xsize : from_x);
+ }
+ else
+ scroll_direction = MV_DOWN;
+ break;
+
+ case MV_UP:
+ if (from_y > 0)
+ {
+ from_y -= preview.step_offset;
+ from_y = (from_y < 0 ? 0 : from_y);
+ }
+ else
+ scroll_direction = MV_RIGHT;
+ break;
+
+ case MV_DOWN:
+ if (from_y < level_ysize - preview.ysize)
+ {
+ from_y += preview.step_offset;
+ from_y = (from_y > level_ysize - preview.ysize ?
+ level_ysize - preview.ysize : from_y);
+ }
+ else
+ scroll_direction = MV_LEFT;
+ break;
+
+ default:
+ break;
+ }
+
+ DrawPreviewLevelPlayfieldExt(from_x, from_y);
+ }
+
+ /* !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!! */
+ /* redraw micro level label, if needed */
+ if (!strEqual(level.name, NAMELESS_LEVEL_NAME) &&
+ !strEqual(level.author, ANONYMOUS_NAME) &&
+ !strEqual(level.author, leveldir_current->name) &&
+ DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY))
+ {
+ int max_label_counter = 23;
+
+ if (leveldir_current->imported_from != NULL &&
+ strlen(leveldir_current->imported_from) > 0)
+ max_label_counter += 14;
+ if (leveldir_current->imported_by != NULL &&
+ strlen(leveldir_current->imported_by) > 0)
+ max_label_counter += 14;
+
+ label_counter = (label_counter + 1) % max_label_counter;
+ label_state = (label_counter >= 0 && label_counter <= 7 ?
+ MICROLABEL_LEVEL_NAME :
+ label_counter >= 9 && label_counter <= 12 ?
+ MICROLABEL_LEVEL_AUTHOR_HEAD :
+ label_counter >= 14 && label_counter <= 21 ?
+ MICROLABEL_LEVEL_AUTHOR :
+ label_counter >= 23 && label_counter <= 26 ?
+ MICROLABEL_IMPORTED_FROM_HEAD :
+ label_counter >= 28 && label_counter <= 35 ?
+ MICROLABEL_IMPORTED_FROM :
+ label_counter >= 37 && label_counter <= 40 ?
+ MICROLABEL_IMPORTED_BY_HEAD :
+ label_counter >= 42 && label_counter <= 49 ?
+ MICROLABEL_IMPORTED_BY : MICROLABEL_EMPTY);
+
+ if (leveldir_current->imported_from == NULL &&
+ (label_state == MICROLABEL_IMPORTED_FROM_HEAD ||
+ label_state == MICROLABEL_IMPORTED_FROM))
+ label_state = (label_state == MICROLABEL_IMPORTED_FROM_HEAD ?
+ MICROLABEL_IMPORTED_BY_HEAD : MICROLABEL_IMPORTED_BY);
+
+ DrawPreviewLevelLabelExt(label_state);
+ }
+
+ game_status = last_game_status; /* restore current game status */
+}
+
+void DrawPreviewLevelInitial()
+{
+ DrawPreviewLevelExt(TRUE);
+}
+
+void DrawPreviewLevelAnimation()
+{
+ DrawPreviewLevelExt(FALSE);
+}
+
+inline void DrawGraphicAnimationExt(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)
+ DrawGraphicThruMaskExt(dst_bitmap, x, y, graphic, frame);
+ else
+ 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);
+
+ 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);
+}
+
+void DrawLevelGraphicAnimation(int x, int y, int graphic)
+{
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+}
+
+void DrawLevelElementAnimation(int x, int y, int element)
+{
+ int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
+
+ DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
+}
+
+inline void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
+{
+ int sx = SCREENX(x), sy = SCREENY(y);
+
+ if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
+ return;
+
+ if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
+ return;
+
+ DrawGraphicAnimation(sx, sy, graphic);
+
+#if 1
+ if (GFX_CRUMBLED(TILE_GFX_ELEMENT(x, y)))
+ DrawLevelFieldCrumbled(x, y);
+#else
+ if (GFX_CRUMBLED(Feld[x][y]))
+ DrawLevelFieldCrumbled(x, y);
+#endif
+}
+
+void DrawLevelElementAnimationIfNeeded(int x, int y, int element)
+{
+ int sx = SCREENX(x), sy = SCREENY(y);
+ int graphic;
+
+ if (!IN_LEV_FIELD(x, y) || !IN_SCR_FIELD(sx, sy))
+ return;
+
+ graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
+
+ if (!IS_NEW_FRAME(GfxFrame[x][y], graphic))
+ return;
+
+ DrawGraphicAnimation(sx, sy, graphic);
+
+ if (GFX_CRUMBLED(element))
+ DrawLevelFieldCrumbled(x, y);
+}
+
+static int getPlayerGraphic(struct PlayerInfo *player, int move_dir)
+{
+ if (player->use_murphy)
+ {
+ /* this works only because currently only one player can be "murphy" ... */
+ static int last_horizontal_dir = MV_LEFT;
+ int graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, move_dir);
+
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ last_horizontal_dir = move_dir;
+
+ if (graphic == IMG_SP_MURPHY) /* undefined => use special graphic */
+ {
+ int direction = (player->is_snapping ? move_dir : last_horizontal_dir);
+
+ graphic = el_act_dir2img(EL_SP_MURPHY, player->GfxAction, direction);
+ }
+
+ return graphic;
+ }
+ else
+ return el_act_dir2img(player->artwork_element, player->GfxAction,move_dir);
+}
+
+static boolean equalGraphics(int graphic1, int graphic2)
+{
+ struct GraphicInfo *g1 = &graphic_info[graphic1];
+ struct GraphicInfo *g2 = &graphic_info[graphic2];
+
+ return (g1->bitmap == g2->bitmap &&
+ g1->src_x == g2->src_x &&
+ g1->src_y == g2->src_y &&
+ g1->anim_frames == g2->anim_frames &&
+ g1->anim_delay == g2->anim_delay &&
+ g1->anim_mode == g2->anim_mode);
+}
+
+void DrawAllPlayers()
+{
+ int i;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].active)
+ DrawPlayer(&stored_player[i]);
+}
+
+void DrawPlayerField(int x, int y)
+{
+ if (!IS_PLAYER(x, y))
+ return;
+
+ DrawPlayer(PLAYERINFO(x, y));
+}
+
+#define DRAW_PLAYER_OVER_PUSHED_ELEMENT 1
+
+void DrawPlayer(struct PlayerInfo *player)
+{
+ int jx = player->jx;
+ int jy = player->jy;
+ int move_dir = player->MovDir;
+ int dx = (move_dir == MV_LEFT ? -1 : move_dir == MV_RIGHT ? +1 : 0);
+ int dy = (move_dir == MV_UP ? -1 : move_dir == MV_DOWN ? +1 : 0);
+ int last_jx = (player->is_moving ? jx - dx : jx);
+ int last_jy = (player->is_moving ? jy - dy : jy);
+ int next_jx = jx + dx;
+ int next_jy = jy + dy;
+ boolean player_is_moving = (player->MovPos ? TRUE : FALSE);
+ boolean player_is_opaque = FALSE;
+ int sx = SCREENX(jx), sy = SCREENY(jy);
+ int sxx = 0, syy = 0;
+ int element = Feld[jx][jy], last_element = Feld[last_jx][last_jy];
+ int graphic;
+ int action = ACTION_DEFAULT;
+ int last_player_graphic = getPlayerGraphic(player, move_dir);
+ int last_player_frame = player->Frame;
+ int frame = 0;
+
+ /* GfxElement[][] is set to the element the player is digging or collecting;
+ remove also for off-screen player if the player is not moving anymore */
if (IN_LEV_FIELD(jx, jy) && !player_is_moving)
GfxElement[jx][jy] = EL_UNDEFINED;
- if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
- return;
+ if (!player->active || !IN_SCR_FIELD(SCREENX(last_jx), SCREENY(last_jy)))
+ return;
+
+#if DEBUG
+ if (!IN_LEV_FIELD(jx, jy))
+ {
+ printf("DrawPlayerField(): x = %d, y = %d\n",jx,jy);
+ printf("DrawPlayerField(): sx = %d, sy = %d\n",sx,sy);
+ printf("DrawPlayerField(): This should never happen!\n");
+ return;
+ }
+#endif
+
+ if (element == EL_EXPLOSION)
+ return;
+
+ action = (player->is_pushing ? ACTION_PUSHING :
+ player->is_digging ? ACTION_DIGGING :
+ player->is_collecting ? ACTION_COLLECTING :
+ player->is_moving ? ACTION_MOVING :
+ player->is_snapping ? ACTION_SNAPPING :
+ player->is_dropping ? ACTION_DROPPING :
+ player->is_waiting ? player->action_waiting : ACTION_DEFAULT);
+
+ if (player->is_waiting)
+ move_dir = player->dir_waiting;
+
+ InitPlayerGfxAnimation(player, action, move_dir);
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things in the field the player is leaving, if needed */
+ /* ----------------------------------------------------------------------- */
+
+ if (player->is_moving)
+ {
+ if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
+ {
+ DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
+
+ if (last_element == EL_DYNAMITE_ACTIVE ||
+ last_element == EL_EM_DYNAMITE_ACTIVE ||
+ last_element == EL_SP_DISK_RED_ACTIVE)
+ DrawDynamite(last_jx, last_jy);
+ else
+ DrawLevelFieldThruMask(last_jx, last_jy);
+ }
+ else if (last_element == EL_DYNAMITE_ACTIVE ||
+ last_element == EL_EM_DYNAMITE_ACTIVE ||
+ last_element == EL_SP_DISK_RED_ACTIVE)
+ DrawDynamite(last_jx, last_jy);
+#if 0
+ /* !!! this is not enough to prevent flickering of players which are
+ moving next to each others without a free tile between them -- this
+ can only be solved by drawing all players layer by layer (first the
+ background, then the foreground etc.) !!! => TODO */
+ else if (!IS_PLAYER(last_jx, last_jy))
+ DrawLevelField(last_jx, last_jy);
+#else
+ else
+ DrawLevelField(last_jx, last_jy);
+#endif
+
+ if (player->is_pushing && IN_SCR_FIELD(SCREENX(next_jx), SCREENY(next_jy)))
+ DrawLevelElement(next_jx, next_jy, EL_EMPTY);
+ }
+
+ if (!IN_SCR_FIELD(sx, sy))
+ return;
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things behind the player, if needed */
+ /* ----------------------------------------------------------------------- */
+
+ if (Back[jx][jy])
+ DrawLevelElement(jx, jy, Back[jx][jy]);
+ else if (IS_ACTIVE_BOMB(element))
+ DrawLevelElement(jx, jy, EL_EMPTY);
+ else
+ {
+ if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
+ {
+ int old_element = GfxElement[jx][jy];
+ int old_graphic = el_act_dir2img(old_element, action, move_dir);
+ int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
+
+ if (GFX_CRUMBLED(old_element))
+ DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
+ else
+ DrawGraphic(sx, sy, old_graphic, frame);
+
+ if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
+ player_is_opaque = TRUE;
+ }
+ else
+ {
+ GfxElement[jx][jy] = EL_UNDEFINED;
+
+ /* make sure that pushed elements are drawn with correct frame rate */
+#if 1
+ graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
+
+ if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
+ GfxFrame[jx][jy] = player->StepFrame;
+#else
+ if (player->is_pushing && player->is_moving)
+ GfxFrame[jx][jy] = player->StepFrame;
+#endif
+
+ DrawLevelField(jx, jy);
+ }
+ }
+
+#if !DRAW_PLAYER_OVER_PUSHED_ELEMENT
+ /* ----------------------------------------------------------------------- */
+ /* draw player himself */
+ /* ----------------------------------------------------------------------- */
+
+ graphic = getPlayerGraphic(player, move_dir);
+
+ /* in the case of changed player action or direction, prevent the current
+ animation frame from being restarted for identical animations */
+ if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
+ player->Frame = last_player_frame;
+
+ frame = getGraphicAnimationFrame(graphic, player->Frame);
+
+ if (player->GfxPos)
+ {
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ sxx = player->GfxPos;
+ else
+ syy = player->GfxPos;
+ }
+
+ if (!setup.soft_scrolling && ScreenMovPos)
+ sxx = syy = 0;
+
+ if (player_is_opaque)
+ DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
+ else
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+
+ if (SHIELD_ON(player))
+ {
+ int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
+ IMG_SHIELD_NORMAL_ACTIVE);
+ int frame = getGraphicAnimationFrame(graphic, -1);
+
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ }
+#endif
+
+#if DRAW_PLAYER_OVER_PUSHED_ELEMENT
+ if (player->GfxPos)
+ {
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ sxx = player->GfxPos;
+ else
+ syy = player->GfxPos;
+ }
+#endif
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things the player is pushing, if needed */
+ /* ----------------------------------------------------------------------- */
+
+#if 0
+ printf("::: %d, %d [%d, %d] [%d]\n",
+ player->is_pushing, player_is_moving, player->GfxAction,
+ player->is_moving, player_is_moving);
+#endif
+
+#if 1
+ if (player->is_pushing && player->is_moving)
+ {
+ int px = SCREENX(jx), py = SCREENY(jy);
+ int pxx = (TILEX - ABS(sxx)) * dx;
+ int pyy = (TILEY - ABS(syy)) * dy;
+ int gfx_frame = GfxFrame[jx][jy];
+
+ int graphic;
+ int sync_frame;
+ int frame;
+
+ if (!IS_MOVING(jx, jy)) /* push movement already finished */
+ {
+ element = Feld[next_jx][next_jy];
+ gfx_frame = GfxFrame[next_jx][next_jy];
+ }
+
+ graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
+
+#if 1
+ sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
+ frame = getGraphicAnimationFrame(graphic, sync_frame);
+#else
+ frame = getGraphicAnimationFrame(graphic, player->StepFrame);
+#endif
+
+ /* draw background element under pushed element (like the Sokoban field) */
+#if 1
+ if (game.use_masked_pushing && IS_MOVING(jx, jy))
+ {
+ /* this allows transparent pushing animation over non-black background */
+
+ if (Back[jx][jy])
+ DrawLevelElement(jx, jy, Back[jx][jy]);
+ else
+ DrawLevelElement(jx, jy, EL_EMPTY);
+
+ if (Back[next_jx][next_jy])
+ DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
+ else
+ DrawLevelElement(next_jx, next_jy, EL_EMPTY);
+ }
+ else if (Back[next_jx][next_jy])
+ DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
+#else
+ if (Back[next_jx][next_jy])
+ DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
+#endif
+
+#if 0
+ printf("::: %d, %d, %d, %d [%d] [%d, %d, %d] [%d] [%d, %d] [%d, %d]\n",
+ jx, px, player->GfxPos, player->StepFrame,
+ player->is_pushing,
+ dx, sxx, pxx,
+ IS_MOVING(jx, jy),
+ graphic, frame,
+ GfxFrame[jx][jy], GfxFrame[next_jx][next_jy]);
+#endif
+
+#if 1
+ /* do not draw (EM style) pushing animation when pushing is finished */
+ /* (two-tile animations usually do not contain start and end frame) */
+ if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
+ DrawLevelElement(next_jx, next_jy, Feld[next_jx][next_jy]);
+ else
+ DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
+#else
+ /* masked drawing is needed for EMC style (double) movement graphics */
+ /* !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!! */
+ DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
+#endif
+ }
+#endif
+
+#if DRAW_PLAYER_OVER_PUSHED_ELEMENT
+ /* ----------------------------------------------------------------------- */
+ /* draw player himself */
+ /* ----------------------------------------------------------------------- */
+
+ graphic = getPlayerGraphic(player, move_dir);
+
+ /* in the case of changed player action or direction, prevent the current
+ animation frame from being restarted for identical animations */
+ if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
+ player->Frame = last_player_frame;
+
+ frame = getGraphicAnimationFrame(graphic, player->Frame);
+
+ if (player->GfxPos)
+ {
+ if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
+ sxx = player->GfxPos;
+ else
+ syy = player->GfxPos;
+ }
+
+ if (!setup.soft_scrolling && ScreenMovPos)
+ sxx = syy = 0;
+
+ if (player_is_opaque)
+ DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
+ else
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+
+ if (SHIELD_ON(player))
+ {
+ int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
+ IMG_SHIELD_NORMAL_ACTIVE);
+ int frame = getGraphicAnimationFrame(graphic, -1);
+
+ DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ }
+#endif
+
+ /* ----------------------------------------------------------------------- */
+ /* draw things in front of player (active dynamite or dynabombs) */
+ /* ----------------------------------------------------------------------- */
+
+ if (IS_ACTIVE_BOMB(element))
+ {
+ graphic = el2img(element);
+ frame = getGraphicAnimationFrame(graphic, GfxFrame[jx][jy]);
+
+ if (game.emulation == EMU_SUPAPLEX)
+ DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
+ else
+ DrawGraphicThruMask(sx, sy, graphic, frame);
+ }
+
+ if (player_is_moving && last_element == EL_EXPLOSION)
+ {
+ int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
+ GfxElement[last_jx][last_jy] : EL_EMPTY);
+ int graphic = el_act2img(element, ACTION_EXPLODING);
+ int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
+ int phase = ExplodePhase[last_jx][last_jy] - 1;
+ int frame = getGraphicAnimationFrame(graphic, phase - delay);
+
+ if (phase >= delay)
+ DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
+ }
+
+ /* ----------------------------------------------------------------------- */
+ /* draw elements the player is just walking/passing through/under */
+ /* ----------------------------------------------------------------------- */
+
+ if (player_is_moving)
+ {
+ /* handle the field the player is leaving ... */
+ if (IS_ACCESSIBLE_INSIDE(last_element))
+ DrawLevelField(last_jx, last_jy);
+ else if (IS_ACCESSIBLE_UNDER(last_element))
+ DrawLevelFieldThruMask(last_jx, last_jy);
+ }
+
+ /* do not redraw accessible elements if the player is just pushing them */
+ if (!player_is_moving || !player->is_pushing)
+ {
+ /* ... and the field the player is entering */
+ if (IS_ACCESSIBLE_INSIDE(element))
+ DrawLevelField(jx, jy);
+ else if (IS_ACCESSIBLE_UNDER(element))
+ DrawLevelFieldThruMask(jx, jy);
+ }
+
+ MarkTileDirty(sx, sy);
+}
+
+/* ------------------------------------------------------------------------- */
+
+void WaitForEventToContinue()
+{
+ boolean still_wait = TRUE;
+
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ button_status = MB_RELEASED;
+
+#if 1
+ ClearEventQueue();
+#endif
+
+ while (still_wait)
+ {
+ if (PendingEvent())
+ {
+ Event event;
+
+ NextEvent(&event);
+
+ switch (event.type)
+ {
+ case EVENT_BUTTONPRESS:
+ case EVENT_KEYPRESS:
+ still_wait = FALSE;
+ break;
+
+ case EVENT_KEYRELEASE:
+ ClearPlayerAction();
+ break;
+
+ default:
+ HandleOtherEvents(&event);
+ break;
+ }
+ }
+ else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
+ {
+ still_wait = FALSE;
+ }
+
+ DoAnimation();
+
+ /* don't eat all CPU time */
+ Delay(10);
+ }
+}
+
+#define MAX_REQUEST_LINES 13
+#define MAX_REQUEST_LINE_FONT1_LEN 7
+#define MAX_REQUEST_LINE_FONT2_LEN 10
+
+#if 1
+
+static int RequestHandleEvents(unsigned int req_state)
+{
+ int last_game_status = game_status; /* save current game status */
+ int result;
+ int mx, my;
+
+ button_status = MB_RELEASED;
+
+ request_gadget_id = -1;
+ result = -1;
+
+ while (result < 0)
+ {
+ if (PendingEvent())
+ {
+ Event event;
+
+ NextEvent(&event);
+
+ switch (event.type)
+ {
+ case EVENT_BUTTONPRESS:
+ case EVENT_BUTTONRELEASE:
+ case EVENT_MOTIONNOTIFY:
+ {
+ if (event.type == EVENT_MOTIONNOTIFY)
+ {
+ if (!PointerInWindow(window))
+ continue; /* window and pointer are on different screens */
+
+ if (!button_status)
+ continue;
+
+ motion_status = TRUE;
+ mx = ((MotionEvent *) &event)->x;
+ my = ((MotionEvent *) &event)->y;
+ }
+ else
+ {
+ motion_status = FALSE;
+ mx = ((ButtonEvent *) &event)->x;
+ my = ((ButtonEvent *) &event)->y;
+ if (event.type == EVENT_BUTTONPRESS)
+ button_status = ((ButtonEvent *) &event)->button;
+ else
+ button_status = MB_RELEASED;
+ }
+
+ /* this sets 'request_gadget_id' */
+ HandleGadgets(mx, my, button_status);
-#if DEBUG
- if (!IN_LEV_FIELD(jx, jy))
+ switch (request_gadget_id)
+ {
+ case TOOL_CTRL_ID_YES:
+ result = TRUE;
+ break;
+ case TOOL_CTRL_ID_NO:
+ result = FALSE;
+ break;
+ case TOOL_CTRL_ID_CONFIRM:
+ result = TRUE | FALSE;
+ break;
+
+ case TOOL_CTRL_ID_PLAYER_1:
+ result = 1;
+ break;
+ case TOOL_CTRL_ID_PLAYER_2:
+ result = 2;
+ break;
+ case TOOL_CTRL_ID_PLAYER_3:
+ result = 3;
+ break;
+ case TOOL_CTRL_ID_PLAYER_4:
+ result = 4;
+ break;
+
+ default:
+ break;
+ }
+
+ break;
+ }
+
+ case EVENT_KEYPRESS:
+ switch (GetEventKey((KeyEvent *)&event, TRUE))
+ {
+ case KSYM_space:
+ if (req_state & REQ_CONFIRM)
+ result = 1;
+ break;
+
+ case KSYM_Return:
+ result = 1;
+ break;
+
+ case KSYM_Escape:
+#if defined(TARGET_SDL2)
+ case KSYM_Back:
+#endif
+ result = 0;
+ break;
+
+ default:
+ break;
+ }
+
+ if (req_state & REQ_PLAYER)
+ result = 0;
+ break;
+
+ case EVENT_KEYRELEASE:
+ ClearPlayerAction();
+ break;
+
+ default:
+ HandleOtherEvents(&event);
+ break;
+ }
+ }
+ else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
+ {
+ int joy = AnyJoystick();
+
+ if (joy & JOY_BUTTON_1)
+ result = 1;
+ else if (joy & JOY_BUTTON_2)
+ result = 0;
+ }
+
+#if 1
+
+ if (game_status == GAME_MODE_PLAYING && local_player->LevelSolved_GameEnd)
+ {
+ HandleGameActions();
+ }
+ else
+ {
+ DoAnimation();
+
+ if (!PendingEvent()) /* delay only if no pending events */
+ 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();
+
+#if 1
+ if (!PendingEvent()) /* delay only if no pending events */
+ Delay(10);
+#else
+ /* don't eat all CPU time */
+ Delay(10);
+#endif
+
+#endif
+ }
+
+ return result;
+}
+
+static boolean RequestDoor(char *text, unsigned int req_state)
+{
+ unsigned int old_door_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;
+ char *text_ptr;
+ int result;
+ int ty;
+
+ if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN)
{
- printf("DrawPlayerField(): x = %d, y = %d\n",jx,jy);
- printf("DrawPlayerField(): sx = %d, sy = %d\n",sx,sy);
- printf("DrawPlayerField(): This should never happen!\n");
- return;
+ max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
+ font_nr = FONT_TEXT_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);
}
+
+ /* disable deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOff(TRUE);
+
+ SetMouseCursor(CURSOR_DEFAULT);
+
+#if defined(NETWORK_AVALIABLE)
+ /* pause network game while waiting for request to answer */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_PausePlaying();
#endif
- if (element == EL_EXPLOSION)
- return;
+ old_door_state = GetDoorState();
- action = (player->is_pushing ? ACTION_PUSHING :
- player->is_digging ? ACTION_DIGGING :
- player->is_collecting ? ACTION_COLLECTING :
- player->is_moving ? ACTION_MOVING :
- player->is_snapping ? ACTION_SNAPPING :
- player->is_dropping ? ACTION_DROPPING :
- player->is_waiting ? player->action_waiting : ACTION_DEFAULT);
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
- if (player->is_waiting)
- move_dir = player->dir_waiting;
+ UnmapAllGadgets();
- InitPlayerGfxAnimation(player, action, move_dir);
+ /* draw released gadget before proceeding */
+ // BackToFront();
- /* ----------------------------------------------------------------------- */
- /* draw things in the field the player is leaving, if needed */
- /* ----------------------------------------------------------------------- */
+ if (old_door_state & DOOR_OPEN_1)
+ {
+ CloseDoor(DOOR_CLOSE_1);
- if (player->is_moving)
+ /* save old door content */
+ BlitBitmap(bitmap_db_door, bitmap_db_door,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
+ DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1);
+ }
+
+ SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ /* clear door drawing field */
+ DrawBackground(DX, DY, DXSIZE, DYSIZE);
+
+ /* force DOOR font inside door area */
+ game_status = GAME_MODE_PSEUDO_DOOR;
+
+ /* write text for request */
+ for (text_ptr = text, ty = 0; ty < MAX_REQUEST_LINES; ty++)
{
- if (Back[last_jx][last_jy] && IS_DRAWABLE(last_element))
+ char text_line[max_request_line_len + 1];
+ int tx, tl, tc = 0;
+
+ if (!*text_ptr)
+ break;
+
+ for (tl = 0, tx = 0; tx < max_request_line_len; tl++, tx++)
{
- DrawLevelElement(last_jx, last_jy, Back[last_jx][last_jy]);
+ tc = *(text_ptr + tx);
+ // if (!tc || tc == ' ')
+ if (!tc || tc == ' ' || tc == '?' || tc == '!')
+ break;
+ }
- if (last_element == EL_DYNAMITE_ACTIVE ||
- last_element == EL_EM_DYNAMITE_ACTIVE ||
- last_element == EL_SP_DISK_RED_ACTIVE)
- DrawDynamite(last_jx, last_jy);
- else
- DrawLevelFieldThruMask(last_jx, last_jy);
+ if ((tc == '?' || tc == '!') && tl == 0)
+ tl = 1;
+
+ if (!tl)
+ {
+ text_ptr++;
+ ty--;
+ continue;
}
- else if (last_element == EL_DYNAMITE_ACTIVE ||
- last_element == EL_EM_DYNAMITE_ACTIVE ||
- last_element == EL_SP_DISK_RED_ACTIVE)
- DrawDynamite(last_jx, last_jy);
-#if 0
- /* !!! this is not enough to prevent flickering of players which are
- moving next to each others without a free tile between them -- this
- can only be solved by drawing all players layer by layer (first the
- background, then the foreground etc.) !!! => TODO */
- else if (!IS_PLAYER(last_jx, last_jy))
- DrawLevelField(last_jx, last_jy);
-#else
- else
- DrawLevelField(last_jx, last_jy);
-#endif
- if (player->is_pushing && IN_SCR_FIELD(SCREENX(next_jx), SCREENY(next_jy)))
- DrawLevelElement(next_jx, next_jy, EL_EMPTY);
+ 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_ptr += tl + (tc == ' ' ? 1 : 0);
+ // text_ptr += tl + (tc == ' ' || tc == '?' || tc == '!' ? 1 : 0);
+ }
+
+ game_status = last_game_status; /* restore current game status */
+
+ if (req_state & REQ_ASK)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
+ }
+ else if (req_state & REQ_CONFIRM)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
+ }
+ else if (req_state & REQ_PLAYER)
+ {
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
}
- if (!IN_SCR_FIELD(sx, sy))
- return;
+ /* copy request gadgets to door backbuffer */
+ BlitBitmap(drawto, bitmap_db_door,
+ DX, DY, DXSIZE, DYSIZE,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
- /* ----------------------------------------------------------------------- */
- /* draw things behind the player, if needed */
- /* ----------------------------------------------------------------------- */
+ OpenDoor(DOOR_OPEN_1);
- if (Back[jx][jy])
- DrawLevelElement(jx, jy, Back[jx][jy]);
- else if (IS_ACTIVE_BOMB(element))
- DrawLevelElement(jx, jy, EL_EMPTY);
- else
+ if (!(req_state & REQUEST_WAIT_FOR_INPUT))
{
- if (player_is_moving && GfxElement[jx][jy] != EL_UNDEFINED)
+ if (game_status == GAME_MODE_PLAYING)
{
- int old_element = GfxElement[jx][jy];
- int old_graphic = el_act_dir2img(old_element, action, move_dir);
- int frame = getGraphicAnimationFrame(old_graphic, player->StepFrame);
-
- if (GFX_CRUMBLED(old_element))
- DrawLevelFieldCrumbledSandDigging(jx, jy, move_dir, player->StepFrame);
- else
- DrawGraphic(sx, sy, old_graphic, frame);
-
- if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
- player_is_opaque = TRUE;
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
}
else
{
- GfxElement[jx][jy] = EL_UNDEFINED;
-
- /* make sure that pushed elements are drawn with correct frame rate */
-#if 1
- graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
-
- if (player->is_pushing && player->is_moving && !IS_ANIM_MODE_CE(graphic))
- GfxFrame[jx][jy] = player->StepFrame;
-#else
- if (player->is_pushing && player->is_moving)
- GfxFrame[jx][jy] = player->StepFrame;
-#endif
-
- DrawLevelField(jx, jy);
+ SetDrawBackgroundMask(REDRAW_FIELD);
}
+
+ return FALSE;
}
-#if !DRAW_PLAYER_OVER_PUSHED_ELEMENT
- /* ----------------------------------------------------------------------- */
- /* draw player himself */
- /* ----------------------------------------------------------------------- */
+ if (game_status != GAME_MODE_MAIN)
+ InitAnimation();
- graphic = getPlayerGraphic(player, move_dir);
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
- /* in the case of changed player action or direction, prevent the current
- animation frame from being restarted for identical animations */
- if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
- player->Frame = last_player_frame;
+ // ---------- handle request buttons ----------
+ result = RequestHandleEvents(req_state);
- frame = getGraphicAnimationFrame(graphic, player->Frame);
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
- if (player->GfxPos)
+ UnmapToolButtons();
+
+ if (!(req_state & REQ_STAY_OPEN))
{
- if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
- sxx = player->GfxPos;
- else
- syy = player->GfxPos;
- }
+ CloseDoor(DOOR_CLOSE_1);
- if (!setup.soft_scrolling && ScreenMovPos)
- sxx = syy = 0;
+ if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
+ (req_state & REQ_REOPEN))
+ OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+ }
- if (player_is_opaque)
- DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
- else
- DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ RemapAllGadgets();
- if (SHIELD_ON(player))
+ if (game_status == GAME_MODE_PLAYING)
{
- int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
- IMG_SHIELD_NORMAL_ACTIVE);
- int frame = getGraphicAnimationFrame(graphic, -1);
-
- DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
}
-#endif
-
-#if DRAW_PLAYER_OVER_PUSHED_ELEMENT
- if (player->GfxPos)
+ else
{
- if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
- sxx = player->GfxPos;
- else
- syy = player->GfxPos;
+ SetDrawBackgroundMask(REDRAW_FIELD);
}
+
+#if defined(NETWORK_AVALIABLE)
+ /* continue network game after request */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_ContinuePlaying();
#endif
- /* ----------------------------------------------------------------------- */
- /* draw things the player is pushing, if needed */
- /* ----------------------------------------------------------------------- */
+ /* restore deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOn();
+
+ return result;
+}
+static boolean RequestEnvelope(char *text, unsigned int req_state)
+{
+ int result;
#if 0
- printf("::: %d, %d [%d, %d] [%d]\n",
- player->is_pushing, player_is_moving, player->GfxAction,
- player->is_moving, player_is_moving);
+ int i;
#endif
-#if 1
- if (player->is_pushing && player->is_moving)
+ if (game_status == GAME_MODE_PLAYING)
{
- int px = SCREENX(jx), py = SCREENY(jy);
- int pxx = (TILEX - ABS(sxx)) * dx;
- int pyy = (TILEY - ABS(syy)) * dy;
- int gfx_frame = GfxFrame[jx][jy];
-
- int graphic;
- int sync_frame;
- int frame;
+ 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);
+ }
- if (!IS_MOVING(jx, jy)) /* push movement already finished */
- {
- element = Feld[next_jx][next_jy];
- gfx_frame = GfxFrame[next_jx][next_jy];
- }
+ /* disable deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOff(TRUE);
- graphic = el_act_dir2img(element, ACTION_PUSHING, move_dir);
+ SetMouseCursor(CURSOR_DEFAULT);
-#if 1
- sync_frame = (IS_ANIM_MODE_CE(graphic) ? gfx_frame : player->StepFrame);
- frame = getGraphicAnimationFrame(graphic, sync_frame);
-#else
- frame = getGraphicAnimationFrame(graphic, player->StepFrame);
+#if defined(NETWORK_AVALIABLE)
+ /* pause network game while waiting for request to answer */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_PausePlaying();
#endif
- /* draw background element under pushed element (like the Sokoban field) */
-#if 1
- if (game.use_masked_pushing && IS_MOVING(jx, jy))
- {
- /* this allows transparent pushing animation over non-black background */
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
- if (Back[jx][jy])
- DrawLevelElement(jx, jy, Back[jx][jy]);
- else
- DrawLevelElement(jx, jy, EL_EMPTY);
+ UnmapAllGadgets();
- if (Back[next_jx][next_jy])
- DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
- else
- DrawLevelElement(next_jx, next_jy, EL_EMPTY);
- }
- else if (Back[next_jx][next_jy])
- DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
-#else
- if (Back[next_jx][next_jy])
- DrawLevelElement(next_jx, next_jy, Back[next_jx][next_jy]);
-#endif
+ // (replace with setting corresponding request background)
+ // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+ // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
-#if 0
- printf("::: %d, %d, %d, %d [%d] [%d, %d, %d] [%d] [%d, %d] [%d, %d]\n",
- jx, px, player->GfxPos, player->StepFrame,
- player->is_pushing,
- dx, sxx, pxx,
- IS_MOVING(jx, jy),
- graphic, frame,
- GfxFrame[jx][jy], GfxFrame[next_jx][next_jy]);
-#endif
+ /* clear door drawing field */
+ // DrawBackground(DX, DY, DXSIZE, DYSIZE);
-#if 1
- /* do not draw (EM style) pushing animation when pushing is finished */
- /* (two-tile animations usually do not contain start and end frame) */
- if (graphic_info[graphic].double_movement && !IS_MOVING(jx, jy))
- DrawLevelElement(next_jx, next_jy, Feld[next_jx][next_jy]);
- else
- DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
-#else
- /* masked drawing is needed for EMC style (double) movement graphics */
- /* !!! (ONLY WHEN DRAWING PUSHED ELEMENT OVER THE PLAYER) !!! */
- DrawGraphicShiftedThruMask(px, py, pxx, pyy, graphic, frame, NO_CUTTING);
-#endif
+#if 0
+ if (global.use_envelope_request)
+ {
+ /* !!! TMP !!! */
+ FreeToolButtons();
+ CreateToolButtons();
}
#endif
-#if DRAW_PLAYER_OVER_PUSHED_ELEMENT
- /* ----------------------------------------------------------------------- */
- /* draw player himself */
- /* ----------------------------------------------------------------------- */
-
- graphic = getPlayerGraphic(player, move_dir);
-
- /* in the case of changed player action or direction, prevent the current
- animation frame from being restarted for identical animations */
- if (player->Frame == 0 && equalGraphics(graphic, last_player_graphic))
- player->Frame = last_player_frame;
-
- frame = getGraphicAnimationFrame(graphic, player->Frame);
-
- if (player->GfxPos)
+#if 0
+#if 0
+ if (req_state & REQ_ASK)
{
- if (move_dir == MV_LEFT || move_dir == MV_RIGHT)
- sxx = player->GfxPos;
- else
- syy = player->GfxPos;
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_YES], FALSE);
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_NO], FALSE);
}
-
- if (!setup.soft_scrolling && ScreenMovPos)
- sxx = syy = 0;
-
- if (player_is_opaque)
- DrawGraphicShifted(sx, sy, sxx, syy, graphic, frame,NO_CUTTING,NO_MASKING);
- else
- DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
-
- if (SHIELD_ON(player))
+ else if (req_state & REQ_CONFIRM)
+ {
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_CONFIRM], FALSE);
+ }
+ else if (req_state & REQ_PLAYER)
+ {
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_1], FALSE);
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_2], FALSE);
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_3], FALSE);
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_PLAYER_4], FALSE);
+ }
+#else
+ if (req_state & REQ_ASK)
{
- int graphic = (player->shield_deadly_time_left ? IMG_SHIELD_DEADLY_ACTIVE :
- IMG_SHIELD_NORMAL_ACTIVE);
- int frame = getGraphicAnimationFrame(graphic, -1);
-
- DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, frame, NO_CUTTING);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_YES]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_NO]);
}
-#endif
-
- /* ----------------------------------------------------------------------- */
- /* draw things in front of player (active dynamite or dynabombs) */
- /* ----------------------------------------------------------------------- */
-
- if (IS_ACTIVE_BOMB(element))
+ else if (req_state & REQ_CONFIRM)
{
- graphic = el2img(element);
- frame = getGraphicAnimationFrame(graphic, GfxFrame[jx][jy]);
-
- if (game.emulation == EMU_SUPAPLEX)
- DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
- else
- DrawGraphicThruMask(sx, sy, graphic, frame);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_CONFIRM]);
}
-
- if (player_is_moving && last_element == EL_EXPLOSION)
+ else if (req_state & REQ_PLAYER)
{
- int element = (GfxElement[last_jx][last_jy] != EL_UNDEFINED ?
- GfxElement[last_jx][last_jy] : EL_EMPTY);
- int graphic = el_act2img(element, ACTION_EXPLODING);
- int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
- int phase = ExplodePhase[last_jx][last_jy] - 1;
- int frame = getGraphicAnimationFrame(graphic, phase - delay);
-
- if (phase >= delay)
- DrawGraphicThruMask(SCREENX(last_jx), SCREENY(last_jy), graphic, frame);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_1]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_2]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_3]);
+ MapGadget(tool_gadget[TOOL_CTRL_ID_PLAYER_4]);
}
+#endif
+#endif
- /* ----------------------------------------------------------------------- */
- /* draw elements the player is just walking/passing through/under */
- /* ----------------------------------------------------------------------- */
+ ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
- if (player_is_moving)
+#if 0
+ for (i = 0; i < NUM_TOOL_BUTTONS; i++)
{
- /* handle the field the player is leaving ... */
- if (IS_ACCESSIBLE_INSIDE(last_element))
- DrawLevelField(last_jx, last_jy);
- else if (IS_ACCESSIBLE_UNDER(last_element))
- DrawLevelFieldThruMask(last_jx, last_jy);
+ 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
- /* do not redraw accessible elements if the player is just pushing them */
- if (!player_is_moving || !player->is_pushing)
+ if (!(req_state & REQUEST_WAIT_FOR_INPUT))
{
- /* ... and the field the player is entering */
- if (IS_ACCESSIBLE_INSIDE(element))
- DrawLevelField(jx, jy);
- else if (IS_ACCESSIBLE_UNDER(element))
- DrawLevelFieldThruMask(jx, jy);
- }
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
- MarkTileDirty(sx, sy);
-}
+ return FALSE;
+ }
-/* ------------------------------------------------------------------------- */
+#if 0
+ if (game_status != GAME_MODE_MAIN)
+ InitAnimation();
+#endif
-void WaitForEventToContinue()
-{
- boolean still_wait = TRUE;
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
- /* simulate releasing mouse button over last gadget, if still pressed */
- if (button_status)
- HandleGadgets(-1, -1, 0);
+ // ---------- handle request buttons ----------
+ result = RequestHandleEvents(req_state);
- button_status = MB_RELEASED;
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
-#if 1
- ClearEventQueue();
-#endif
+ UnmapToolButtons();
- while (still_wait)
- {
- if (PendingEvent())
- {
- Event event;
+ ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
- NextEvent(&event);
+ RemapAllGadgets();
- switch (event.type)
- {
- case EVENT_BUTTONPRESS:
- case EVENT_KEYPRESS:
- still_wait = FALSE;
- break;
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
- case EVENT_KEYRELEASE:
- ClearPlayerAction();
- break;
+#if defined(NETWORK_AVALIABLE)
+ /* continue network game after request */
+ if (options.network &&
+ game_status == GAME_MODE_PLAYING &&
+ req_state & REQUEST_WAIT_FOR_INPUT)
+ SendToServer_ContinuePlaying();
+#endif
- default:
- HandleOtherEvents(&event);
- break;
- }
- }
- else if (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED)
- {
- still_wait = FALSE;
- }
+ /* restore deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOn();
- DoAnimation();
+ return result;
+}
- /* don't eat all CPU time */
- Delay(10);
- }
+boolean Request(char *text, unsigned int req_state)
+{
+ if (global.use_envelope_request)
+ return RequestEnvelope(text, req_state);
+ else
+ return RequestDoor(text, req_state);
}
-#define MAX_REQUEST_LINES 13
-#define MAX_REQUEST_LINE_FONT1_LEN 7
-#define MAX_REQUEST_LINE_FONT2_LEN 10
+#else // =====================================================================
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 0
+ global.use_envelope_request = 1;
+#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);
break;
}
}
+#endif
if (game_status == GAME_MODE_PLAYING)
{
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,
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]);
DX, DY, DXSIZE, DYSIZE,
DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+#if 1
+ if (global.use_envelope_request)
+ {
+ ShowEnvelopeRequest(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))
{
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;
break;
case KSYM_Escape:
+#if defined(TARGET_SDL2)
+ case KSYM_Back:
+#endif
result = 0;
break;
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();
UnmapToolButtons();
+#if 1
+ if (global.use_envelope_request)
+ ShowEnvelopeRequest(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);
return result;
}
+#endif
+
unsigned int OpenDoor(unsigned int door_state)
{
if (door_state & DOOR_COPY_BACK)
{
static int door1 = DOOR_OPEN_1;
static int door2 = DOOR_CLOSE_2;
- unsigned long door_delay = 0;
- unsigned long door_delay_value;
+ unsigned int door_delay = 0;
+ unsigned int door_delay_value;
int stepsize = 1;
+#if 0
if (door_1.width < 0 || door_1.width > DXSIZE)
door_1.width = DXSIZE;
if (door_1.height < 0 || door_1.height > DYSIZE)
door_2.width = VXSIZE;
if (door_2.height < 0 || door_2.height > VYSIZE)
door_2.height = VYSIZE;
+#endif
if (door_state == DOOR_GET_STATE)
return (door1 | door2);
door_delay_value = (door_state & DOOR_ACTION_1 ? door_1.step_delay :
door_2.step_delay);
+ // door_delay_value *= 4; // !!! TEST ONLY !!!
+
if (setup.quick_doors)
{
stepsize = 20; /* must be chosen to always draw last frame */
boolean door_2_done = (!handle_door_2);
boolean door_1_vertical = (door_1.anim_mode & ANIM_VERTICAL);
boolean door_2_vertical = (door_2.anim_mode & ANIM_VERTICAL);
+#if 1
+ int door_size_1 = (door_1_vertical ? DYSIZE : DXSIZE);
+ int door_size_2 = (door_2_vertical ? VYSIZE : VXSIZE);
+#else
int door_size_1 = (door_1_vertical ? door_1.height : door_1.width);
int door_size_2 = (door_2_vertical ? door_2.height : door_2.width);
+#endif
int max_door_size_1 = (door_1_vertical ? DYSIZE : DXSIZE);
int max_door_size_2 = (door_2_vertical ? VYSIZE : VXSIZE);
int door_size = (handle_door_1 ? door_size_1 : door_size_2);
for (k = start; k <= end && !(door_1_done && door_2_done); k += stepsize)
{
int x = k;
+#if 1
Bitmap *bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
GC gc = bitmap->stored_clip_gc;
+#endif
if (door_state & DOOR_ACTION_1)
{
int p = (door_state & DOOR_OPEN_1 ? end - a : a);
int i = p + door_skip;
+#if 1
+ struct GraphicInfo *g_left = &graphic_info[IMG_DOOR_1_WING_LEFT];
+ struct GraphicInfo *g_right = &graphic_info[IMG_DOOR_1_WING_RIGHT];
+ Bitmap *bm_left = g_left->bitmap;
+ Bitmap *bm_right = g_right->bitmap;
+ GC gc_left = bm_left->stored_clip_gc;
+ GC gc_right = bm_right->stored_clip_gc;
+#endif
+
if (door_1.anim_mode & ANIM_STATIC_PANEL)
{
BlitBitmap(bitmap_db_door, drawto,
if (door_1.anim_mode & ANIM_HORIZONTAL && x <= DXSIZE)
{
+#if 1
+ int src1_x = g_right->src_x;
+ int src1_y = g_right->src_y;
+ int src2_x = g_left->src_x + g_left->width - i;
+ int src2_y = g_left->src_y;
+ int dst1_x = DX + DXSIZE - i;
+ int dst1_y = DY;
+ int dst2_x = DX;
+ int dst2_y = DY;
+ int width = i;
+ int height = DYSIZE;
+
+ SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+ BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+ dst1_x, dst1_y);
+
+ SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+ BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+ dst2_x, dst2_y);
+#else
int src1_x = DXSIZE, src1_y = DOOR_GFX_PAGEY1;
- int dst1_x = DX + DXSIZE - i, dst1_y = DY;
int src2_x = DXSIZE - i, src2_y = DOOR_GFX_PAGEY1;
+ int dst1_x = DX + DXSIZE - i, dst1_y = DY;
int dst2_x = DX, dst2_y = DY;
int width = i, height = DYSIZE;
SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
dst2_x, dst2_y);
+#endif
}
else if (door_1.anim_mode & ANIM_VERTICAL && x <= DYSIZE)
{
+#if 1
+ int src1_x = g_right->src_x;
+ int src1_y = g_right->src_y;
+ int src2_x = g_left->src_x;
+ int src2_y = g_left->src_y + g_left->height - i;
+ int dst1_x = DX;
+ int dst1_y = DY + DYSIZE - i;
+ int dst2_x = DX;
+ int dst2_y = DY;
+ int width = DXSIZE;
+ int height = i;
+
+ SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+ BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+ dst1_x, dst1_y);
+
+ SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+ BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+ dst2_x, dst2_y);
+#else
int src1_x = DXSIZE, src1_y = DOOR_GFX_PAGEY1;
- int dst1_x = DX, dst1_y = DY + DYSIZE - i;
int src2_x = 0, src2_y = DOOR_GFX_PAGEY1 + DYSIZE - i;
+ int dst1_x = DX, dst1_y = DY + DYSIZE - i;
int dst2_x = DX, dst2_y = DY;
int width = DXSIZE, height = i;
SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
dst2_x, dst2_y);
+#endif
}
else if (x <= DXSIZE) /* ANIM_DEFAULT */
{
int j = (door_1.anim_mode == ANIM_DEFAULT ? (DXSIZE - i) / 3 : 0);
+#if 1
+ int src1_x = g_right->src_x;
+ int src1_y = g_right->src_y;
+ int src2_x = g_left->src_x + g_left->width - i;
+ int src2_y = g_left->src_y;
+ int dst1_x = DX + DXSIZE - i;
+ int dst1_y = DY;
+ int dst2_x = DX;
+ int dst2_y = DY;
+ int width = i;
+ int height1 = 63, height2 = DYSIZE / 2 - height1;
+ int ypos1 = 0, ypos2 = height2;
+ int ypos3 = DYSIZE / 2, ypos4 = DYSIZE - height2;
+
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos1, width, height2,
+ dst1_x, dst1_y + ypos1 + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos3, width, height1,
+ dst1_x, dst1_y + ypos3 + j);
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos1 + j, width, height2 - j,
+ dst2_x, dst2_y + ypos1);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos3, width, height1,
+ dst2_x, dst2_y + ypos3 - j);
+
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos2, width, height1,
+ dst2_x, dst2_y + ypos2 - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos4, width, height2,
+ dst2_x, dst2_y + ypos4 - j);
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos2, width, height1,
+ dst1_x, dst1_y + ypos2 + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos4, width, height2 - j,
+ dst1_x, dst1_y + ypos4 + j);
+#else
+ int src1_x = DXSIZE, src1_y = DOOR_GFX_PAGEY1;
+ int src2_x = DXSIZE - i, src2_y = DOOR_GFX_PAGEY1;
+ int dst1_x = DX + DXSIZE - i, dst1_y = DY;
+ int dst2_x = DX, dst2_y = DY;
+ int width = i, height = DYSIZE;
+ int ypos1 = 63, ypos2 = 77, ypos3 = 140, ypos4 = 203;
+
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y, width, ypos2,
+ dst1_x, dst1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos3, width, ypos1,
+ dst1_x, dst1_y + ypos3 + j);
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + j, width, ypos2 - j,
+ dst2_x, dst2_y);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos3, width, ypos1,
+ dst2_x, dst2_y + ypos3 - j);
+
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos2, width, ypos1,
+ dst2_x, dst2_y + ypos2 - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos4, width, ypos2,
+ dst2_x, dst2_y + ypos4 - j);
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos2, width, ypos1,
+ dst1_x, dst1_y + ypos2 + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos4, width, ypos2 - j,
+ dst1_x, dst1_y + ypos4 + j);
+
+ /*
SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
BlitBitmapMasked(bitmap, drawto,
DXSIZE, DOOR_GFX_PAGEY1, i, 77,
BlitBitmapMasked(bitmap, drawto,
DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j,
DX + DXSIZE - i, DY + 203 + j);
+ */
+#endif
}
redraw_mask |= REDRAW_DOOR_1;
int p = (door_state & DOOR_OPEN_2 ? door_size - a : a);
int i = p + door_skip;
+#if 1
+ struct GraphicInfo *g_left = &graphic_info[IMG_DOOR_2_WING_LEFT];
+ struct GraphicInfo *g_right = &graphic_info[IMG_DOOR_2_WING_RIGHT];
+ Bitmap *bm_left = g_left->bitmap;
+ Bitmap *bm_right = g_right->bitmap;
+ GC gc_left = bm_left->stored_clip_gc;
+ GC gc_right = bm_right->stored_clip_gc;
+#endif
+
if (door_2.anim_mode & ANIM_STATIC_PANEL)
{
BlitBitmap(bitmap_db_door, drawto,
if (door_2.anim_mode & ANIM_HORIZONTAL && x <= VXSIZE)
{
+#if 1
+ int src1_x = g_right->src_x;
+ int src1_y = g_right->src_y;
+ int src2_x = g_left->src_x + g_left->width - i;
+ int src2_y = g_left->src_y;
+ int dst1_x = VX + VXSIZE - i;
+ int dst1_y = VY;
+ int dst2_x = VX;
+ int dst2_y = VY;
+ int width = i;
+ int height = VYSIZE;
+
+ SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+ BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+ dst1_x, dst1_y);
+
+ SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+ BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+ dst2_x, dst2_y);
+#else
int src1_x = VXSIZE, src1_y = DOOR_GFX_PAGEY2;
- int dst1_x = VX + VXSIZE - i, dst1_y = VY;
int src2_x = VXSIZE - i, src2_y = DOOR_GFX_PAGEY2;
+ int dst1_x = VX + VXSIZE - i, dst1_y = VY;
int dst2_x = VX, dst2_y = VY;
int width = i, height = VYSIZE;
SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
dst2_x, dst2_y);
+#endif
}
else if (door_2.anim_mode & ANIM_VERTICAL && x <= VYSIZE)
{
+#if 1
+ int src1_x = g_right->src_x;
+ int src1_y = g_right->src_y;
+ int src2_x = g_left->src_x;
+ int src2_y = g_left->src_y + g_left->height - i;
+ int dst1_x = VX;
+ int dst1_y = VY + VYSIZE - i;
+ int dst2_x = VX;
+ int dst2_y = VY;
+ int width = VXSIZE;
+ int height = i;
+
+ SetClipOrigin(bm_right, gc_right, dst1_x - src1_x, dst1_y - src1_y);
+ BlitBitmapMasked(bm_right, drawto, src1_x, src1_y, width, height,
+ dst1_x, dst1_y);
+
+ SetClipOrigin(bm_left, gc_left, dst2_x - src2_x, dst2_y - src2_y);
+ BlitBitmapMasked(bm_left, drawto, src2_x, src2_y, width, height,
+ dst2_x, dst2_y);
+#else
int src1_x = VXSIZE, src1_y = DOOR_GFX_PAGEY2;
- int dst1_x = VX, dst1_y = VY + VYSIZE - i;
int src2_x = 0, src2_y = DOOR_GFX_PAGEY2 + VYSIZE - i;
+ int dst1_x = VX, dst1_y = VY + VYSIZE - i;
int dst2_x = VX, dst2_y = VY;
int width = VXSIZE, height = i;
SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y);
BlitBitmapMasked(bitmap, drawto, src2_x, src2_y, width, height,
dst2_x, dst2_y);
+#endif
}
else if (x <= VXSIZE) /* ANIM_DEFAULT */
{
int j = (door_2.anim_mode == ANIM_DEFAULT ? (VXSIZE - i) / 3 : 0);
+#if 1
+ int src1_x = g_right->src_x;
+ int src1_y = g_right->src_y;
+ int src2_x = g_left->src_x + g_left->width - i;
+ int src2_y = g_left->src_y;
+ int dst1_x = VX + VXSIZE - i;
+ int dst1_y = VY;
+ int dst2_x = VX;
+ int dst2_y = VY;
+ int width = i;
+ int height = VYSIZE / 2;
+ int ypos1 = 0, ypos2 = VYSIZE / 2;
+
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos1, width, height,
+ dst1_x, dst1_y + ypos1 + j);
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos1 + j, width, height - j,
+ dst2_x, dst2_y + ypos1);
+
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src2_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos2, width, height,
+ dst2_x, dst2_y + ypos2 - j);
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos2, width, height - j,
+ dst1_x, dst1_y + ypos2 + j);
+#else
+ int src1_x = VXSIZE, src1_y = DOOR_GFX_PAGEY2;
+ int src2_x = VXSIZE - i, src2_y = DOOR_GFX_PAGEY2;
+ int dst1_x = VX + VXSIZE - i, dst1_y = VY;
+ int dst2_x = VX, dst2_y = VY;
+ int width = i, height = VYSIZE;
+ int ypos = VYSIZE / 2;
+
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y, width, ypos,
+ dst1_x, dst1_y + j);
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src1_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + j, width, ypos - j,
+ dst2_x, dst2_y);
+
+ SetClipOrigin(bitmap, gc, dst2_x - src2_x, dst2_y - src1_y - j);
+ BlitBitmapMasked(bitmap, drawto,
+ src2_x, src2_y + ypos, width, ypos,
+ dst2_x, dst2_y + ypos - j);
+ SetClipOrigin(bitmap, gc, dst1_x - src1_x, dst1_y - src1_y + j);
+ BlitBitmapMasked(bitmap, drawto,
+ src1_x, src1_y + ypos, width, ypos - j,
+ dst1_x, dst1_y + ypos + j);
+
+ /*
SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
BlitBitmapMasked(bitmap, drawto,
VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2,
VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2,
i, VYSIZE / 2 - j,
VX + VXSIZE - i, VY + VYSIZE / 2 + j);
+ */
+#endif
}
redraw_mask |= REDRAW_DOOR_2;
void DrawSpecialEditorDoor()
{
- /* draw bigger toolbox window */
+#if 1
+ struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
+ int top_border_width = gfx1->width;
+ int top_border_height = gfx1->height;
+ int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
+ int ex = EX - outer_border;
+ int ey = EY - outer_border;
+ int vy = VY - outer_border;
+ int exsize = EXSIZE + 2 * outer_border;
+
+ CloseDoor(DOOR_CLOSE_2);
+
+ /* draw bigger level editor toolbox window */
+ BlitBitmap(gfx1->bitmap, drawto, gfx1->src_x, gfx1->src_y,
+ top_border_width, top_border_height, ex, ey - top_border_height);
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto, ex, vy,
+ exsize, EYSIZE - VYSIZE + outer_border, ex, ey);
+#else
+ /* draw bigger level editor toolbox window */
BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
- DOOR_GFX_PAGEX7, 0, EXSIZE + 8, 8,
- EX - 4, EY - 12);
+ DOOR_GFX_PAGEX7, 0, EXSIZE + 8, 8,
+ EX - 4, EY - 12);
BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
- EX - 6, VY - 4, EXSIZE + 12, EYSIZE - VYSIZE + 4,
- EX - 6, EY - 4);
+ EX - 6, VY - 4, EXSIZE + 12, EYSIZE - VYSIZE + 4,
+ EX - 6, EY - 4);
+#endif
redraw_mask |= REDRAW_ALL;
}
void UndrawSpecialEditorDoor()
{
+#if 1
+ struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
+ int top_border_width = gfx1->width;
+ int top_border_height = gfx1->height;
+ int outer_border = viewport.door_2[GAME_MODE_EDITOR].border_size;
+ int ex = EX - outer_border;
+ int ey = EY - outer_border;
+ int ey_top = ey - top_border_height;
+ int exsize = EXSIZE + 2 * outer_border;
+ int eysize = EYSIZE + 2 * outer_border;
+
+ /* draw normal tape recorder window */
+ if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
+ {
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+ ex, ey_top, top_border_width, top_border_height,
+ ex, ey_top);
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
+ ex, ey, exsize, eysize, ex, ey);
+ }
+ else
+ {
+ // if screen background is set to "[NONE]", clear editor toolbox window
+ ClearRectangle(drawto, ex, ey_top, top_border_width, top_border_height);
+ ClearRectangle(drawto, ex, ey, exsize, eysize);
+ }
+#else
/* draw normal tape recorder window */
BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, drawto,
- EX - 6, EY - 12, EXSIZE + 12, EYSIZE - VYSIZE + 12,
- EX - 6, EY - 12);
+ EX - 6, EY - 12, EXSIZE + 12, EYSIZE - VYSIZE + 12,
+ EX - 6, EY - 12);
+#endif
redraw_mask |= REDRAW_ALL;
}
/* ---------- new tool button stuff ---------------------------------------- */
+#if 1
+
+static struct
+{
+ int graphic;
+ struct TextPosInfo *pos;
+ int gadget_id;
+ char *infotext;
+} toolbutton_info[NUM_TOOL_BUTTONS] =
+{
+ {
+ IMG_REQUEST_BUTTON_GFX_YES, &request.button.yes,
+ TOOL_CTRL_ID_YES, "yes"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_NO, &request.button.no,
+ TOOL_CTRL_ID_NO, "no"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_CONFIRM, &request.button.confirm,
+ TOOL_CTRL_ID_CONFIRM, "confirm"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_1, &request.button.player_1,
+ TOOL_CTRL_ID_PLAYER_1, "player 1"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_2, &request.button.player_2,
+ TOOL_CTRL_ID_PLAYER_2, "player 2"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_3, &request.button.player_3,
+ TOOL_CTRL_ID_PLAYER_3, "player 3"
+ },
+ {
+ IMG_REQUEST_BUTTON_GFX_PLAYER_4, &request.button.player_4,
+ TOOL_CTRL_ID_PLAYER_4, "player 4"
+ }
+};
+
+void CreateToolButtons()
+{
+ int i;
+
+ for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+ {
+ struct GraphicInfo *gfx = &graphic_info[toolbutton_info[i].graphic];
+ struct TextPosInfo *pos = toolbutton_info[i].pos;
+ struct GadgetInfo *gi;
+ Bitmap *deco_bitmap = None;
+ int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
+ unsigned int event_mask = GD_EVENT_RELEASED;
+ int dx = DX;
+ int dy = DY;
+ int gd_x = gfx->src_x;
+ int gd_y = gfx->src_y;
+ int gd_xp = gfx->src_x + gfx->pressed_xoffset;
+ int gd_yp = gfx->src_y + gfx->pressed_yoffset;
+ int id = i;
+
+ if (global.use_envelope_request)
+ setRequestPosition(&dx, &dy, TRUE);
+
+ if (id >= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4)
+ {
+ int player_nr = id - TOOL_CTRL_ID_PLAYER_1;
+
+ getSizedGraphicSource(PLAYER_NR_GFX(IMG_PLAYER_1, player_nr), 0,
+ pos->size, &deco_bitmap, &deco_x, &deco_y);
+ deco_xpos = (gfx->width - pos->size) / 2;
+ deco_ypos = (gfx->height - pos->size) / 2;
+ }
+
+ gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_INFO_TEXT, toolbutton_info[i].infotext,
+ GDI_X, dx + pos->x,
+ GDI_Y, dy + pos->y,
+ GDI_WIDTH, gfx->width,
+ GDI_HEIGHT, gfx->height,
+ GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
+ GDI_STATE, GD_BUTTON_UNPRESSED,
+ GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
+ GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
+ GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y,
+ GDI_DECORATION_POSITION, deco_xpos, deco_ypos,
+ GDI_DECORATION_SIZE, pos->size, pos->size,
+ GDI_DECORATION_SHIFTING, 1, 1,
+ GDI_DIRECT_DRAW, FALSE,
+ GDI_EVENT_MASK, event_mask,
+ GDI_CALLBACK_ACTION, HandleToolButtons,
+ GDI_END);
+
+ if (gi == NULL)
+ Error(ERR_EXIT, "cannot create gadget");
+
+ tool_gadget[id] = gi;
+ }
+}
+
+#else
+
/* graphic position values for tool buttons */
#define TOOL_BUTTON_YES_XPOS 2
#define TOOL_BUTTON_YES_YPOS 250
Bitmap *deco_bitmap = None;
int deco_x = 0, deco_y = 0, deco_xpos = 0, deco_ypos = 0;
struct GadgetInfo *gi;
- unsigned long event_mask;
+ unsigned int event_mask;
int gd_xoffset, gd_yoffset;
int gd_x1, gd_x2, gd_y;
int id = i;
}
}
+#endif
+
void FreeToolButtons()
{
int i;
return game_frame_delay_value;
}
-unsigned int InitRND(long seed)
+unsigned int InitRND(int seed)
{
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
return InitEngineRandom_EM(seed);
case Yacid_splash_wB:
return (frame_em > 5 ? EL_EMPTY : element);
+#if 0
+ /* !!! FIX !!! */
+ case Ydiamond_stone:
+ // if (!game.use_native_emc_graphics_engine)
+ return EL_ROCK;
+#endif
+
default:
return element;
}
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;
}
#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
#endif
}
+void CheckSingleStepMode_EM(byte action[MAX_PLAYERS], int frame,
+ boolean any_player_moving,
+ boolean player_is_dropping)
+{
+ if (tape.single_step && tape.recording && !tape.pausing)
+ {
+#if 0
+ boolean active_players = FALSE;
+ int i;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (action[i] != JOY_NO_ACTION)
+ active_players = TRUE;
+#endif
+
+ // 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)
{
#endif
}
-void ToggleFullscreenIfNeeded()
+void ToggleFullscreenOrChangeWindowScalingIfNeeded()
{
boolean change_fullscreen = (setup.fullscreen !=
video.fullscreen_enabled);
boolean change_fullscreen_mode = (video.fullscreen_enabled &&
!strEqual(setup.fullscreen_mode,
video.fullscreen_mode_current));
+ boolean change_window_scaling_percent = (!video.fullscreen_enabled &&
+ setup.window_scaling_percent !=
+ video.window_scaling_percent);
- if (!video.fullscreen_available)
+ if (change_window_scaling_percent && video.fullscreen_enabled)
return;
-#if 1
- if (change_fullscreen || change_fullscreen_mode)
-#else
- if (setup.fullscreen != video.fullscreen_enabled ||
- setup.fullscreen_mode != video.fullscreen_mode_current)
+ if (!change_window_scaling_percent && !video.fullscreen_available)
+ return;
+
+#if defined(TARGET_SDL2)
+ if (change_window_scaling_percent)
+ {
+ SDLSetWindowScaling(setup.window_scaling_percent);
+
+ return;
+ }
+ else if (change_fullscreen)
+ {
+ SDLSetWindowFullscreen(setup.fullscreen);
+
+ /* set setup value according to successfully changed fullscreen mode */
+ setup.fullscreen = video.fullscreen_enabled;
+
+ return;
+ }
#endif
+
+ if (change_fullscreen ||
+ change_fullscreen_mode ||
+ change_window_scaling_percent)
{
Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
/* save backbuffer content which gets lost when toggling fullscreen mode */
BlitBitmap(backbuffer, tmp_backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
-#if 1
if (change_fullscreen_mode)
-#else
- if (setup.fullscreen && video.fullscreen_enabled)
-#endif
{
/* keep fullscreen, but change fullscreen mode (screen resolution) */
-#if 1
- /* (this is now set in sdl.c) */
-#else
- video.fullscreen_mode_current = setup.fullscreen_mode;
-#endif
video.fullscreen_enabled = FALSE; /* force new fullscreen mode */
}
+ if (change_window_scaling_percent)
+ {
+ /* keep window mode, but change window scaling */
+ video.fullscreen_enabled = TRUE; /* force new window scaling */
+ }
+
/* toggle fullscreen */
ChangeVideoModeIfNeeded(setup.fullscreen);
+ /* set setup value according to successfully changed fullscreen mode */
setup.fullscreen = video.fullscreen_enabled;
/* restore backbuffer content from temporary backbuffer backup bitmap */
#endif
}
}
+
+void ChangeViewportPropertiesIfNeeded()
+{
+#if 0
+ int *door_1_x = &DX;
+ int *door_1_y = &DY;
+ int *door_2_x = (game_status == GAME_MODE_EDITOR ? &EX : &VX);
+ int *door_2_y = (game_status == GAME_MODE_EDITOR ? &EY : &VY);
+#endif
+ int gfx_game_mode = (game_status == GAME_MODE_PLAYING ||
+ game_status == GAME_MODE_EDITOR ? game_status :
+ GAME_MODE_MAIN);
+ int gfx_game_mode2 = (game_status == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
+ game_status);
+ struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
+ struct RectWithBorder *vp_door_1 = &viewport.door_1[gfx_game_mode];
+ struct RectWithBorder *vp_door_2 = &viewport.door_2[gfx_game_mode2];
+ struct RectWithBorder *vp_door_3 = &viewport.door_2[GAME_MODE_EDITOR];
+ 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;
+ int new_dx = vp_door_1->x;
+ int new_dy = vp_door_1->y;
+ int new_dxsize = vp_door_1->width;
+ int new_dysize = vp_door_1->height;
+ int new_vx = vp_door_2->x;
+ int new_vy = vp_door_2->y;
+ int new_vxsize = vp_door_2->width;
+ int new_vysize = vp_door_2->height;
+ int new_ex = vp_door_3->x;
+ int new_ey = vp_door_3->y;
+ int new_exsize = vp_door_3->width;
+ int new_eysize = vp_door_3->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)
+ {
+ 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();
+
+#if 1
+ SetDrawDeactivationMask(REDRAW_NONE);
+ SetDrawBackgroundMask(REDRAW_FIELD);
+
+ // RedrawBackground();
+#endif
+#endif
+
+ // printf("::: video: init_video_buffer, init_gfx_buffers\n");
+ }
+
+ if (new_scr_fieldx != SCR_FIELDX ||
+ 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 ||
+ new_dx != DX ||
+ new_dy != DY ||
+ new_vx != VX ||
+ new_vy != VY ||
+ new_ex != EX ||
+ new_ey != EY ||
+ new_sxsize != SXSIZE ||
+ new_sysize != SYSIZE ||
+ new_dxsize != DXSIZE ||
+ new_dysize != DYSIZE ||
+ new_vxsize != VXSIZE ||
+ new_vysize != VYSIZE ||
+ new_exsize != EXSIZE ||
+ new_eysize != EYSIZE ||
+ 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
+#if 0
+ ||
+ 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
+#endif
+ )
+ {
+ SX = new_sx;
+ SY = new_sy;
+ DX = new_dx;
+ DY = new_dy;
+ VX = new_vx;
+ VY = new_vy;
+ EX = new_ex;
+ EY = new_ey;
+ SXSIZE = new_sxsize;
+ SYSIZE = new_sysize;
+ DXSIZE = new_dxsize;
+ DYSIZE = new_dysize;
+ VXSIZE = new_vxsize;
+ VYSIZE = new_vysize;
+ EXSIZE = new_exsize;
+ EYSIZE = new_eysize;
+ 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
+
+#if 0
+ *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;
+#endif
+
+#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
+}