{
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)
}
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;
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 */
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)
{
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 DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
}
#endif
+#if NEW_TILESIZE
+ BlitBitmap(src_bitmap, drawto_field,
+ src_x + cx * TILESIZE_VAR / TILESIZE,
+ src_y + cy * TILESIZE_VAR / TILESIZE,
+ width * TILESIZE_VAR / TILESIZE,
+ height * TILESIZE_VAR / TILESIZE,
+ FX + sx * TILEX_VAR + cx * TILESIZE_VAR / TILESIZE,
+ FY + sy * TILEY_VAR + cy * TILESIZE_VAR / TILESIZE);
+#else
BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
width, height, FX + sx * TILEX + cx, FY + sy * TILEY + cy);
+#endif
/* (remaining middle border part must be at least as big as corner part) */
if (!(graphic_info[graphic].style & STYLE_ACCURATE_BORDERS) ||
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
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, 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
}
}
-void AnimateEnvelopeDoor(char *text, int anim_mode, int action)
+void ShowEnvelope(int envelope_nr)
{
-#if 1
- int envelope_nr = 0;
-#endif
+ int element = EL_ENVELOPE_1 + envelope_nr;
int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
- Bitmap *src_bitmap = graphic_info[graphic].bitmap;
- int mask_mode = (src_bitmap != NULL ? BLIT_MASKED : BLIT_ON_BACKGROUND);
+ int sound_opening = element_info[element].sound[ACTION_OPENING];
+ int sound_closing = element_info[element].sound[ACTION_CLOSING];
boolean ffwd_delay = (tape.playing && tape.fast_forward);
boolean no_delay = (tape.warp_forward);
- unsigned long anim_delay = 0;
+ int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
+ int wait_delay_value = (no_delay ? 0 : normal_delay_value);
+ int anim_mode = graphic_info[graphic].anim_mode;
+ int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
+ anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
+
+ game.envelope_active = TRUE; /* needed for RedrawPlayfield() events */
+
+ PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
+
+ if (anim_mode == ANIM_DEFAULT)
+ AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
+
+ AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
+
+ if (tape.playing)
+ Delay(wait_delay_value);
+ else
+ WaitForEventToContinue();
+
+ PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
+
+ if (anim_mode != ANIM_NONE)
+ AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
+
+ if (anim_mode == ANIM_DEFAULT)
+ AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
+
+ game.envelope_active = FALSE;
+
+ SetDrawtoField(DRAW_BUFFERED);
+
+ redraw_mask |= REDRAW_FIELD;
+ BackToFront();
+}
+
+static void setRequestPosition(int *x, int *y, boolean add_border_size)
+{
+ 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;
+
+ if (add_border_size)
+ {
+ sx += border_size;
+ sy += border_size;
+ }
+
+ *x = sx;
+ *y = sy;
+}
+
+void DrawEnvelopeRequest(char *text)
+{
+ 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 (*src_text_ptr != ' ')
+ *dst_text_ptr++ = *src_text_ptr;
+
+ src_text_ptr++;
+ }
+
+ *dst_text_ptr = '\0';
+
+ text_final = text_door_style;
+ }
+
+ setRequestPosition(&sx, &sy, FALSE);
+
+ ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
+
+ 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);
+
+ 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);
+
+ for (i = 0; i < NUM_TOOL_BUTTONS; i++)
+ RedrawGadget(tool_gadget[i]);
+
+ // store readily prepared envelope request for later use when animating
+ BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+
+#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);
+
+ redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+ BackToFront();
+
+ Delay(3000);
+
+ BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+
+ redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+ BackToFront();
+
+ Delay(1000);
+#endif
+
+ if (text_door_style)
+ free(text_door_style);
+}
+
+#if 1
+
+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 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
+ 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
+ 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
+ redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+ // redraw_mask |= REDRAW_ALL | REDRAW_FROM_BACKBUFFER;
+#else
+ redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
+#endif
+
+#if 1
+ DoAnimation();
+ BackToFront();
+#else
+ BackToFront();
+#endif
+
+ WaitUntilDelayReached(&anim_delay, anim_delay_value / 2);
+ }
+}
+
+#else
+
+void AnimateEnvelopeRequest(char *text, int anim_mode, int action)
+{
+#if 0
+ int envelope_nr = 0;
+#endif
+#if 1
+ int graphic = IMG_BACKGROUND_REQUEST;
+#else
+ 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);
+ 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);
#endif
int font_width = getFontWidth(font_nr);
int font_height = getFontHeight(font_nr);
+ int line_spacing = 2 * 1;
#if 1
#if 1
int max_xsize = DXSIZE / font_width;
- int max_ysize = DYSIZE / font_height;
+ // 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 */
{
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 = SX + (SYSIZE - ysize * font_height) / 2;
+ int sy = SY + (SYSIZE - ysize * (font_height + line_spacing)) / 2;
int xx, yy;
#if 1
#else
SetDrawtoField(DRAW_BUFFERED);
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
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++)
- DrawEnvelopeBackground(envelope_nr, sx,sy, xx,yy, xsize, ysize, font_nr);
+ 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
#if 1
- DrawTextBuffer(SX + sx + font_width, SY + sy + font_height + 8,
+ DrawTextBuffer(sx + font_width, sy + font_height + 8,
text_copy, font_nr, max_xsize,
- xsize - 2, ysize - 2, 2, mask_mode,
+ xsize - 2, ysize - 2, line_spacing, mask_mode,
FALSE, TRUE, FALSE);
#else
- 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, 0, mask_mode,
level.envelope[envelope_nr].autowrap,
#endif
#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
/* copy request gadgets to door backbuffer */
#if 1
+ /*
if ((ysize - 2) > 13)
BlitBitmap(bitmap_db_door, drawto,
DOOR_GFX_PAGEX1 + (DXSIZE - (xsize - 2) * font_width) / 2,
DOOR_GFX_PAGEY1 + 13 * font_height,
(xsize - 2) * font_width,
(ysize - 2 - 13) * font_height,
- SX + sx + font_width,
- SY + sy + font_height * (1 + 13));
+ 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_PAGEY1 + 13 * font_height,
(xsize - 2) * font_width,
(ysize - 2 - 13) * font_height,
- SX + sx + font_width,
- SY + sy + font_height * (1 + 13));
+ sx + font_width,
+ sy + font_height * (1 + 13));
#endif
#if 1
#endif
}
-void ShowEnvelope(int envelope_nr)
-{
- int element = EL_ENVELOPE_1 + envelope_nr;
- int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
- int sound_opening = element_info[element].sound[ACTION_OPENING];
- int sound_closing = element_info[element].sound[ACTION_CLOSING];
- boolean ffwd_delay = (tape.playing && tape.fast_forward);
- boolean no_delay = (tape.warp_forward);
- int normal_delay_value = ONE_SECOND_DELAY / (ffwd_delay ? 2 : 1);
- int wait_delay_value = (no_delay ? 0 : normal_delay_value);
- int anim_mode = graphic_info[graphic].anim_mode;
- int main_anim_mode = (anim_mode == ANIM_NONE ? ANIM_VERTICAL|ANIM_HORIZONTAL:
- anim_mode == ANIM_DEFAULT ? ANIM_VERTICAL : anim_mode);
-
- game.envelope_active = TRUE; /* needed for RedrawPlayfield() events */
-
- PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
-
- if (anim_mode == ANIM_DEFAULT)
- AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_OPENING);
-
- AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_OPENING);
-
- if (tape.playing)
- Delay(wait_delay_value);
- else
- WaitForEventToContinue();
-
- PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
-
- if (anim_mode != ANIM_NONE)
- AnimateEnvelope(envelope_nr, main_anim_mode, ACTION_CLOSING);
-
- if (anim_mode == ANIM_DEFAULT)
- AnimateEnvelope(envelope_nr, ANIM_DEFAULT, ACTION_CLOSING);
-
- game.envelope_active = FALSE;
-
- SetDrawtoField(DRAW_BUFFERED);
-
- redraw_mask |= REDRAW_FIELD;
- BackToFront();
-}
+#endif
-void ShowEnvelopeDoor(char *text, int action)
+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;
- int envelope_nr = 0;
#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 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;
+
+ for (text_ptr = text_copy; *text_ptr; text_ptr++)
+ if (*text_ptr == ' ')
+ *text_ptr = '\n';
+#endif
#if 1
if (game_status == GAME_MODE_PLAYING)
{
BlitBitmap(backbuffer, bitmap_db_store, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+#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
+
if (game_status != GAME_MODE_MAIN)
InitAnimation();
}
PlayMenuSoundStereo(sound_opening, SOUND_MIDDLE);
if (anim_mode == ANIM_DEFAULT)
- AnimateEnvelopeDoor(text, ANIM_DEFAULT, ACTION_OPENING);
+ AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_OPENING);
- AnimateEnvelopeDoor(text, main_anim_mode, ACTION_OPENING);
+ AnimateEnvelopeRequest(main_anim_mode, ACTION_OPENING);
#if 0
if (tape.playing)
PlayMenuSoundStereo(sound_closing, SOUND_MIDDLE);
if (anim_mode != ANIM_NONE)
- AnimateEnvelopeDoor(text, main_anim_mode, ACTION_CLOSING);
+ AnimateEnvelopeRequest(main_anim_mode, ACTION_CLOSING);
if (anim_mode == ANIM_DEFAULT)
- AnimateEnvelopeDoor(text, ANIM_DEFAULT, ACTION_CLOSING);
+ AnimateEnvelopeRequest(ANIM_DEFAULT, ACTION_CLOSING);
}
game.envelope_active = FALSE;
#if 1
- game_status = last_game_status; /* restore current game status */
+ // game_status = last_game_status; /* restore current game status */
if (action == ACTION_CLOSING)
{
BackToFront();
+ /* (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
}
void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
redraw_mask |= REDRAW_FIELD;
}
-static void DrawPreviewLevelExt(int from_x, int from_y)
+static void DrawPreviewLevelPlayfieldExt(int from_x, int from_y)
{
boolean show_level_border = (BorderElement != EL_EMPTY);
int level_xsize = lev_fieldx + (show_level_border ? 2 : 0);
redraw_mask |= REDRAW_MICROLEVEL;
}
-void DrawPreviewLevel(boolean restart)
+static void DrawPreviewLevelExt(boolean restart)
{
- static unsigned long scroll_delay = 0;
- static unsigned long label_delay = 0;
+ 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 long scroll_delay_value = preview.step_delay;
+ 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);
label_state = 1;
label_counter = 0;
- DrawPreviewLevelExt(from_x, from_y);
+ DrawPreviewLevelPlayfieldExt(from_x, from_y);
DrawPreviewLevelLabelExt(label_state);
/* initialize delay counters */
break;
}
- DrawPreviewLevelExt(from_x, from_y);
+ DrawPreviewLevelPlayfieldExt(from_x, from_y);
}
/* !!! THIS ALL SUCKS -- SHOULD BE CLEANLY REWRITTEN !!! */
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)
{
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);
#define MAX_REQUEST_LINE_FONT1_LEN 7
#define MAX_REQUEST_LINE_FONT2_LEN 10
-boolean Request(char *text, unsigned int req_state)
-{
- int mx, my, ty, result = -1;
- 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;
- boolean use_envelope_request = TRUE * 0;
-#if 0
- int max_word_len = 0;
-#endif
- char *text_ptr;
- int i;
-
-#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);
-
- if (max_word_len > MAX_REQUEST_LINE_FONT1_LEN)
- {
- max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
-#if 1
- font_nr = FONT_TEXT_1;
-#else
- font_nr = FONT_LEVEL_NUMBER;
-#endif
-
- break;
- }
- }
-#endif
-
- 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
-
- old_door_state = GetDoorState();
-
- /* simulate releasing mouse button over last gadget, if still pressed */
- if (button_status)
- HandleGadgets(-1, -1, 0);
-
- UnmapAllGadgets();
-
-#if 1
- if (old_door_state & DOOR_OPEN_1 && !use_envelope_request)
-#else
- if (old_door_state & DOOR_OPEN_1)
-#endif
- {
- CloseDoor(DOOR_CLOSE_1);
-
- /* 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);
- }
-
-#if 1
- SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
-#endif
-
- 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++)
- {
- 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++)
- {
- tc = *(text_ptr + tx);
- if (!tc || tc == ' ')
- break;
- }
-
- if (!tl)
- {
- text_ptr++;
- ty--;
- continue;
- }
-
- 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);
- }
-
- game_status = last_game_status; /* restore current game status */
-
-#if 1
- if (use_envelope_request)
- {
- /* !!! TMP !!! */
- FreeToolButtons();
- CreateToolButtons();
- }
-#endif
-
- 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]);
- }
-
- /* copy request gadgets to door backbuffer */
- BlitBitmap(drawto, bitmap_db_door,
- DX, DY, DXSIZE, DYSIZE,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
-
-#if 1
- if (use_envelope_request)
- {
- ShowEnvelopeDoor(text, ACTION_OPENING);
-
- for (i = 0; i < NUM_TOOL_BUTTONS; i++)
- {
- if ((req_state & REQ_ASK && (i == TOOL_CTRL_ID_YES ||
- i == TOOL_CTRL_ID_NO)) ||
- (req_state & REQ_CONFIRM && i == TOOL_CTRL_ID_CONFIRM) ||
- (req_state & REQ_PLAYER && (i == TOOL_CTRL_ID_PLAYER_1 &&
- i == TOOL_CTRL_ID_PLAYER_2 &&
- i == TOOL_CTRL_ID_PLAYER_3 &&
- i == TOOL_CTRL_ID_PLAYER_4)))
- {
- int x = tool_gadget[i]->x + dDX;
- int y = tool_gadget[i]->y + dDY;
-
- ModifyGadget(tool_gadget[i], GDI_X, x, GDI_Y, y, GDI_END);
- }
- }
- }
-#endif
-
#if 1
- if (!use_envelope_request)
- OpenDoor(DOOR_OPEN_1);
-#else
- OpenDoor(DOOR_OPEN_1);
-#endif
-
- if (!(req_state & REQUEST_WAIT_FOR_INPUT))
- {
- if (game_status == GAME_MODE_PLAYING)
- {
- SetPanelBackground();
- SetDrawBackgroundMask(REDRAW_DOOR_1);
- }
- else
- {
- SetDrawBackgroundMask(REDRAW_FIELD);
- }
- return FALSE;
- }
-
-#if 1
- if (game_status != GAME_MODE_MAIN && !use_envelope_request)
- InitAnimation();
-#else
- if (game_status != GAME_MODE_MAIN)
- InitAnimation();
-#endif
+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;
-
- SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+ result = -1;
while (result < 0)
{
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();
#endif
}
- if (game_status != GAME_MODE_MAIN)
- StopAnimation();
-
- UnmapToolButtons();
+ return result;
+}
-#if 1
- if (use_envelope_request)
- ShowEnvelopeDoor(text, ACTION_CLOSING);
-#endif
+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 1
- if (!(req_state & REQ_STAY_OPEN) && !use_envelope_request)
-#else
- if (!(req_state & REQ_STAY_OPEN))
-#endif
+ if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN)
{
- CloseDoor(DOOR_CLOSE_1);
-
- if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
- (req_state & REQ_REOPEN))
- OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+ max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
+ font_nr = FONT_TEXT_1;
}
- RemapAllGadgets();
+ 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
+
+ old_door_state = GetDoorState();
+
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ UnmapAllGadgets();
+
+ /* draw released gadget before proceeding */
+ // BackToFront();
+
+ if (old_door_state & DOOR_OPEN_1)
+ {
+ CloseDoor(DOOR_CLOSE_1);
+
+ /* 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++)
+ {
+ 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++)
+ {
+ tc = *(text_ptr + tx);
+ // if (!tc || tc == ' ')
+ if (!tc || tc == ' ' || tc == '?' || tc == '!')
+ break;
+ }
+
+ if ((tc == '?' || tc == '!') && tl == 0)
+ tl = 1;
+
+ if (!tl)
+ {
+ text_ptr++;
+ ty--;
+ continue;
+ }
+
+ 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]);
+ }
+
+ /* copy request gadgets to door backbuffer */
+ BlitBitmap(drawto, bitmap_db_door,
+ DX, DY, DXSIZE, DYSIZE,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+
+ OpenDoor(DOOR_OPEN_1);
+
+ if (!(req_state & REQUEST_WAIT_FOR_INPUT))
+ {
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
+
+ return FALSE;
+ }
+
+ if (game_status != GAME_MODE_MAIN)
+ InitAnimation();
+
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ // ---------- handle request buttons ----------
+ result = RequestHandleEvents(req_state);
+
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
+
+ UnmapToolButtons();
+
+ if (!(req_state & REQ_STAY_OPEN))
+ {
+ CloseDoor(DOOR_CLOSE_1);
+
+ if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
+ (req_state & REQ_REOPEN))
+ OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+ }
+
+ RemapAllGadgets();
+
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ 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
+
+ /* 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
+ int i;
+#endif
+
+ 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
+
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ UnmapAllGadgets();
+
+ // (replace with setting corresponding request background)
+ // SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+ // SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ /* clear door drawing field */
+ // DrawBackground(DX, DY, DXSIZE, DYSIZE);
+
+#if 0
+ if (global.use_envelope_request)
+ {
+ /* !!! TMP !!! */
+ FreeToolButtons();
+ CreateToolButtons();
+ }
+#endif
+
+#if 0
+#if 0
+ if (req_state & REQ_ASK)
+ {
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_YES], FALSE);
+ MapGadgetExt(tool_gadget[TOOL_CTRL_ID_NO], FALSE);
+ }
+ 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)
+ {
+ 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
+#endif
+
+ ShowEnvelopeRequest(text, req_state, ACTION_OPENING);
+
+#if 0
+ 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 (!(req_state & REQUEST_WAIT_FOR_INPUT))
+ {
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
+
+ return FALSE;
+ }
+
+#if 0
+ if (game_status != GAME_MODE_MAIN)
+ InitAnimation();
+#endif
+
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
+
+ // ---------- handle request buttons ----------
+ result = RequestHandleEvents(req_state);
+
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
+
+ UnmapToolButtons();
+
+ ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
+
+ RemapAllGadgets();
+
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ 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
+
+ /* restore deactivated drawing when quick-loading level tape recording */
+ if (tape.playing && tape.deactivate_display)
+ TapeDeactivateDisplayOn();
+
+ return result;
+}
+
+boolean Request(char *text, unsigned int req_state)
+{
+ if (global.use_envelope_request)
+ return RequestEnvelope(text, req_state);
+ else
+ return RequestDoor(text, req_state);
+}
+
+#else // =====================================================================
+
+boolean Request(char *text, unsigned int req_state)
+{
+ int mx, my, ty, result = -1;
+ 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;
+#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);
+
+ if (max_word_len > MAX_REQUEST_LINE_FONT1_LEN)
+ {
+ max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
+#if 1
+ font_nr = FONT_TEXT_1;
+#else
+ font_nr = FONT_LEVEL_NUMBER;
+#endif
+
+ break;
+ }
+ }
+#endif
+
+ 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
+
+ old_door_state = GetDoorState();
+
+ /* simulate releasing mouse button over last gadget, if still pressed */
+ if (button_status)
+ HandleGadgets(-1, -1, 0);
+
+ 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,
+ DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
+ DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1);
+ }
+
+#if 1
+ SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+#endif
+
+ 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++)
+ {
+ 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++)
+ {
+ tc = *(text_ptr + tx);
+ if (!tc || tc == ' ')
+ break;
+ }
+
+ if (!tl)
+ {
+ text_ptr++;
+ ty--;
+ continue;
+ }
+
+ 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);
+ }
+
+ 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]);
+ 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]);
+ }
+
+ /* copy request gadgets to door backbuffer */
+ BlitBitmap(drawto, bitmap_db_door,
+ 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))
+ {
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ SetPanelBackground();
+ SetDrawBackgroundMask(REDRAW_DOOR_1);
+ }
+ else
+ {
+ SetDrawBackgroundMask(REDRAW_FIELD);
+ }
+
+ 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;
+
+ request_gadget_id = -1;
+
+ SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_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);
+
+ 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
+ }
+
+ if (game_status != GAME_MODE_MAIN)
+ StopAnimation();
+
+ 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);
+
+ if (((old_door_state & DOOR_OPEN_1) && !(req_state & REQ_STAY_CLOSED)) ||
+ (req_state & REQ_REOPEN))
+ OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+ }
+
+ RemapAllGadgets();
if (game_status == GAME_MODE_PLAYING)
{
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);
return (frame_em > 5 ? EL_EMPTY : element);
#if 0
+ /* !!! FIX !!! */
case Ydiamond_stone:
// if (!game.use_native_emc_graphics_engine)
return EL_ROCK;
boolean any_player_moving,
boolean player_is_dropping)
{
- int i;
-
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)
#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 (change_window_scaling_percent && video.fullscreen_enabled)
+ return;
+
+ if (!change_window_scaling_percent && !video.fullscreen_available)
+ return;
+
+#if defined(TARGET_SDL2)
+ if (change_window_scaling_percent)
+ {
+ SDLSetWindowScaling(setup.window_scaling_percent);
- if (!video.fullscreen_available)
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)
+ if (change_fullscreen ||
+ change_fullscreen_mode ||
+ change_window_scaling_percent)
{
Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
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 */
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_mode];
- int border_size = vp_playfield->border_size;
- int new_sx = vp_playfield->x + border_size;
- int new_sy = vp_playfield->y + border_size;
+ 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 !!! */
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();
// RedrawBackground();
#endif
+#endif
+
+ // printf("::: video: init_video_buffer, init_gfx_buffers\n");
}
if (new_scr_fieldx != SCR_FIELDX ||
- new_scr_fieldy != SCR_FIELDY ||
- new_sx != SX ||
+ new_scr_fieldy != SCR_FIELDY)
+ {
+ /* this always toggles between MAIN and GAME when using small tile size */
+
+ SCR_FIELDX = new_scr_fieldx;
+ SCR_FIELDY = new_scr_fieldy;
+
+ // printf("::: new_scr_fieldx != SCR_FIELDX ...\n");
+ }
+
+#if 0
+ if (new_tilesize_var != TILESIZE_VAR &&
+ gfx_game_mode == GAME_MODE_PLAYING)
+ {
+ /* doing this outside GAME_MODE_PLAYING would give wrong playfield size */
+
+ TILESIZE_VAR = new_tilesize_var;
+
+ init_gfx_buffers = TRUE;
+
+ // printf("::: tilesize: init_gfx_buffers\n");
+ }
+#endif
+
+ if (new_sx != SX ||
new_sy != SY ||
- vp_playfield->x != REAL_SX ||
- vp_playfield->y != REAL_SY ||
+ new_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)
+ vp_door_2->y != *door_2_y
+#endif
+ )
{
- SCR_FIELDX = new_scr_fieldx;
- SCR_FIELDY = new_scr_fieldy;
SX = new_sx;
SY = new_sy;
- REAL_SX = vp_playfield->x;
- REAL_SY = vp_playfield->y;
+ 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