/* forward declaration for internal use */
-static void UnmapToolButtons();
+static void UnmapToolButtons(void);
static void HandleToolButtons(struct GadgetInfo *);
static int el_act_dir2crm(int, int, int);
static int el_act2crm(int, int);
return ly;
}
-static int getFieldbufferOffsetX_RND()
+static int getFieldbufferOffsetX_RND(void)
{
int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
int dx = (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0);
return fx;
}
-static int getFieldbufferOffsetY_RND()
+static int getFieldbufferOffsetY_RND(void)
{
int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
int dy = (ScreenMovDir & (MV_UP | MV_DOWN) ? ScreenGfxPos : 0);
}
}
-static void RedrawPlayfield_RND()
+static void RedrawPlayfield_RND(void)
{
if (game.envelope_active)
return;
DrawAllPlayers();
}
-void RedrawPlayfield()
+void RedrawPlayfield(void)
{
if (game_status != GAME_MODE_PLAYING)
return;
}
}
-void DrawMaskedBorder_FIELD()
+void DrawMaskedBorder_FIELD(void)
{
DrawMaskedBorderExt_FIELD(DRAW_TO_BACKBUFFER);
}
redraw_mask |= REDRAW_FIELD;
}
-void DrawFramesPerSecond()
+static void DrawFramesPerSecond(void)
{
char text[100];
int font_nr = FONT_TEXT_2;
}
#if DEBUG_FRAME_TIME
-static void PrintFrameTimeDebugging()
+static void PrintFrameTimeDebugging(void)
{
static unsigned int last_counter = 0;
unsigned int counter = Counter();
return unifiedRedrawMask(mask_1) == unifiedRedrawMask(mask_2);
}
-void BackToFront()
+void BackToFront(void)
{
static int last_redraw_mask = REDRAW_NONE;
draw_border_function);
redraw_mask &= ~fade_mask;
+
+ ClearAutoRepeatKeyEvents();
}
-static void SetScreenStates_BeforeFadingIn()
+static void SetScreenStates_BeforeFadingIn(void)
{
// temporarily set screen mode for animations to screen after fading in
global.anim_status = global.anim_status_next;
global.anim_status = GAME_MODE_PSEUDO_FADING;
}
-static void SetScreenStates_AfterFadingIn()
+static void SetScreenStates_AfterFadingIn(void)
{
// store new source screen (to use correct masked border for fading)
gfx.fade_border_source_status = global.border_status;
global.anim_status = global.anim_status_next;
}
-static void SetScreenStates_BeforeFadingOut()
+static void SetScreenStates_BeforeFadingOut(void)
{
// store new target screen (to use correct masked border for fading)
gfx.fade_border_target_status = game_status;
PrepareFadeBitmap(DRAW_TO_FADE_SOURCE);
}
-static void SetScreenStates_AfterFadingOut()
+static void SetScreenStates_AfterFadingOut(void)
{
global.border_status = game_status;
}
fading = fading_leave_stored;
}
-void FadeSetEnterMenu()
+void FadeSetEnterMenu(void)
{
fading = menu.enter_menu;
FadeSetLeaveNext(fading, TRUE); /* (keep same fade mode) */
}
-void FadeSetLeaveMenu()
+void FadeSetLeaveMenu(void)
{
fading = menu.leave_menu;
FadeSetLeaveNext(fading, TRUE); /* (keep same fade mode) */
}
-void FadeSetEnterScreen()
+void FadeSetEnterScreen(void)
{
fading = menu.enter_screen[game_status];
FadeSetLeaveNext(menu.leave_screen[game_status], TRUE); /* store */
}
-void FadeSetNextScreen()
+void FadeSetNextScreen(void)
{
fading = menu.next_screen[game_status];
// FadeSetLeaveNext(fading, TRUE); /* (keep same fade mode) */
}
-void FadeSetLeaveScreen()
+void FadeSetLeaveScreen(void)
{
FadeSetLeaveNext(menu.leave_screen[game_status], FALSE); /* recall */
}
FadeSetLeaveMenu();
}
-void FadeSetDisabled()
+void FadeSetDisabled(void)
{
static struct TitleFadingInfo fading_none = { FADE_MODE_NONE, -1, -1, -1 };
fading = fading_none;
}
-void FadeSkipNextFadeIn()
+void FadeSkipNextFadeIn(void)
{
FadeExt(0, FADE_MODE_SKIP_FADE_IN, FADE_TYPE_SKIP);
}
-void FadeSkipNextFadeOut()
+void FadeSkipNextFadeOut(void)
{
FadeExt(0, FADE_MODE_SKIP_FADE_OUT, FADE_TYPE_SKIP);
}
-Bitmap *getBitmapFromGraphicOrDefault(int graphic, int default_graphic)
+static Bitmap *getBitmapFromGraphicOrDefault(int graphic, int default_graphic)
{
boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
graphic_info[default_graphic].bitmap);
}
-Bitmap *getBackgroundBitmap(int graphic)
+static Bitmap *getBackgroundBitmap(int graphic)
{
return getBitmapFromGraphicOrDefault(graphic, IMG_BACKGROUND);
}
-Bitmap *getGlobalBorderBitmap(int graphic)
+static Bitmap *getGlobalBorderBitmap(int graphic)
{
return getBitmapFromGraphicOrDefault(graphic, IMG_GLOBAL_BORDER);
}
SetDoorBackgroundBitmap(getBackgroundBitmap(graphic));
}
-void SetPanelBackground()
+void SetPanelBackground(void)
{
struct GraphicInfo *gfx = &graphic_info[IMG_BACKGROUND_PANEL];
static int ex_last = -1, ey_last = -1;
static int exsize_last = -1, eysize_last = -1;
-boolean CheckIfGlobalBorderHasChanged()
+boolean CheckIfGlobalBorderHasChanged(void)
{
// if game status has not changed, global border has not changed either
if (game_status == game_status_last)
return (global_border_bitmap_last != global_border_bitmap);
}
-boolean CheckIfGlobalBorderRedrawIsNeeded()
+#define ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED 0
+
+#if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
+static boolean CheckIfGlobalBorderRedrawIsNeeded(void)
{
// if game status has not changed, nothing has to be redrawn
if (game_status == game_status_last)
return FALSE;
}
+#endif
-void RedrawGlobalBorderFromBitmap(Bitmap *bitmap)
+static void RedrawGlobalBorderFromBitmap(Bitmap *bitmap)
{
if (bitmap)
BlitBitmap(bitmap, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
}
-void RedrawGlobalBorder()
+void RedrawGlobalBorder(void)
{
Bitmap *bitmap = getGlobalBorderBitmapFromStatus(game_status);
redraw_mask = REDRAW_ALL;
}
-#define ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED 0
-
-static void RedrawGlobalBorderIfNeeded()
+static void RedrawGlobalBorderIfNeeded(void)
{
#if ONLY_REDRAW_GLOBAL_BORDER_IF_NEEDED
if (game_status == game_status_last)
eysize_last = EYSIZE;
}
-void ClearField()
+void ClearField(void)
{
RedrawGlobalBorderIfNeeded();
redraw_mask |= REDRAW_FIELD;
}
-void SetBorderElement()
+void SetBorderElement(void)
{
int x, y;
DrawGraphicShiftedNormal(x, y, dx, dy, graphic, frame, cut_mode,mask_mode);
}
-void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy, int graphic,
- int frame, int cut_mode)
+static void DrawGraphicShiftedThruMask(int x, int y, int dx, int dy,
+ int graphic, int frame, int cut_mode)
{
DrawGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, USE_MASKING);
}
element, tilesize, el2edimg, masked, element_bits_draw);
}
-void DrawSizedWall_MM(int dst_x, int dst_y, int element, int tilesize,
- int (*el2img_function)(int))
+static void DrawSizedWall_MM(int dst_x, int dst_y, int element, int tilesize,
+ int (*el2img_function)(int))
{
DrawSizedWallExt_MM(dst_x, dst_y, element, tilesize, el2img_function, FALSE,
0x000f);
}
-void DrawSizedElementExt(int x, int y, int element, int tilesize,
- boolean masked)
+static void DrawSizedElementExt(int x, int y, int element, int tilesize,
+ boolean masked)
{
if (IS_MM_WALL(element))
{
DrawMiniGraphic(sx, sy, el2edimg(getBorderElement(x, y)));
}
-void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
- int x, int y, int xsize, int ysize,
- int tile_width, int tile_height)
+static void DrawEnvelopeBackgroundTiles(int graphic, int startx, int starty,
+ int x, int y, int xsize, int ysize,
+ int tile_width, int tile_height)
{
Bitmap *src_bitmap;
int src_x, src_y;
dst_x, dst_y);
}
-void DrawEnvelopeBackground(int graphic, int startx, int starty,
- int x, int y, int xsize, int ysize, int font_nr)
+static 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);
font_width, font_height);
}
-void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
+static void AnimateEnvelope(int envelope_nr, int anim_mode, int action)
{
int graphic = IMG_BACKGROUND_ENVELOPE_1 + envelope_nr;
Bitmap *src_bitmap = graphic_info[graphic].bitmap;
SkipUntilDelayReached(&anim_delay, anim_delay_value, &i, last_frame);
}
+
+ ClearAutoRepeatKeyEvents();
}
void ShowEnvelope(int envelope_nr)
setRequestPositionExt(x, y, request.width, request.height, add_border_size);
}
-void DrawEnvelopeRequest(char *text)
+static void DrawEnvelopeRequest(char *text)
{
char *text_final = text;
char *text_door_style = NULL;
free(text_door_style);
}
-void AnimateEnvelopeRequest(int anim_mode, int action)
+static void AnimateEnvelopeRequest(int anim_mode, int action)
{
int graphic = IMG_BACKGROUND_REQUEST;
boolean draw_masked = graphic_info[graphic].draw_masked;
SkipUntilDelayReached(&anim_delay, anim_delay_value, &i, last_frame);
}
+
+ ClearAutoRepeatKeyEvents();
}
-void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
+static void ShowEnvelopeRequest(char *text, unsigned int req_state, int action)
{
int graphic = IMG_BACKGROUND_REQUEST;
int sound_opening = SND_REQUEST_OPENING;
SetDrawtoField(DRAW_TO_FIELDBUFFER);
}
-void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
+static void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
{
if (IS_MM_WALL(element))
{
}
}
-void DrawPreviewLevelInitial()
+static void DrawPreviewPlayers(void)
+{
+ if (game_status != GAME_MODE_MAIN)
+ return;
+
+ if (!network.enabled && !setup.team_mode)
+ return;
+
+ boolean player_found[MAX_PLAYERS];
+ int num_players = 0;
+ int i, x, y;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ player_found[i] = FALSE;
+
+ /* check which players can be found in the level (simple approach) */
+ for (x = 0; x < lev_fieldx; x++)
+ {
+ for (y = 0; y < lev_fieldy; y++)
+ {
+ int element = level.field[x][y];
+
+ if (ELEM_IS_PLAYER(element))
+ {
+ int player_nr = GET_PLAYER_NR(element);
+
+ player_nr = MIN(MAX(0, player_nr), MAX_PLAYERS - 1);
+
+ if (!player_found[player_nr])
+ num_players++;
+
+ player_found[player_nr] = TRUE;
+ }
+ }
+ }
+
+ struct TextPosInfo *pos = &menu.main.preview_players;
+ int tile_size = pos->tile_size;
+ int border_size = pos->border_size;
+ int player_xoffset_raw = (pos->vertical ? 0 : tile_size + border_size);
+ int player_yoffset_raw = (pos->vertical ? tile_size + border_size : 0);
+ int player_xoffset = (pos->xoffset != -1 ? pos->xoffset : player_xoffset_raw);
+ int player_yoffset = (pos->yoffset != -1 ? pos->yoffset : player_yoffset_raw);
+ int max_players_width = (MAX_PLAYERS - 1) * player_xoffset + tile_size;
+ int max_players_height = (MAX_PLAYERS - 1) * player_yoffset + tile_size;
+ int all_players_width = (num_players - 1) * player_xoffset + tile_size;
+ int all_players_height = (num_players - 1) * player_yoffset + tile_size;
+ int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width, pos->align);
+ int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
+ int xpos = SX + ALIGNED_XPOS(pos->x, all_players_width, pos->align);
+ int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
+
+ /* clear area in which the players will be drawn */
+ ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
+ max_players_width, max_players_height);
+
+ /* only draw players if level is suited for team mode */
+ if (num_players < 2)
+ return;
+
+ /* draw all players that were found in the level */
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ if (player_found[i])
+ {
+ int graphic = el2img(EL_PLAYER_1 + i);
+
+ DrawSizedGraphicThruMaskExt(drawto, xpos, ypos, graphic, 0, tile_size);
+
+ xpos += player_xoffset;
+ ypos += player_yoffset;
+ }
+ }
+}
+
+void DrawPreviewLevelInitial(void)
{
DrawPreviewLevelExt(TRUE);
+ DrawPreviewPlayers();
}
-void DrawPreviewLevelAnimation()
+void DrawPreviewLevelAnimation(void)
{
DrawPreviewLevelExt(FALSE);
}
+static void DrawNetworkPlayer(int x, int y, int player_nr, int tile_size,
+ int border_size, int font_nr)
+{
+ int graphic = el2img(EL_PLAYER_1 + player_nr);
+ int font_height = getFontHeight(font_nr);
+ int player_height = MAX(tile_size, font_height);
+ int xoffset_text = tile_size + border_size;
+ int yoffset_text = (player_height - font_height) / 2;
+ int yoffset_graphic = (player_height - tile_size) / 2;
+ char *player_name = getNetworkPlayerName(player_nr + 1);
+
+ DrawSizedGraphicThruMaskExt(drawto, x, y + yoffset_graphic, graphic, 0,
+ tile_size);
+ DrawText(x + xoffset_text, y + yoffset_text, player_name, font_nr);
+}
+
+static void DrawNetworkPlayersExt(boolean force)
+{
+ if (game_status != GAME_MODE_MAIN)
+ return;
+
+ if (!network.connected && !force)
+ return;
+
+ int num_players = 0;
+ int i;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].connected_network)
+ num_players++;
+
+ struct TextPosInfo *pos = &menu.main.network_players;
+ int tile_size = pos->tile_size;
+ int border_size = pos->border_size;
+ int xoffset_text = tile_size + border_size;
+ int font_nr = pos->font;
+ int font_width = getFontWidth(font_nr);
+ int font_height = getFontHeight(font_nr);
+ int player_height = MAX(tile_size, font_height);
+ int player_yoffset = player_height + border_size;
+ int max_players_width = xoffset_text + MAX_PLAYER_NAME_LEN * font_width;
+ int max_players_height = MAX_PLAYERS * player_yoffset - border_size;
+ int all_players_height = num_players * player_yoffset - border_size;
+ int max_xpos = SX + ALIGNED_XPOS(pos->x, max_players_width, pos->align);
+ int max_ypos = SY + ALIGNED_YPOS(pos->y, max_players_height, pos->valign);
+ int ypos = SY + ALIGNED_YPOS(pos->y, all_players_height, pos->valign);
+
+ ClearRectangleOnBackground(drawto, max_xpos, max_ypos,
+ max_players_width, max_players_height);
+
+ /* first draw local network player ... */
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ if (stored_player[i].connected_network &&
+ stored_player[i].connected_locally)
+ {
+ char *player_name = getNetworkPlayerName(i + 1);
+ int player_width = xoffset_text + getTextWidth(player_name, font_nr);
+ int xpos = SX + ALIGNED_XPOS(pos->x, player_width, pos->align);
+
+ DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
+
+ ypos += player_yoffset;
+ }
+ }
+
+ /* ... then draw all other network players */
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ if (stored_player[i].connected_network &&
+ !stored_player[i].connected_locally)
+ {
+ char *player_name = getNetworkPlayerName(i + 1);
+ int player_width = xoffset_text + getTextWidth(player_name, font_nr);
+ int xpos = SX + ALIGNED_XPOS(pos->x, player_width, pos->align);
+
+ DrawNetworkPlayer(xpos, ypos, i, tile_size, border_size, font_nr);
+
+ ypos += player_yoffset;
+ }
+ }
+}
+
+void DrawNetworkPlayers(void)
+{
+ DrawNetworkPlayersExt(FALSE);
+}
+
+void ClearNetworkPlayers(void)
+{
+ DrawNetworkPlayersExt(TRUE);
+}
+
inline static void DrawGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
int graphic, int sync_frame,
int mask_mode)
g1->anim_mode == g2->anim_mode);
}
-void DrawAllPlayers()
+void DrawAllPlayers(void)
{
int i;
/* ------------------------------------------------------------------------- */
-void WaitForEventToContinue()
+void WaitForEventToContinue(void)
{
boolean still_wait = TRUE;
{
switch (event.type)
{
- case EVENT_BUTTONPRESS:
+ case EVENT_BUTTONRELEASE:
case EVENT_KEYPRESS:
#if defined(TARGET_SDL2)
case SDL_CONTROLLERBUTTONDOWN:
int sx, sy;
int result;
+ game.request_active = TRUE;
+
setRequestPosition(&sx, &sy, FALSE);
button_status = MB_RELEASED;
BackToFront();
}
+ game.request_active = FALSE;
+
return result;
}
int result;
int ty;
- if (maxWordLengthInString(text) > MAX_REQUEST_LINE_FONT1_LEN)
+ if (maxWordLengthInRequestString(text) > MAX_REQUEST_LINE_FONT1_LEN)
{
max_request_line_len = MAX_REQUEST_LINE_FONT2_LEN;
font_nr = FONT_TEXT_1;
SetMouseCursor(CURSOR_DEFAULT);
-#if defined(NETWORK_AVALIABLE)
/* pause network game while waiting for request to answer */
- if (options.network &&
+ if (network.enabled &&
game_status == GAME_MODE_PLAYING &&
+ !AllPlayersGone &&
req_state & REQUEST_WAIT_FOR_INPUT)
SendToServer_PausePlaying();
-#endif
old_door_state = GetDoorState();
SetDrawBackgroundMask(REDRAW_FIELD);
}
-#if defined(NETWORK_AVALIABLE)
/* continue network game after request */
- if (options.network &&
+ if (network.enabled &&
game_status == GAME_MODE_PLAYING &&
+ !AllPlayersGone &&
req_state & REQUEST_WAIT_FOR_INPUT)
SendToServer_ContinuePlaying();
-#endif
/* restore deactivated drawing when quick-loading level tape recording */
if (tape.playing && tape.deactivate_display)
SetMouseCursor(CURSOR_DEFAULT);
-#if defined(NETWORK_AVALIABLE)
/* pause network game while waiting for request to answer */
- if (options.network &&
+ if (network.enabled &&
game_status == GAME_MODE_PLAYING &&
+ !AllPlayersGone &&
req_state & REQUEST_WAIT_FOR_INPUT)
SendToServer_PausePlaying();
-#endif
/* simulate releasing mouse button over last gadget, if still pressed */
if (button_status)
SetDrawBackgroundMask(REDRAW_FIELD);
}
-#if defined(NETWORK_AVALIABLE)
/* continue network game after request */
- if (options.network &&
+ if (network.enabled &&
game_status == GAME_MODE_PLAYING &&
+ !AllPlayersGone &&
req_state & REQUEST_WAIT_FOR_INPUT)
SendToServer_ContinuePlaying();
-#endif
/* restore deactivated drawing when quick-loading level tape recording */
if (tape.playing && tape.deactivate_display)
return compare_result;
}
-void InitGraphicCompatibilityInfo_Doors()
+void InitGraphicCompatibilityInfo_Doors(void)
{
struct
{
}
}
-void InitDoors()
+void InitDoors(void)
{
int i;
return MoveDoor(door_state);
}
-unsigned int GetDoorState()
+unsigned int GetDoorState(void)
{
return MoveDoor(DOOR_GET_STATE);
}
return MoveDoor(door_state | DOOR_SET_STATE);
}
-int euclid(int a, int b)
+static int euclid(int a, int b)
{
return (b ? euclid(b, a % b) : a);
}
DrawMaskedBorder(REDRAW_DOOR_1);
DrawMaskedBorder(REDRAW_DOOR_2);
+ ClearAutoRepeatKeyEvents();
+
return (door1 | door2);
}
-static boolean useSpecialEditorDoor()
+static boolean useSpecialEditorDoor(void)
{
int graphic = IMG_GLOBAL_BORDER_EDITOR;
boolean redefined = getImageListEntryFromImageID(graphic)->redefined;
return TRUE;
}
-void DrawSpecialEditorDoor()
+void DrawSpecialEditorDoor(void)
{
struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
int top_border_width = gfx1->width;
redraw_mask |= REDRAW_ALL;
}
-void UndrawSpecialEditorDoor()
+void UndrawSpecialEditorDoor(void)
{
struct GraphicInfo *gfx1 = &graphic_info[IMG_DOOR_2_TOP_BORDER_CORRECTION];
int top_border_width = gfx1->width;
}
};
-void CreateToolButtons()
+void CreateToolButtons(void)
{
int i;
}
}
-void FreeToolButtons()
+void FreeToolButtons(void)
{
int i;
FreeGadget(tool_gadget[i]);
}
-static void UnmapToolButtons()
+static void UnmapToolButtons(void)
{
int i;
return getBeltSwitchElementFromBeltNrAndBeltDirNr(belt_nr, belt_dir_nr);
}
-boolean getTeamMode_EM()
+boolean getTeamMode_EM(void)
{
- return game.team_mode;
+ return game.team_mode || network_playing;
}
int getGameFrameDelay_EM(int native_em_game_frame_delay)
}
}
+#if 0
void ResetGfxAnimation_EM(int x, int y, int tile)
{
GfxFrame[x][y] = 0;
}
+#endif
void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
int tile, int frame_em, int x, int y)
#endif
}
-void CheckSaveEngineSnapshot_EM(byte action[MAX_PLAYERS], int frame,
- boolean any_player_moving,
- boolean any_player_snapping,
- boolean any_player_dropping)
+static void CheckSaveEngineSnapshot_EM(byte action[MAX_PLAYERS], int frame,
+ boolean any_player_moving,
+ boolean any_player_snapping,
+ boolean any_player_dropping)
{
if (frame == 0 && !any_player_dropping)
{
}
}
-void CheckSaveEngineSnapshot_SP(boolean murphy_is_waiting,
- boolean murphy_is_dropping)
+static void CheckSaveEngineSnapshot_SP(boolean murphy_is_waiting,
+ boolean murphy_is_dropping)
{
if (murphy_is_waiting)
{
}
}
-void CheckSaveEngineSnapshot_MM(boolean element_clicked,
- boolean button_released)
+static void CheckSaveEngineSnapshot_MM(boolean element_clicked,
+ boolean button_released)
{
if (button_released)
{
PlaySound(sound);
}
-void PlayMenuSound()
+void PlayMenuSound(void)
{
PlayMenuSoundExt(menu.sound[game_status]);
}
PlaySoundLoop(sound);
}
-void PlayMenuSoundIfLoop()
+void PlayMenuSoundIfLoop(void)
{
PlayMenuSoundIfLoopExt(menu.sound[game_status]);
}
if (!setup.sound_music)
return;
- PlayMusic(music);
+ if (IS_LOOP_MUSIC(music))
+ PlayMusicLoop(music);
+ else
+ PlayMusic(music);
}
-void PlayMenuMusic()
+void PlayMenuMusic(void)
{
char *curr_music = getCurrentlyPlayingMusicFilename();
char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
PlayMenuMusicExt(menu.music[game_status]);
}
-void PlayMenuSoundsAndMusic()
+void PlayMenuSoundsAndMusic(void)
{
PlayMenuSound();
PlayMenuMusic();
}
-static void FadeMenuSounds()
+static void FadeMenuSounds(void)
{
FadeSounds();
}
-static void FadeMenuMusic()
+static void FadeMenuMusic(void)
{
char *curr_music = getCurrentlyPlayingMusicFilename();
char *next_music = getMusicInfoEntryFilename(menu.music[game_status]);
FadeMusic();
}
-void FadeMenuSoundsAndMusic()
+void FadeMenuSoundsAndMusic(void)
{
FadeMenuSounds();
FadeMenuMusic();
}
-void PlaySoundActivating()
+void PlaySoundActivating(void)
{
#if 0
PlaySound(SND_MENU_ITEM_ACTIVATING);
#endif
}
-void PlaySoundSelecting()
+void PlaySoundSelecting(void)
{
#if 0
PlaySound(SND_MENU_ITEM_SELECTING);
#endif
}
-void ToggleFullscreenOrChangeWindowScalingIfNeeded()
+void ToggleFullscreenOrChangeWindowScalingIfNeeded(void)
{
boolean change_fullscreen = (setup.fullscreen !=
video.fullscreen_enabled);
}
}
-void JoinRectangles(int *x, int *y, int *width, int *height,
- int x2, int y2, int width2, int height2)
+static void JoinRectangles(int *x, int *y, int *width, int *height,
+ int x2, int y2, int width2, int height2)
{
// do not join with "off-screen" rectangle
if (x2 == -1 || y2 == -1)
}
}
-void ResetFontStatus()
+void ResetFontStatus(void)
{
SetFontStatus(-1);
}
-boolean CheckIfPlayfieldViewportHasChanged()
+void SetLevelSetInfo(char *identifier, int level_nr)
+{
+ setString(&levelset.identifier, identifier);
+
+ levelset.level_nr = level_nr;
+}
+
+boolean CheckIfPlayfieldViewportHasChanged(void)
{
// if game status has not changed, playfield viewport has not changed either
if (game_status == game_status_last)
new_full_sysize != FULL_SYSIZE);
}
-boolean CheckIfGlobalBorderOrPlayfieldViewportHasChanged()
+boolean CheckIfGlobalBorderOrPlayfieldViewportHasChanged(void)
{
return (CheckIfGlobalBorderHasChanged() ||
CheckIfPlayfieldViewportHasChanged());
}
-void ChangeViewportPropertiesIfNeeded()
+void ChangeViewportPropertiesIfNeeded(void)
{
boolean use_mini_tilesize = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
FALSE : setup.small_game_graphics);
projects / rocksndiamonds.git / blobdiff