printf(" CustomValue: %d\n", CustomValue[x][y]);
printf(" GfxElement: %d\n", GfxElement[x][y]);
printf(" GfxAction: %d\n", GfxAction[x][y]);
- printf(" GfxFrame: %d\n", GfxFrame[x][y]);
+ printf(" GfxFrame: %d [%d]\n", GfxFrame[x][y], FrameCounter);
printf("\n");
}
void DrawMaskedBorder_Rect(int x, int y, int width, int height)
{
- Bitmap *bitmap = graphic_info[IMG_GLOBAL_BORDER].bitmap;
+ Bitmap *bitmap = getGlobalBorderBitmapFromGameStatus();
BlitBitmapMasked(bitmap, backbuffer, x, y, width, height, x, y);
}
void DrawMaskedBorder(int redraw_mask)
{
/* never draw masked screen borders on borderless screens */
- if (effectiveGameStatus() == GAME_MODE_LOADING ||
- effectiveGameStatus() == GAME_MODE_TITLE)
+ if (game_status == GAME_MODE_LOADING ||
+ game_status == GAME_MODE_TITLE)
return;
if (redraw_mask & REDRAW_ALL)
FadeExt(0, FADE_MODE_SKIP_FADE_OUT, FADE_TYPE_SKIP);
}
+Bitmap *getBitmapFromGraphicOrDefault(int graphic, int default_graphic)
+{
+ boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
+
+ return (graphic == IMG_UNDEFINED ? NULL :
+ graphic_info[graphic].bitmap != NULL || redefined ?
+ graphic_info[graphic].bitmap :
+ graphic_info[default_graphic].bitmap);
+}
+
+Bitmap *getBackgroundBitmap(int graphic)
+{
+ return getBitmapFromGraphicOrDefault(graphic, IMG_BACKGROUND);
+}
+
+Bitmap *getGlobalBorderBitmap(int graphic)
+{
+ return getBitmapFromGraphicOrDefault(graphic, IMG_GLOBAL_BORDER);
+}
+
+Bitmap *getGlobalBorderBitmapFromGameStatus()
+{
+ int graphic =
+ (game_status == GAME_MODE_MAIN ||
+ game_status == GAME_MODE_PSEUDO_TYPENAME ? IMG_GLOBAL_BORDER_MAIN :
+ game_status == GAME_MODE_SCORES ? IMG_GLOBAL_BORDER_SCORES :
+ game_status == GAME_MODE_EDITOR ? IMG_GLOBAL_BORDER_EDITOR :
+ game_status == GAME_MODE_PLAYING ? IMG_GLOBAL_BORDER_PLAYING :
+ IMG_GLOBAL_BORDER);
+
+ return getGlobalBorderBitmap(graphic);
+}
+
void SetWindowBackgroundImageIfDefined(int graphic)
{
if (graphic_info[graphic].bitmap)
void SetWindowBackgroundImage(int graphic)
{
- SetWindowBackgroundBitmap(graphic == IMG_UNDEFINED ? NULL :
- graphic_info[graphic].bitmap ?
- graphic_info[graphic].bitmap :
- graphic_info[IMG_BACKGROUND].bitmap);
+ SetWindowBackgroundBitmap(getBackgroundBitmap(graphic));
}
void SetMainBackgroundImage(int graphic)
{
- SetMainBackgroundBitmap(graphic == IMG_UNDEFINED ? NULL :
- graphic_info[graphic].bitmap ?
- graphic_info[graphic].bitmap :
- graphic_info[IMG_BACKGROUND].bitmap);
+ SetMainBackgroundBitmap(getBackgroundBitmap(graphic));
}
void SetDoorBackgroundImage(int graphic)
{
- SetDoorBackgroundBitmap(graphic == IMG_UNDEFINED ? NULL :
- graphic_info[graphic].bitmap ?
- graphic_info[graphic].bitmap :
- graphic_info[IMG_BACKGROUND].bitmap);
+ SetDoorBackgroundBitmap(getBackgroundBitmap(graphic));
}
void SetPanelBackground()
boolean CheckIfGlobalBorderHasChanged()
{
- int global_border_graphic;
-
// if game status has not changed, global border has not changed either
if (game_status == game_status_last)
return FALSE;
- global_border_graphic =
- (game_status == GAME_MODE_MAIN ? IMG_GLOBAL_BORDER_MAIN :
- game_status == GAME_MODE_SCORES ? IMG_GLOBAL_BORDER_SCORES :
- game_status == GAME_MODE_EDITOR ? IMG_GLOBAL_BORDER_EDITOR :
- game_status == GAME_MODE_PLAYING ? IMG_GLOBAL_BORDER_PLAYING :
- IMG_GLOBAL_BORDER);
-
- global_border_bitmap =
- (graphic_info[global_border_graphic].bitmap ?
- graphic_info[global_border_graphic].bitmap :
- graphic_info[IMG_GLOBAL_BORDER].bitmap);
+ // determine and store new global border bitmap for current game status
+ global_border_bitmap = getGlobalBorderBitmapFromGameStatus();
return (global_border_bitmap_last != global_border_bitmap);
}
if (game_status == game_status_last)
return FALSE;
+ // redraw if last screen was title screen
+ if (game_status_last == GAME_MODE_TITLE)
+ return TRUE;
+
// redraw if global screen border has changed
if (CheckIfGlobalBorderHasChanged())
return TRUE;
return FALSE;
}
+void RedrawGlobalBorderFromBitmap(Bitmap *bitmap)
+{
+ if (bitmap)
+ BlitBitmap(bitmap, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ else
+ ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
+}
+
+void RedrawGlobalBorder()
+{
+ Bitmap *bitmap = getGlobalBorderBitmapFromGameStatus();
+
+ RedrawGlobalBorderFromBitmap(bitmap);
+
+ redraw_mask = REDRAW_ALL;
+}
+
static void RedrawGlobalBorderIfNeeded()
{
if (game_status == game_status_last)
if (CheckIfGlobalBorderRedrawIsNeeded())
{
// redraw global screen border (or clear, if defined to be empty)
-
- if (global_border_bitmap)
- BlitBitmap(global_border_bitmap, backbuffer,
- 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
- else
- ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
+ RedrawGlobalBorderFromBitmap(global_border_bitmap);
// copy previous playfield and door areas, if they are defined on both
// previous and current screen and if they still have the same size
gfx.anim_random_frame = GfxRandom[x][y];
}
-inline int getGraphicAnimationFrame(int graphic, int sync_frame)
+int getGraphicAnimationFrame(int graphic, int sync_frame)
{
/* animation synchronized with global frame counter, not move position */
if (graphic_info[graphic].anim_global_sync || sync_frame < 0)
getSizedGraphicSource(graphic, 0, MINI_TILESIZE, bitmap, x, y);
}
-inline void getGraphicSourceExt(int graphic, int frame, Bitmap **bitmap,
- int *x, int *y, boolean get_backside)
+inline static void getGraphicSourceExt(int graphic, int frame, Bitmap **bitmap,
+ int *x, int *y, boolean get_backside)
{
struct GraphicInfo *g = &graphic_info[graphic];
int src_x = g->src_x + (get_backside ? g->offset2_x : 0);
void DrawEnvelopeRequest(char *text)
{
+ int last_game_status = game_status; /* save current game status */
char *text_final = text;
char *text_door_style = NULL;
int graphic = IMG_BACKGROUND_REQUEST;
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 max_text_width = request.width - 2 * border_size;
+ int max_text_height = request.height - 2 * border_size;
+ int line_length = max_text_width / font_width;
+ int max_lines = max_text_height / line_height;
+ int text_width = line_length * font_width;
int width = request.width;
int height = request.height;
- int tile_size = request.step_offset;
+ int tile_size = MAX(request.step_offset, 1);
int x_steps = width / tile_size;
int y_steps = height / tile_size;
+ int sx_offset = border_size;
+ int sy_offset = border_size;
int sx, sy;
int i, x, y;
- if (request.wrap_single_words)
+ if (request.centered)
+ sx_offset = (request.width - text_width) / 2;
+
+ if (request.wrap_single_words && !request.autowrap)
{
char *src_text_ptr, *dst_text_ptr;
x, y, x_steps, y_steps,
tile_size, tile_size);
- DrawTextBuffer(sx + border_size, sy + border_size, text_final, font_nr,
+ /* force DOOR font inside door area */
+ game_status = GAME_MODE_PSEUDO_DOOR;
+
+ DrawTextBuffer(sx + sx_offset, sy + sy_offset, text_final, font_nr,
line_length, -1, max_lines, line_spacing, mask_mode,
request.autowrap, request.centered, FALSE);
+ game_status = last_game_status; /* restore current game status */
+
for (i = 0; i < NUM_TOOL_BUTTONS; i++)
RedrawGadget(tool_gadget[i]);
int anim_delay_value = (no_delay ? 0 : delay_value + 500 * 0) / 2;
unsigned int anim_delay = 0;
- int tile_size = request.step_offset;
+ int tile_size = MAX(request.step_offset, 1);
int max_xsize = request.width / tile_size;
int max_ysize = request.height / tile_size;
int max_xsize_inner = max_xsize - 2;
void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
{
- int last_game_status = game_status; /* save current game status */
int graphic = IMG_BACKGROUND_REQUEST;
int sound_opening = SND_REQUEST_OPENING;
int sound_closing = SND_REQUEST_CLOSING;
InitAnimation();
}
- /* force DOOR font inside door area */
- game_status = GAME_MODE_PSEUDO_DOOR;
-
game.envelope_active = TRUE; /* needed for RedrawPlayfield() events */
if (action == ACTION_OPENING)
game.envelope_active = FALSE;
- game_status = last_game_status; /* restore current game status */
-
if (action == ACTION_CLOSING)
{
if (game_status != GAME_MODE_MAIN)
DrawPreviewLevelExt(FALSE);
}
-inline void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
- int graphic, int sync_frame, int mask_mode)
+inline static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
+ int graphic, int sync_frame,
+ int mask_mode)
{
int frame = getGraphicAnimationFrame(graphic, sync_frame);
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)
+void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
+ int graphic, int sync_frame, int mask_mode)
{
int frame = getGraphicAnimationFrame(graphic, sync_frame);
DrawFixedGraphicExt(dst_bitmap, x, y, graphic, frame);
}
-inline void DrawGraphicAnimation(int x, int y, int graphic)
+inline static void DrawGraphicAnimation(int x, int y, int graphic)
{
int lx = LEVELX(x), ly = LEVELY(y);
MarkTileDirty(x, y);
}
-inline void DrawFixedGraphicAnimation(int x, int y, int graphic)
+void DrawFixedGraphicAnimation(int x, int y, int graphic)
{
int lx = LEVELX(x), ly = LEVELY(y);
DrawGraphicAnimation(SCREENX(x), SCREENY(y), graphic);
}
-inline void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
+void DrawLevelGraphicAnimationIfNeeded(int x, int y, int graphic)
{
int sx = SCREENX(x), sy = SCREENY(y);
{
boolean level_solved = (game_status == GAME_MODE_PLAYING &&
local_player->LevelSolved_GameEnd);
- int last_game_status = game_status; /* save current game status */
int width = request.width;
int height = request.height;
int sx, sy;
Delay(10);
}
- game_status = GAME_MODE_PSEUDO_DOOR;
-
BackToFront();
-
- game_status = last_game_status; /* restore current game status */
}
return result;
return (door1 | door2);
}
+static boolean useSpecialEditorDoor()
+{
+ int graphic = IMG_GLOBAL_BORDER_EDITOR;
+ boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
+
+ // do not draw special editor door if editor border defined or redefined
+ if (graphic_info[graphic].bitmap != NULL || redefined)
+ return FALSE;
+
+ // do not draw special editor door if global border defined to be empty
+ if (graphic_info[IMG_GLOBAL_BORDER].bitmap == NULL)
+ return FALSE;
+
+ // do not draw special editor door if viewport definitions do not match
+ if (EX != VX ||
+ EY >= VY ||
+ EXSIZE != VXSIZE ||
+ EY + EYSIZE != VY + VYSIZE)
+ return FALSE;
+
+ return TRUE;
+}
+
void DrawSpecialEditorDoor()
{
struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
int vy = VY - outer_border;
int exsize = EXSIZE + 2 * outer_border;
+ if (!useSpecialEditorDoor())
+ return;
+
/* 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);
int exsize = EXSIZE + 2 * outer_border;
int eysize = EYSIZE + 2 * outer_border;
+ if (!useSpecialEditorDoor())
+ return;
+
/* draw normal tape recorder window */
if (graphic_info[IMG_GLOBAL_BORDER].bitmap)
{