# OPTIONS = $(DEBUG) -Wall # only for debugging purposes
# OPTIONS = $(DEBUG) -O3 -Wall # only for debugging purposes
-OPTIONS = $(DEBUG) -Wall # only for debugging purposes
+# OPTIONS = $(DEBUG) -Wall # only for debugging purposes
+OPTIONS = $(DEBUG) -Wall -Wstrict-prototypes # only for debugging purposes
# OPTIONS = $(DEBUG) -Wall -ansi -pedantic # only for debugging purposes
# OPTIONS = -O3 -Wall -ansi -pedantic
# OPTIONS = -O3 -Wall
/* forward declaration for internal use */
static void HandleGlobalAnim(int, int);
static void DoAnimationExt(void);
-static void ResetGlobalAnim_Clickable();
-static void ResetGlobalAnim_Clicked();
+static void ResetGlobalAnim_Clickable(void);
+static void ResetGlobalAnim_Clicked(void);
static struct GlobalAnimControlInfo global_anim_ctrl[NUM_GAME_MODES];
return compare_result;
}
-static void InitToonControls()
+static void InitToonControls(void)
{
int mode_nr_toons = GAME_MODE_PSEUDO_TOONS;
struct GlobalAnimControlInfo *ctrl = &global_anim_ctrl[mode_nr_toons];
ctrl->num_anims++;
}
-void InitGlobalAnimControls()
+void InitGlobalAnimControls(void)
{
int i, m, a, p;
int mode_nr, anim_nr, part_nr;
anim_classes_last = ANIM_CLASS_NONE;
}
-void InitGlobalAnimations()
+void InitGlobalAnimations(void)
{
InitGlobalAnimControls();
}
HandleGlobalAnim_Mode(&global_anim_ctrl[game_mode], action);
}
-static void DoAnimationExt()
+static void DoAnimationExt(void)
{
int i;
return action_executed;
}
-static void InitGlobalAnim_Clickable()
+static void InitGlobalAnim_Clickable(void)
{
int mode_nr;
return (anything_clicked || any_event_action);
}
-static void ResetGlobalAnim_Clickable()
+static void ResetGlobalAnim_Clickable(void)
{
InitGlobalAnim_Clickable();
}
-static void ResetGlobalAnim_Clicked()
+static void ResetGlobalAnim_Clicked(void)
{
InitGlobalAnim_Clicked(-1, -1, FALSE);
}
#include "conftime.h"
-char *getSourceDateString()
+char *getSourceDateString(void)
{
return SOURCE_DATE_STRING;
}
-char *getProgramTitleString()
+char *getProgramTitleString(void)
{
return program.program_title;
}
-char *getProgramRealVersionString()
+char *getProgramRealVersionString(void)
{
static char program_version_string[32];
return program_version_string;
}
-char *getProgramVersionString()
+char *getProgramVersionString(void)
{
return program.version_string;
}
-char *getProgramInitString()
+char *getProgramInitString(void)
{
static char *program_init_string = NULL;
return program_init_string;
}
-char *getConfigProgramTitleString()
+char *getConfigProgramTitleString(void)
{
TreeInfo *graphics_current =
getArtworkTreeInfoForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
setup.internal.program_title);
}
-char *getConfigProgramCopyrightString()
+char *getConfigProgramCopyrightString(void)
{
TreeInfo *graphics_current =
getArtworkTreeInfoForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
setup.internal.program_copyright);
}
-char *getConfigProgramCompanyString()
+char *getConfigProgramCompanyString(void)
{
TreeInfo *graphics_current =
getArtworkTreeInfoForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
setup.internal.program_company);
}
-char *getWindowTitleString()
+char *getWindowTitleString(void)
{
static char *window_title_string = NULL;
char *getProgramRealVersionString(void);
char *getProgramVersionString(void);
char *getProgramInitString(void);
-char *getConfigProgramTitleString();
-char *getConfigProgramCopyrightString();
-char *getConfigProgramCompanyString();
+char *getConfigProgramTitleString(void);
+char *getConfigProgramCopyrightString(void);
+char *getConfigProgramCompanyString(void);
char *getWindowTitleString(void);
#endif /* CONFIG_H */
static void ModifyEditorSelectboxValue(int, int);
static void ModifyEditorSelectboxOptions(int, struct ValueTextInfo *);
static void ModifyEditorDrawingArea(int, int, int);
-static void ModifyEditorElementList();
-static void AdjustElementListScrollbar();
-static void RedrawDrawingElements();
+static void ModifyEditorElementList(void);
+static void AdjustElementListScrollbar(void);
+static void RedrawDrawingElements(void);
static void DrawDrawingWindowExt(boolean);
-static void DrawDrawingWindow();
-static void DrawLevelInfoWindow();
-static void DrawPropertiesWindow();
-static void DrawPaletteWindow();
-static void UpdateCustomElementGraphicGadgets();
+static void DrawDrawingWindow(void);
+static void DrawLevelInfoWindow(void);
+static void DrawPropertiesWindow(void);
+static void DrawPaletteWindow(void);
+static void UpdateCustomElementGraphicGadgets(void);
static boolean checkPropertiesConfig(int);
-static void SetAutomaticNumberOfGemsNeeded();
-static void ClearEditorGadgetInfoText();
+static void SetAutomaticNumberOfGemsNeeded(void);
+static void ClearEditorGadgetInfoText(void);
static void CopyLevelToUndoBuffer(int);
static void HandleDrawingAreas(struct GadgetInfo *);
static void HandleCounterButtons(struct GadgetInfo *);
static void HandleControlButtons(struct GadgetInfo *);
static void HandleDrawingAreaInfo(struct GadgetInfo *);
static void PrintEditorGadgetInfoText(struct GadgetInfo *);
-static boolean AskToCopyAndModifyLevelTemplate();
-static boolean getDrawModeHiRes();
-static int getTabulatorBarWidth();
-static int getTabulatorBarHeight();
-static Pixel getTabulatorBarColor();
+static boolean AskToCopyAndModifyLevelTemplate(void);
+static boolean getDrawModeHiRes(void);
+static int getTabulatorBarWidth(void);
+static int getTabulatorBarHeight(void);
+static Pixel getTabulatorBarColor(void);
static int num_editor_gadgets = 0; /* dynamically determined */
-----------------------------------------------------------------------------
*/
-static int getMaxInfoTextLength()
+static int getMaxInfoTextLength(void)
{
return (SXSIZE / getFontWidth(INFOTEXT_FONT));
}
return NULL;
}
-static boolean suppressBorderElement()
+static boolean suppressBorderElement(void)
{
return (level.game_engine_type == GAME_ENGINE_TYPE_MM &&
lev_fieldx <= MAX_ED_FIELDX &&
(*elements)[(*num_elements)++] = EL_EMPTY;
}
-static void ReinitializeElementList_EnableSections()
+static void ReinitializeElementList_EnableSections(void)
{
/* default: enable all element sections */
}
}
-static void ReinitializeElementList()
+static void ReinitializeElementList(void)
{
static boolean initialization_needed = TRUE;
int pos = 0;
AdjustElementListScrollbar();
}
-void PrintEditorElementList()
+void PrintEditorElementList(void)
{
boolean *stop = &setup_editor_el_user_defined;
int i, j;
}
}
-static void ReinitializeElementListButtons()
+static void ReinitializeElementListButtons(void)
{
static boolean last_setup_value_headlines = FALSE;
static boolean initialization_needed = TRUE;
FillRectangle(drawto, SX + x, SY + y, xsize_thin, ysize_thin, BLACK_PIXEL);
}
-static void DrawEditorLevelBorderLinesIfNeeded()
+static void DrawEditorLevelBorderLinesIfNeeded(void)
{
int xsize = lev_fieldx * ed_tilesize;
int ysize = lev_fieldy * ed_tilesize;
getSizedGraphicSource(el2edimg(element), 0, tile_size, bitmap, x, y);
}
-static void CreateControlButtons()
+static void CreateControlButtons(void)
{
struct GadgetInfo *gi;
int i;
}
}
-static void CreateCounterButtons()
+static void CreateCounterButtons(void)
{
int max_infotext_len = getMaxInfoTextLength();
int i;
}
}
-static void CreateDrawingAreas()
+static void CreateDrawingAreas(void)
{
int i;
}
}
-static void CreateTextInputGadgets()
+static void CreateTextInputGadgets(void)
{
struct GraphicInfo *gd = &graphic_info[IMG_EDITOR_INPUT_TEXT];
int max_infotext_len = getMaxInfoTextLength();
}
}
-static void CreateTextAreaGadgets()
+static void CreateTextAreaGadgets(void)
{
int max_infotext_len = getMaxInfoTextLength();
int i;
}
}
-static void CreateSelectboxGadgets()
+static void CreateSelectboxGadgets(void)
{
int max_infotext_len = getMaxInfoTextLength();
int i, j;
}
}
-static void CreateTextbuttonGadgets()
+static void CreateTextbuttonGadgets(void)
{
int max_infotext_len = getMaxInfoTextLength();
int i;
}
}
-static void CreateGraphicbuttonGadgets()
+static void CreateGraphicbuttonGadgets(void)
{
struct GadgetInfo *gi;
unsigned int event_mask;
}
}
-static void CreateScrollbarGadgets()
+static void CreateScrollbarGadgets(void)
{
int i;
}
}
-static void CreateCheckbuttonGadgets()
+static void CreateCheckbuttonGadgets(void)
{
struct GadgetInfo *gi;
unsigned int event_mask;
}
}
-static void CreateRadiobuttonGadgets()
+static void CreateRadiobuttonGadgets(void)
{
int graphic = IMG_EDITOR_RADIOBUTTON;
struct GraphicInfo *gd = &graphic_info[graphic];
}
}
-void CreateLevelEditorGadgets()
+void CreateLevelEditorGadgets(void)
{
/* force EDITOR font inside level editor */
SetFontStatus(GAME_MODE_EDITOR);
ResetFontStatus();
}
-void FreeLevelEditorGadgets()
+void FreeLevelEditorGadgets(void)
{
int i;
MapGadget(gi_up);
}
-static void MapControlButtons()
+static void MapControlButtons(void)
{
int counter_id;
int i;
MapGadget(gi);
}
-static void MapMainDrawingArea()
+static void MapMainDrawingArea(void)
{
boolean no_horizontal_scrollbar = (lev_fieldx + 2 <= ed_fieldx);
boolean no_vertical_scrollbar = (lev_fieldy + 2 <= ed_fieldy);
}
}
-static void MapLevelEditorToolboxCustomGadgets()
+static void MapLevelEditorToolboxCustomGadgets(void)
{
MapOrUnmapLevelEditorToolboxCustomGadgets(TRUE);
}
-static void UnmapLevelEditorToolboxCustomGadgets()
+static void UnmapLevelEditorToolboxCustomGadgets(void)
{
MapOrUnmapLevelEditorToolboxCustomGadgets(FALSE);
}
}
}
-static void MapLevelEditorToolboxDrawingGadgets()
+static void MapLevelEditorToolboxDrawingGadgets(void)
{
MapOrUnmapLevelEditorToolboxDrawingGadgets(TRUE);
}
-static void UnmapLevelEditorToolboxDrawingGadgets()
+static void UnmapLevelEditorToolboxDrawingGadgets(void)
{
MapOrUnmapLevelEditorToolboxDrawingGadgets(FALSE);
}
UnmapGadget(level_editor_gadget[drawingarea_info[id].gadget_id]);
}
-static void UnmapLevelEditorFieldGadgets()
+static void UnmapLevelEditorFieldGadgets(void)
{
int i;
UnmapGadget(level_editor_gadget[i]);
}
-void UnmapLevelEditorGadgets()
+void UnmapLevelEditorGadgets(void)
{
int i;
UnmapGadget(level_editor_gadget[i]);
}
-static void ResetUndoBuffer()
+static void ResetUndoBuffer(void)
{
undo_buffer_position = -1;
undo_buffer_steps = -1;
DrawDrawingWindowExt(remap_toolbox_gadgets);
}
-static void DrawEditModeWindow()
+static void DrawEditModeWindow(void)
{
DrawEditModeWindowExt(TRUE);
}
-static void DrawEditModeWindow_PlayfieldOnly()
+static void DrawEditModeWindow_PlayfieldOnly(void)
{
DrawEditModeWindowExt(FALSE);
}
DrawEditModeWindow();
}
-static boolean LevelChanged()
+static boolean LevelChanged(void)
{
boolean field_changed = FALSE;
int x, y;
return (level.changed || field_changed);
}
-static boolean PrepareSavingIntoPersonalLevelSet()
+static boolean PrepareSavingIntoPersonalLevelSet(void)
{
static LevelDirTree *last_copied_leveldir = NULL;
static LevelDirTree *last_written_leveldir = NULL;
return new_index_value;
}
-static void setSelectboxSpecialActionVariablesIfNeeded()
+static void setSelectboxSpecialActionVariablesIfNeeded(void)
{
int i;
}
}
-static void setSelectboxSpecialActionOptions()
+static void setSelectboxSpecialActionOptions(void)
{
int i;
CopyClassicElementPropertiesToEditor(element);
}
-static boolean AskToCopyAndModifyLevelTemplate()
+static boolean AskToCopyAndModifyLevelTemplate(void)
{
if (Request("Copy and modify settings from level template?", REQ_ASK))
{
CopyClassicElementPropertiesToGame(element);
}
-void CheckElementDescriptions()
+void CheckElementDescriptions(void)
{
int i;
MAX_ED_FIELDY = getMaxEdFieldY(FALSE);
}
-static void InitDrawingElements()
+static void InitDrawingElements(void)
{
static int game_engine_type_last = GAME_ENGINE_TYPE_UNKNOWN;
game_engine_type_last = level.game_engine_type;
}
-static void InitLevelSetInfo()
+static void InitLevelSetInfo(void)
{
snprintf(levelset_name, MAX_LEVEL_NAME_LEN + 1,
"%s", leveldir_current->name);
DrawLevelEd();
}
-static boolean useEditorDoorAnimation()
+static boolean useEditorDoorAnimation(void)
{
struct RectWithBorder *vp_door_1 = &viewport.door_1[GAME_MODE_MAIN];
boolean door_1_viewport_unchanged =
return (door_1_viewport_unchanged && door_1_contains_toolbox);
}
-void DrawEditorDoorContent()
+void DrawEditorDoorContent(void)
{
/* needed for gadgets drawn on background (like palette scrollbar) */
SetDoorBackgroundImage(IMG_UNDEFINED);
BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
}
-void DrawLevelEd()
+void DrawLevelEd(void)
{
int fade_mask = REDRAW_FIELD;
SetDoorState(DOOR_OPEN_1 | DOOR_OPEN_2);
}
-static void AdjustDrawingAreaGadgets()
+static void AdjustDrawingAreaGadgets(void)
{
int ed_xsize = lev_fieldx + 2;
int ed_ysize = lev_fieldy + 2;
GDI_END);
}
-static void AdjustLevelScrollPosition()
+static void AdjustLevelScrollPosition(void)
{
if (level_xpos < -1)
level_xpos = -1;
GDI_SCROLLBAR_ITEM_POSITION, item_position, GDI_END);
}
-static void AdjustElementListScrollbar()
+static void AdjustElementListScrollbar(void)
{
struct GadgetInfo *gi = level_editor_gadget[GADGET_ID_SCROLL_LIST_VERTICAL];
int items_max, items_visible, item_position;
ModifyGadget(gi, GDI_AREA_SIZE, xsize, ysize, GDI_END);
}
-static void ModifyEditorElementList()
+static void ModifyEditorElementList(void)
{
int i;
redraw_mask |= REDRAW_DOOR_1;
}
-static void RedrawDrawingElements()
+static void RedrawDrawingElements(void)
{
PickDrawingElement(1, new_element1);
PickDrawingElement(2, new_element2);
}
}
-static void DrawDrawingWindow()
+static void DrawDrawingWindow(void)
{
DrawDrawingWindowExt(TRUE);
}
-static int getTabulatorBarWidth()
+static int getTabulatorBarWidth(void)
{
struct GadgetInfo *gd_gi1 = level_editor_gadget[GADGET_ID_PROPERTIES_INFO];
struct GadgetInfo *gd_gi4 = level_editor_gadget[GADGET_ID_PROPERTIES_CHANGE];
return gd_gi4->x - gd_gi1->x + gd_gi4->width;
}
-static int getTabulatorBarHeight()
+static int getTabulatorBarHeight(void)
{
return ED_TAB_BAR_HEIGHT;
}
-static Pixel getTabulatorBarColor()
+static Pixel getTabulatorBarColor(void)
{
struct GadgetInfo *gd_gi1 = level_editor_gadget[GADGET_ID_LEVELINFO_LEVEL];
struct GadgetDesign *gd = &gd_gi1->alt_design[GD_BUTTON_UNPRESSED];
return GetPixel(gd->bitmap, gd_x, gd_y);
}
-static void DrawLevelInfoTabulatorGadgets()
+static void DrawLevelInfoTabulatorGadgets(void)
{
struct GadgetInfo *gd_gi1 = level_editor_gadget[GADGET_ID_LEVELINFO_LEVEL];
Pixel tab_color = getTabulatorBarColor();
getTabulatorBarWidth(), getTabulatorBarHeight(), tab_color);
}
-static void DrawPropertiesTabulatorGadgets()
+static void DrawPropertiesTabulatorGadgets(void)
{
struct GadgetInfo *gd_gi1 = level_editor_gadget[GADGET_ID_PROPERTIES_INFO];
struct GadgetDesign *gd = &gd_gi1->alt_design[GD_BUTTON_UNPRESSED];
TRUE, FALSE, FALSE);
}
-static void DrawLevelInfoLevel()
+static void DrawLevelInfoLevel(void)
{
int i;
return leveldir_current->subdir;
}
-static void DrawLevelInfoLevelSet_DirectoryInfo()
+static void DrawLevelInfoLevelSet_DirectoryInfo(void)
{
char *directory_text = "Level set directory:";
char *directory_name = getLevelSubdirFromSaveMode(levelset_save_mode);
PrintInfoText(directory_name, font2_nr, x, y);
}
-static void DrawLevelInfoLevelSet()
+static void DrawLevelInfoLevelSet(void)
{
boolean artwork_exists = checkIfCustomArtworkExistsForCurrentLevelSet();
boolean template_exists = fileExists(getLocalLevelTemplateFilename());
DrawLevelInfoLevelSet_DirectoryInfo();
}
-static void DrawLevelInfoEditor()
+static void DrawLevelInfoEditor(void)
{
int i;
MapTextbuttonGadget(ED_TEXTBUTTON_ID_SAVE_AS_TEMPLATE_2);
}
-static void DrawLevelInfoWindow()
+static void DrawLevelInfoWindow(void)
{
char *text = "Global Settings";
int font_nr = FONT_TITLE_1;
DrawLevelInfoEditor();
}
-static void DrawCustomContentArea()
+static void DrawCustomContentArea(void)
{
int id = ED_DRAWING_ID_CUSTOM_CONTENT;
struct GadgetInfo *gi = level_editor_gadget[drawingarea_info[id].gadget_id];
MapDrawingArea(ED_DRAWING_ID_CUSTOM_CONTENT);
}
-static void DrawCustomChangeContentArea()
+static void DrawCustomChangeContentArea(void)
{
int id = ED_DRAWING_ID_CUSTOM_CHANGE_CONTENT;
struct GadgetInfo *gi = level_editor_gadget[drawingarea_info[id].gadget_id];
ED_GADGET_TEXT_DISTANCE + font_height);
}
-static void DrawYamYamContentAreas()
+static void DrawYamYamContentAreas(void)
{
int font_nr = FONT_TEXT_1;
int font_height = getFontHeight(font_nr);
DrawText(x, y + 2 * tilesize, "smashed", font_nr);
}
-static void DrawMagicBallContentAreas()
+static void DrawMagicBallContentAreas(void)
{
int font_nr = FONT_TEXT_1;
int font_height = getFontHeight(font_nr);
MapTextAreaGadget(ED_TEXTAREA_ID_ENVELOPE_INFO);
}
-static void DrawPropertiesInfo()
+static void DrawPropertiesInfo(void)
{
static struct
{
return FALSE;
}
-static void SetAutomaticNumberOfGemsNeeded()
+static void SetAutomaticNumberOfGemsNeeded(void)
{
int x, y;
ModifyEditorCounterValue(ED_COUNTER_ID_LEVEL_GEMSLIMIT, level.gems_needed);
}
-static void DrawPropertiesConfig()
+static void DrawPropertiesConfig(void)
{
boolean draw_footer_line = FALSE;
int max_num_element_counters = 4;
}
}
-static void DrawPropertiesChangeDrawingAreas()
+static void DrawPropertiesChangeDrawingAreas(void)
{
if (IS_CUSTOM_ELEMENT(properties_element))
{
redraw_mask |= REDRAW_FIELD;
}
-static void DrawPropertiesChange()
+static void DrawPropertiesChange(void)
{
int i;
}
}
-static void DrawPropertiesWindow()
+static void DrawPropertiesWindow(void)
{
struct GraphicInfo *gd = &graphic_info[IMG_EDITOR_INPUT_TEXT];
int element_border = graphic_info[IMG_EDITOR_ELEMENT_BORDER].border_size;
DrawPropertiesConfig();
}
-static void DrawPaletteWindow()
+static void DrawPaletteWindow(void)
{
int i;
MapGadget(level_editor_gadget[GADGET_ID_SCROLL_LIST_DOWN]);
}
-static void UpdateCustomElementGraphicGadgets()
+static void UpdateCustomElementGraphicGadgets(void)
{
int i;
last_y = y;
}
-static void ResetIntelliDraw()
+static void ResetIntelliDraw(void)
{
int x, y;
(IS_MM_WALL_EDITOR(element) || element == EL_EMPTY));
}
-static boolean getDrawModeHiRes()
+static boolean getDrawModeHiRes(void)
{
return draw_mode_hires;
}
CopyBrushExt(x, y, 0, 0, 0, CB_BRUSH_TO_CURSOR);
}
-static void DeleteBrushFromCursor()
+static void DeleteBrushFromCursor(void)
{
CopyBrushExt(0, 0, 0, 0, 0, CB_DELETE_OLD_CURSOR);
}
-void DumpBrush()
+void DumpBrush(void)
{
CopyBrushExt(0, 0, 0, 0, 0, CB_DUMP_BRUSH);
}
-void DumpBrush_Small()
+void DumpBrush_Small(void)
{
CopyBrushExt(0, 0, 0, 0, 0, CB_DUMP_BRUSH_SMALL);
}
}
}
-void HandleLevelEditorIdle()
+void HandleLevelEditorIdle(void)
{
int element_border = graphic_info[IMG_EDITOR_ELEMENT_BORDER].border_size;
int x = editor.settings.element_graphic.x + element_border;
FrameCounter++; /* increase animation frame counter */
}
-static void ClearEditorGadgetInfoText()
+static void ClearEditorGadgetInfoText(void)
{
DrawBackground(INFOTEXT_XPOS, INFOTEXT_YPOS, INFOTEXT_XSIZE, INFOTEXT_YSIZE);
}
#include "main.h"
-void CreateLevelEditorGadgets();
-void FreeLevelEditorGadgets();
-void UnmapLevelEditorGadgets();
+void CreateLevelEditorGadgets(void);
+void FreeLevelEditorGadgets(void);
+void UnmapLevelEditorGadgets(void);
void DrawLevelEd(void);
void HandleLevelEditorKeyInput(Key);
-void HandleLevelEditorIdle();
+void HandleLevelEditorIdle(void);
void HandleEditorGadgetInfoText(void *ptr);
void RequestExitLevelEditor(boolean, boolean);
-void PrintEditorElementList();
+void PrintEditorElementList(void);
-void DumpBrush();
-void DumpBrush_Small();
+void DumpBrush(void);
+void DumpBrush_Small(void);
#endif
extern void SetBitmaps_EM(Bitmap **);
extern void UpdateEngineValues(int, int, int, int);
-extern boolean getTeamMode_EM();
+extern boolean getTeamMode_EM(void);
extern int getGameFrameDelay_EM(int);
extern void PlayLevelSound_EM(int, int, int, int);
return FALSE;
}
-void HandleEvents()
+void HandleEvents(void)
{
Event event;
unsigned int event_frame_delay = 0;
}
}
-void HandleMouseCursor()
+void HandleMouseCursor(void)
{
if (game_status == GAME_MODE_TITLE)
{
}
}
-void ClearAutoRepeatKeyEvents()
+void ClearAutoRepeatKeyEvents(void)
{
while (PendingEvent())
{
}
}
-void ClearEventQueue()
+void ClearEventQueue(void)
{
Event event;
}
}
-void ClearPlayerMouseAction()
+void ClearPlayerMouseAction(void)
{
local_player->mouse_action.lx = 0;
local_player->mouse_action.ly = 0;
local_player->mouse_action.button = 0;
}
-void ClearPlayerAction()
+void ClearPlayerAction(void)
{
int i;
SetTileCursorXY(lx, ly);
}
-void SleepWhileUnmapped()
+void SleepWhileUnmapped(void)
{
boolean window_unmapped = TRUE;
#if defined(TARGET_SDL2)
-static boolean checkTextInputKeyModState()
+static boolean checkTextInputKeyModState(void)
{
// when playing, only handle raw key events and ignore text input
if (game_status == GAME_MODE_PLAYING)
HandleKeysDebug(key);
}
-void HandleNoEvent()
+void HandleNoEvent(void)
{
HandleMouseCursor();
}
}
-void HandleEventActions()
+void HandleEventActions(void)
{
// if (button_status && game_status != GAME_MODE_PLAYING)
if (button_status && (game_status != GAME_MODE_PLAYING ||
}
}
-static int HandleJoystickForAllPlayers()
+static int HandleJoystickForAllPlayers(void)
{
int i;
int result = 0;
return result;
}
-void HandleJoystick()
+void HandleJoystick(void)
{
static unsigned int joytest_delay = 0;
static unsigned int joytest_delay_value = GADGET_FRAME_DELAY;
void HandleButton(int, int, int, int);
void HandleKey(Key, int);
-void HandleJoystick();
+void HandleJoystick(void);
void HandleSpecialGameControllerButtons(Event *);
void HandleSpecialGameControllerKeys(Key, int);
return FALSE;
}
-static struct DateInfo getCurrentDate()
+static struct DateInfo getCurrentDate(void)
{
time_t epoch_seconds = time(NULL);
struct tm *now = localtime(&epoch_seconds);
change->has_event[i] = FALSE;
}
-static void resetEventBits()
+static void resetEventBits(void)
{
int i;
int getMappedElement_SB(int, boolean);
-static void ActivateLevelTemplate()
+static void ActivateLevelTemplate(void)
{
int x, y;
return filetype;
}
-char *getLocalLevelTemplateFilename()
+char *getLocalLevelTemplateFilename(void)
{
return getDefaultLevelFilename(-1);
}
-char *getGlobalLevelTemplateFilename()
+char *getGlobalLevelTemplateFilename(void)
{
/* global variable "leveldir_current" must be modified in the loop below */
LevelDirTree *leveldir_current_last = leveldir_current;
demo->is_available = TRUE;
}
-static void setTapeInfoToDefaults();
+static void setTapeInfoToDefaults(void);
static void CopyNativeTape_SP_to_RND(struct LevelInfo *level)
{
CopyNativeLevel_RND_to_Native(level);
}
-static void LoadLevelTemplate_LoadAndInit()
+static void LoadLevelTemplate_LoadAndInit(void)
{
LoadLevelFromFileInfo(&level_template, &level_template.file_info, FALSE);
SaveLevelFromFilename(&level, filename, FALSE);
}
-void SaveLevelTemplate()
+void SaveLevelTemplate(void)
{
char *filename = getLocalLevelTemplateFilename();
/* tape file functions */
/* ========================================================================= */
-static void setTapeInfoToDefaults()
+static void setTapeInfoToDefaults(void)
{
int i;
}
}
-static void LoadSetup_SpecialPostProcessing()
+static void LoadSetup_SpecialPostProcessing(void)
{
char *player_name_new;
MIN(MAX(MIN_SCROLL_DELAY, setup.scroll_delay_value), MAX_SCROLL_DELAY);
}
-void LoadSetup()
+void LoadSetup(void)
{
char *filename;
LoadSetup_SpecialPostProcessing();
}
-void LoadSetup_AutoSetup()
+void LoadSetup_AutoSetup(void)
{
char *filename = getPath2(getSetupDir(), AUTOSETUP_FILENAME);
SetupFileHash *setup_file_hash = NULL;
free(filename);
}
-void LoadSetup_EditorCascade()
+void LoadSetup_EditorCascade(void)
{
char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
SetupFileHash *setup_file_hash = NULL;
fclose(file);
}
-void SaveSetup()
+void SaveSetup(void)
{
char *filename = getSetupFilename();
FILE *file;
SetFilePermissions(filename, PERMS_PRIVATE);
}
-void SaveSetup_AutoSetup()
+void SaveSetup_AutoSetup(void)
{
char *filename = getPath2(getSetupDir(), AUTOSETUP_FILENAME);
FILE *file;
free(filename);
}
-void SaveSetup_EditorCascade()
+void SaveSetup_EditorCascade(void)
{
char *filename = getPath2(getSetupDir(), EDITORCASCADE_FILENAME);
FILE *file;
free(filename);
}
-void LoadCustomElementDescriptions()
+void LoadCustomElementDescriptions(void)
{
char *filename = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
SetupFileHash *setup_file_hash;
return get_parameter_value(value_raw, suffix, TYPE_INTEGER);
}
-void InitMenuDesignSettings_Static()
+void InitMenuDesignSettings_Static(void)
{
int i;
}
}
-static void InitMenuDesignSettings_SpecialPreProcessing()
+static void InitMenuDesignSettings_SpecialPreProcessing(void)
{
int i;
}
}
-static void InitMenuDesignSettings_SpecialPostProcessing()
+static void InitMenuDesignSettings_SpecialPostProcessing(void)
{
static struct
{
*game_buttons_xy[i].dst = *game_buttons_xy[i].src;
}
-static void InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics()
+static void InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics(void)
{
static struct
{
freeSetupFileHash(setup_file_hash);
}
-void LoadMenuDesignSettings()
+void LoadMenuDesignSettings(void)
{
char *filename_base = UNDEFINED_FILENAME, *filename_local;
InitMenuDesignSettings_SpecialPostProcessing();
}
-void LoadMenuDesignSettings_AfterGraphics()
+void LoadMenuDesignSettings_AfterGraphics(void)
{
InitMenuDesignSettings_SpecialPostProcessing_AfterGraphics();
}
return music_info_listed_ext(list, basename, TRUE);
}
-void LoadMusicInfo()
+void LoadMusicInfo(void)
{
char *music_directory = getCustomMusicDirectory();
int num_music = getMusicListSize();
Error(ERR_INFO_LINE, "-");
}
-void LoadHelpAnimInfo()
+void LoadHelpAnimInfo(void)
{
char *filename = getHelpAnimFilename();
SetupFileList *setup_file_list = NULL, *list;
#endif
}
-void LoadHelpTextInfo()
+void LoadHelpTextInfo(void)
{
char *filename = getHelpTextFilename();
int i;
#define MAX_NUM_CONVERT_LEVELS 1000
-void ConvertLevels()
+void ConvertLevels(void)
{
static LevelDirTree *convert_leveldir = NULL;
static int convert_level_nr = -1;
/* create and save images for use in level sketches (raw BMP format) */
/* ------------------------------------------------------------------------- */
-void CreateLevelSketchImages()
+void CreateLevelSketchImages(void)
{
#if defined(TARGET_SDL)
Bitmap *bitmap1;
void copyElementInfo(struct ElementInfo *, struct ElementInfo *);
char *getDefaultLevelFilename(int);
-char *getLocalLevelTemplateFilename();
-char *getGlobalLevelTemplateFilename();
+char *getLocalLevelTemplateFilename(void);
+char *getGlobalLevelTemplateFilename(void);
void LoadLevelFromFilename(struct LevelInfo *, char *);
void LoadLevel(int);
void LoadLevelInfoOnly(int);
void LoadNetworkLevel(struct NetworkLevelInfo *);
void SaveLevel(int);
-void SaveLevelTemplate();
+void SaveLevelTemplate(void);
void SaveNativeLevel(struct LevelInfo *);
void DumpLevel(struct LevelInfo *);
boolean SaveLevelChecked(int);
void SaveScore(int);
void LoadSetupFromFilename(char *);
-void LoadSetup();
-void SaveSetup();
+void LoadSetup(void);
+void SaveSetup(void);
-void LoadSetup_AutoSetup();
-void SaveSetup_AutoSetup();
+void LoadSetup_AutoSetup(void);
+void SaveSetup_AutoSetup(void);
-void LoadSetup_EditorCascade();
-void SaveSetup_EditorCascade();
+void LoadSetup_EditorCascade(void);
+void SaveSetup_EditorCascade(void);
void SaveSetup_AddGameControllerMapping(char *);
void setHideSetupEntry(void *);
boolean hideSetupEntry(void *);
-void LoadCustomElementDescriptions();
-void InitMenuDesignSettings_Static();
-void LoadMenuDesignSettings();
-void LoadMenuDesignSettings_AfterGraphics();
+void LoadCustomElementDescriptions(void);
+void InitMenuDesignSettings_Static(void);
+void LoadMenuDesignSettings(void);
+void LoadMenuDesignSettings_AfterGraphics(void);
void LoadUserDefinedEditorElementList(int **, int *);
-void LoadMusicInfo();
-void LoadHelpAnimInfo();
-void LoadHelpTextInfo();
+void LoadMusicInfo(void);
+void LoadHelpAnimInfo(void);
+void LoadHelpTextInfo(void);
-void ConvertLevels();
-void CreateLevelSketchImages();
+void ConvertLevels(void);
+void CreateLevelSketchImages(void);
void CreateCustomElementImages(char *);
#endif /* FILES_H */
static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
static void PlayLevelSoundActionIfLoop(int, int, int);
static void StopLevelSoundActionIfLoop(int, int, int);
-static void PlayLevelMusic();
-static void FadeLevelSoundsAndMusic();
+static void PlayLevelMusic(void);
+static void FadeLevelSoundsAndMusic(void);
static void HandleGameButtons(struct GadgetInfo *);
(x) += playfield_scan_delta_x)
#ifdef DEBUG
-void DEBUG_SetMaximumDynamite()
+void DEBUG_SetMaximumDynamite(void)
{
int i;
}
#endif
-static void InitPlayfieldScanModeVars()
+static void InitPlayfieldScanModeVars(void)
{
if (game.use_reverse_scan_direction)
{
}
}
-void GetPlayerConfig()
+void GetPlayerConfig(void)
{
GameFrameDelay = setup.game_frame_delay;
return stored_player[player_nr].inventory_size;
}
-void InitGameControlValues()
+void InitGameControlValues(void)
{
int i;
sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
}
-void UpdatePlayfieldElementCount()
+void UpdatePlayfieldElementCount(void)
{
boolean use_element_count = FALSE;
int i, j, x, y;
element_info[j].element_count;
}
-void UpdateGameControlValues()
+void UpdateGameControlValues(void)
{
int i, k;
int time = (local_player->LevelSolved ?
}
}
-void DisplayGameControlValues()
+void DisplayGameControlValues(void)
{
boolean redraw_panel = FALSE;
int i;
SetGameStatus(GAME_MODE_PLAYING);
}
-void UpdateAndDisplayGameControlValues()
+void UpdateAndDisplayGameControlValues(void)
{
if (tape.deactivate_display)
return;
DisplayGameControlValues();
}
-void UpdateGameDoorValues()
+void UpdateGameDoorValues(void)
{
UpdateGameControlValues();
}
-void DrawGameDoorValues()
+void DrawGameDoorValues(void)
{
DisplayGameControlValues();
}
=============================================================================
*/
-static void InitGameEngine()
+static void InitGameEngine(void)
{
int i, j, k, l, x, y;
}
#endif
-void InitGame()
+void InitGame(void)
{
int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
player->LevelSolved_CountingHealth = player->health_final;
}
-void GameWon()
+void GameWon(void)
{
static int time_count_steps;
static int time, time_final;
GameEnd();
}
-void GameEnd()
+void GameEnd(void)
{
int hi_pos;
}
}
-static boolean checkIfAllPlayersFitToScreen_RND()
+static boolean checkIfAllPlayersFitToScreen_RND(void)
{
int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
PlayLevelSound(x, y, SND_ACID_SPLASHING);
}
-static void InitBeltMovement()
+static void InitBeltMovement(void)
{
static int belt_base_element[4] =
{
element);
}
-static void RedrawAllLightSwitchesAndInvisibleElements()
+static void RedrawAllLightSwitchesAndInvisibleElements(void)
{
int x, y;
}
}
-static void RedrawAllInvisibleElementsForLenses()
+static void RedrawAllInvisibleElementsForLenses(void)
{
int x, y;
}
}
-static void RedrawAllInvisibleElementsForMagnifier()
+static void RedrawAllInvisibleElementsForMagnifier(void)
{
int x, y;
PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
}
-static void CloseAllOpenTimegates()
+static void CloseAllOpenTimegates(void)
{
int x, y;
}
}
-static void PlayAllPlayersSound()
+static void PlayAllPlayersSound(void)
{
int i;
tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
}
-static void CheckLevelTime()
+static void CheckLevelTime(void)
{
int i;
InitGame();
}
-void GameActionsExt()
+void GameActionsExt(void)
{
#if 0
static unsigned int game_frame_delay = 0;
}
}
-static void GameActions_CheckSaveEngineSnapshot()
+static void GameActions_CheckSaveEngineSnapshot(void)
{
if (!game.snapshot.save_snapshot)
return;
SaveEngineSnapshotToList();
}
-void GameActions()
+void GameActions(void)
{
GameActionsExt();
GameActions_CheckSaveEngineSnapshot();
}
-void GameActions_EM_Main()
+void GameActions_EM_Main(void)
{
byte effective_action[MAX_PLAYERS];
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
GameActions_EM(effective_action, warp_mode);
}
-void GameActions_SP_Main()
+void GameActions_SP_Main(void)
{
byte effective_action[MAX_PLAYERS];
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
}
}
-void GameActions_MM_Main()
+void GameActions_MM_Main(void)
{
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
GameActions_MM(local_player->effective_mouse_action, warp_mode);
}
-void GameActions_RND_Main()
+void GameActions_RND_Main(void)
{
GameActions_RND();
}
-void GameActions_RND()
+void GameActions_RND(void)
{
int magic_wall_x = 0, magic_wall_y = 0;
int i, x, y, element, graphic, last_gfx_frame;
return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
}
-static boolean AllPlayersInVisibleScreen()
+static boolean AllPlayersInVisibleScreen(void)
{
int i;
static int *loop_sound_frame = NULL;
static int *loop_sound_volume = NULL;
-void InitPlayLevelSound()
+void InitPlayLevelSound(void)
{
int num_sounds = getSoundListSize();
StopSound(sound_effect);
}
-static int getLevelMusicNr()
+static int getLevelMusicNr(void)
{
if (levelset.music[level_nr] != MUS_UNDEFINED)
return levelset.music[level_nr]; /* from config file */
return MAP_NOCONF_MUSIC(level_nr); /* from music dir */
}
-static void FadeLevelSounds()
+static void FadeLevelSounds(void)
{
FadeSounds();
}
-static void FadeLevelMusic()
+static void FadeLevelMusic(void)
{
int music_nr = getLevelMusicNr();
char *curr_music = getCurrentlyPlayingMusicFilename();
FadeMusic();
}
-void FadeLevelSoundsAndMusic()
+void FadeLevelSoundsAndMusic(void)
{
FadeLevelSounds();
FadeLevelMusic();
}
-static void PlayLevelMusic()
+static void PlayLevelMusic(void)
{
int music_nr = getLevelMusicNr();
char *curr_music = getCurrentlyPlayingMusicFilename();
static char *snapshot_level_identifier = NULL;
static int snapshot_level_nr = -1;
-static void SaveEngineSnapshotValues_RND()
+static void SaveEngineSnapshotValues_RND(void)
{
static int belt_base_active_element[4] =
{
}
}
-static void LoadEngineSnapshotValues_RND()
+static void LoadEngineSnapshotValues_RND(void)
{
unsigned int num_random_calls = game.num_random_calls;
int i, j;
}
}
-void FreeEngineSnapshotSingle()
+void FreeEngineSnapshotSingle(void)
{
FreeSnapshotSingle();
snapshot_level_nr = -1;
}
-void FreeEngineSnapshotList()
+void FreeEngineSnapshotList(void)
{
FreeSnapshotList();
}
-ListNode *SaveEngineSnapshotBuffers()
+ListNode *SaveEngineSnapshotBuffers(void)
{
ListNode *buffers = NULL;
return buffers;
}
-void SaveEngineSnapshotSingle()
+void SaveEngineSnapshotSingle(void)
{
ListNode *buffers = SaveEngineSnapshotBuffers();
snapshot_level_nr = level_nr;
}
-boolean CheckSaveEngineSnapshotToList()
+boolean CheckSaveEngineSnapshotToList(void)
{
boolean save_snapshot =
((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
return save_snapshot;
}
-void SaveEngineSnapshotToList()
+void SaveEngineSnapshotToList(void)
{
if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
tape.quick_resume)
SaveSnapshotToList(buffers);
}
-void SaveEngineSnapshotToListInitial()
+void SaveEngineSnapshotToListInitial(void)
{
FreeEngineSnapshotList();
SaveEngineSnapshotToList();
}
-void LoadEngineSnapshotValues()
+void LoadEngineSnapshotValues(void)
{
/* restore special values from snapshot structure */
LoadEngineSnapshotValues_MM();
}
-void LoadEngineSnapshotSingle()
+void LoadEngineSnapshotSingle(void)
{
LoadSnapshotSingle();
LoadEngineSnapshotValues();
}
-boolean CheckEngineSnapshotSingle()
+boolean CheckEngineSnapshotSingle(void)
{
return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
snapshot_level_nr == level_nr);
}
-boolean CheckEngineSnapshotList()
+boolean CheckEngineSnapshotList(void)
{
return CheckSnapshotList();
}
}
};
-void CreateGameButtons()
+void CreateGameButtons(void)
{
int i;
}
}
-void FreeGameButtons()
+void FreeGameButtons(void)
{
int i;
UnmapGadget(game_gadget[i]);
}
-static void UnmapGameButtonsAtSamePosition_All()
+static void UnmapGameButtonsAtSamePosition_All(void)
{
if (setup.show_snapshot_buttons)
{
UnmapGameButtonsAtSamePosition_All();
}
-void MapUndoRedoButtons()
+void MapUndoRedoButtons(void)
{
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
ModifyGadget(game_gadget[GAME_CTRL_ID_PAUSE2], GDI_CHECKED, TRUE, GDI_END);
}
-void UnmapUndoRedoButtons()
+void UnmapUndoRedoButtons(void)
{
UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
RedrawGadget(game_gadget[id2]);
}
-void MapGameButtons()
+void MapGameButtons(void)
{
MapGameButtonsExt(FALSE);
}
-void UnmapGameButtons()
+void UnmapGameButtons(void)
{
UnmapGameButtonsExt(FALSE);
}
-void RedrawGameButtons()
+void RedrawGameButtons(void)
{
RedrawGameButtonsExt(FALSE);
}
-void MapGameButtonsOnTape()
+void MapGameButtonsOnTape(void)
{
MapGameButtonsExt(TRUE);
}
-void UnmapGameButtonsOnTape()
+void UnmapGameButtonsOnTape(void)
{
UnmapGameButtonsExt(TRUE);
}
-void RedrawGameButtonsOnTape()
+void RedrawGameButtonsOnTape(void)
{
RedrawGameButtonsExt(TRUE);
}
-void GameUndoRedoExt()
+void GameUndoRedoExt(void)
{
ClearPlayerAction();
#ifdef DEBUG
-void DEBUG_SetMaximumDynamite();
+void DEBUG_SetMaximumDynamite(void);
#endif
void GetPlayerConfig(void);
void DrawGameValue_Time(int);
void DrawGameDoorValues(void);
-void UpdateAndDisplayGameControlValues();
+void UpdateAndDisplayGameControlValues(void);
-void InitGameSound();
-void InitGame();
+void InitGameSound(void);
+void InitGame(void);
void UpdateEngineValues(int, int, int, int);
void GameWon(void);
void StartGameActions(boolean, boolean, int);
void GameActions(void);
-void GameActions_EM_Main();
-void GameActions_SP_Main();
-void GameActions_MM_Main();
-void GameActions_RND_Main();
-void GameActions_RND();
+void GameActions_EM_Main(void);
+void GameActions_SP_Main(void);
+void GameActions_MM_Main(void);
+void GameActions_RND_Main(void);
+void GameActions_RND(void);
void ScrollLevel(int, int);
-void InitPlayLevelSound();
+void InitPlayLevelSound(void);
void PlayLevelSound_EM(int, int, int, int);
void PlayLevelSound_SP(int, int, int, int);
void PlayLevelSound_MM(int, int, int, int);
unsigned int InitEngineRandom_RND(int);
unsigned int RND(int);
-void FreeEngineSnapshotSingle();
-void FreeEngineSnapshotList();
-void LoadEngineSnapshotSingle();
-void SaveEngineSnapshotSingle();
-boolean CheckSaveEngineSnapshotToList();
-void SaveEngineSnapshotToList();
-void SaveEngineSnapshotToListInitial();
-boolean CheckEngineSnapshotSingle();
-boolean CheckEngineSnapshotList();
-
-void CreateGameButtons();
-void FreeGameButtons();
-void MapUndoRedoButtons();
-void UnmapUndoRedoButtons();
-void MapGameButtons();
-void UnmapGameButtons();
-void RedrawGameButtons();
-void MapGameButtonsOnTape();
-void UnmapGameButtonsOnTape();
-void RedrawGameButtonsOnTape();
+void FreeEngineSnapshotSingle(void);
+void FreeEngineSnapshotList(void);
+void LoadEngineSnapshotSingle(void);
+void SaveEngineSnapshotSingle(void);
+boolean CheckSaveEngineSnapshotToList(void);
+void SaveEngineSnapshotToList(void);
+void SaveEngineSnapshotToListInitial(void);
+boolean CheckEngineSnapshotSingle(void);
+boolean CheckEngineSnapshotList(void);
+
+void CreateGameButtons(void);
+void FreeGameButtons(void);
+void MapUndoRedoButtons(void);
+void UnmapUndoRedoButtons(void);
+void MapGameButtons(void);
+void UnmapGameButtons(void);
+void RedrawGameButtons(void);
+void MapGameButtonsOnTape(void);
+void UnmapGameButtonsOnTape(void);
+void RedrawGameButtonsOnTape(void);
void HandleSoundButtonKeys(Key);
extern struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][SPR_MAX][8];
extern struct EngineSnapshotInfo_EM engine_snapshot_em;
-extern void em_open_all();
-extern void em_close_all();
+extern void em_open_all(void);
+extern void em_close_all(void);
-extern void InitGfxBuffers_EM();
+extern void InitGfxBuffers_EM(void);
-extern void InitGameEngine_EM();
+extern void InitGameEngine_EM(void);
extern void GameActions_EM(byte *, boolean);
extern unsigned int InitEngineRandom_EM(int);
-extern void setLevelInfoToDefaults_EM();
+extern void setLevelInfoToDefaults_EM(void);
extern boolean LoadNativeLevel_EM(char *, boolean);
-extern int getFieldbufferOffsetX_EM();
-extern int getFieldbufferOffsetY_EM();
+extern int getFieldbufferOffsetX_EM(void);
+extern int getFieldbufferOffsetY_EM(void);
extern void BackToFront_EM(void);
extern void BlitScreenToBitmap_EM(Bitmap *);
extern void RedrawPlayfield_EM(boolean);
-extern void LoadEngineSnapshotValues_EM();
-extern void SaveEngineSnapshotValues_EM();
+extern void LoadEngineSnapshotValues_EM(void);
+extern void SaveEngineSnapshotValues_EM(void);
#endif /* EXPORT_H */
static int screentiles[MAX_PLAYFIELD_HEIGHT + 2][MAX_PLAYFIELD_WIDTH + 2];
static int crumbled_state[MAX_PLAYFIELD_HEIGHT + 2][MAX_PLAYFIELD_WIDTH + 2];
-int getFieldbufferOffsetX_EM()
+int getFieldbufferOffsetX_EM(void)
{
return screen_x % TILEX;
}
-int getFieldbufferOffsetY_EM()
+int getFieldbufferOffsetY_EM(void)
{
return screen_y % TILEY;
}
}
}
-boolean checkIfAllPlayersFitToScreen()
+boolean checkIfAllPlayersFitToScreen(void)
{
int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
char *progname;
char *arg_basedir;
-extern void tab_generate();
-extern void tab_generate_graphics_info_em();
+extern void tab_generate(void);
+extern void tab_generate_graphics_info_em(void);
int open_all(void)
{
return 0;
}
-void InitGfxBuffers_EM()
+void InitGfxBuffers_EM(void)
{
ReCreateBitmap(&screenBitmap, MAX_BUF_XSIZE * TILEX, MAX_BUF_YSIZE * TILEY);
global_em_info.screenbuffer = screenBitmap;
}
-void em_open_all()
+void em_open_all(void)
{
/* pre-calculate some data */
tab_generate();
Boom = Index[3];
}
-void InitGameEngine_EM()
+void InitGameEngine_EM(void)
{
prepare_em_level();
RedrawPlayfield_EM(FALSE);
}
-void UpdateGameDoorValues_EM()
+void UpdateGameDoorValues_EM(void)
{
}
ply->joy_snap = snap;
}
-void SaveEngineSnapshotValues_EM()
+void SaveEngineSnapshotValues_EM(void)
{
int i, j, k;
engine_snapshot_em.Array[i][j][k] = Array[i][j][k];
}
-void LoadEngineSnapshotValues_EM()
+void LoadEngineSnapshotValues_EM(void)
{
int i, j, k;
#define USE_CHANGED_ACID_STUFF 1
-extern boolean checkIfAllPlayersFitToScreen();
+extern boolean checkIfAllPlayersFitToScreen(void);
static void check_player(struct PLAYER *);
static void kill_player(struct PLAYER *);
array[i] = buffer[i];
}
-void create_explode()
+void create_explode(void)
{
int i;
int *tile = tile_explode;
tab_explode_dynamite[i] = buffer[i];
}
-void create_obj()
+void create_obj(void)
{
int i, j;
int *map = obj_map;
map_obj[i][j] = buffer[7 - i][j];
}
-void create_obj_graphics_info_em()
+void create_obj_graphics_info_em(void)
{
int i, j;
}
}
-void create_spr()
+void create_spr(void)
{
int i, j, k;
int *map = spr_map;
map_spr[i][j][k] = buffer[i][7 - j][k];
}
-void create_spr_graphics_info_em()
+void create_spr_graphics_info_em(void)
{
int i, j, k;
}
}
-void tab_generate()
+void tab_generate(void)
{
create_tab(tile_blank, tab_blank);
create_tab(tile_acid, tab_acid);
create_spr();
}
-void tab_generate_graphics_info_em()
+void tab_generate_graphics_info_em(void)
{
create_obj_graphics_info_em();
create_spr_graphics_info_em();
extern short Ur[MM_MAX_PLAYFIELD_WIDTH][MM_MAX_PLAYFIELD_HEIGHT];
-extern void mm_open_all();
-extern void mm_close_all();
+extern void mm_open_all(void);
+extern void mm_close_all(void);
-void InitElementProperties_MM();
+void InitElementProperties_MM(void);
-extern void InitGfxBuffers_MM();
+extern void InitGfxBuffers_MM(void);
-extern void InitGameEngine_MM();
-extern void InitGameActions_MM();
+extern void InitGameEngine_MM(void);
+extern void InitGameActions_MM(void);
extern void GameActions_MM(struct MouseActionInfo, boolean);
-extern void DrawLaser_MM();
+extern void DrawLaser_MM(void);
extern boolean ClickElement(int, int, int);
extern unsigned int InitEngineRandom_MM(int);
-extern void setLevelInfoToDefaults_MM();
-extern void copyInternalEngineVars_MM();
+extern void setLevelInfoToDefaults_MM(void);
+extern void copyInternalEngineVars_MM(void);
extern boolean LoadNativeLevel_MM(char *, boolean);
extern void SaveNativeLevel_MM(char *);
-extern int getFieldbufferOffsetX_MM();
-extern int getFieldbufferOffsetY_MM();
+extern int getFieldbufferOffsetX_MM(void);
+extern int getFieldbufferOffsetY_MM(void);
extern void BlitScreenToBitmap_MM(Bitmap *);
-extern void RedrawPlayfield_MM();
+extern void RedrawPlayfield_MM(void);
-extern void LoadEngineSnapshotValues_MM();
+extern void LoadEngineSnapshotValues_MM(void);
extern void SaveEngineSnapshotValues_MM(ListNode **);
extern int getButtonFromTouchPosition(int, int, int, int);
fputc(0, file); /* not used */
}
-void setLevelInfoToDefaults_MM()
+void setLevelInfoToDefaults_MM(void)
{
int i, x, y;
return (pixel == WHITE_PIXEL);
}
-static void CheckExitMM()
+static void CheckExitMM(void)
{
int exit_element = EL_EMPTY;
int exit_x = 0;
}
}
-static void InitCycleElements_RotateSingleStep()
+static void InitCycleElements_RotateSingleStep(void)
{
int i;
}
}
-static void InitLaser()
+static void InitLaser(void)
{
int start_element = Feld[laser.start_edge.x][laser.start_edge.y];
int step = (IS_LASER(start_element) ? 4 : 0);
native_mm_level.laser_blue * 0xFF);
}
-void InitGameEngine_MM()
+void InitGameEngine_MM(void)
{
int i, x, y;
DrawLevel_MM();
}
-void InitGameActions_MM()
+void InitGameActions_MM(void)
{
int num_init_game_frames = INIT_GAME_ACTIONS_DELAY;
int cycle_steps_done = 0;
laser.num_damages++;
}
-boolean StepBehind()
+boolean StepBehind(void)
{
if (laser.num_edges)
{
return IMG_MM_MASK_CIRCLE;
}
-int ScanPixel()
+int ScanPixel(void)
{
int hit_mask = 0;
return hit_mask;
}
-void ScanLaser()
+void ScanLaser(void)
{
int element;
int end = 0, rf = laser.num_edges;
game_mm.laser_enabled = mode;
}
-void DrawLaser_MM()
+void DrawLaser_MM(void)
{
DrawLaser(0, game_mm.laser_enabled);
}
}
}
-void AutoRotateMirrors()
+void AutoRotateMirrors(void)
{
int x, y;
CheckSingleStepMode_MM(element_clicked, button_released);
}
-void MovePacMen()
+void MovePacMen(void)
{
int mx, my, ox, oy, nx, ny;
int element;
}
}
-void GameWon_MM()
+void GameWon_MM(void)
{
int hi_pos;
boolean raise_level = FALSE;
BackToFront();
}
-int NewHiScore_MM()
+int NewHiScore_MM(void)
{
int k, l;
int position = -1;
engine_snapshot_mm.overload_delay = overload_delay;
}
-void LoadEngineSnapshotValues_MM()
+void LoadEngineSnapshotValues_MM(void)
{
int x, y;
boolean PlaceBomb(struct PlayerInfo *);
void PlaySoundLevel(int, int, int);
-void CreateGameButtons();
-void UnmapGameButtons();
+void CreateGameButtons(void);
+void UnmapGameButtons(void);
void AddLaserEdge(int, int);
void AddDamagedField(int, int);
return InitEngineRandom(seed);
}
-void InitElementProperties_MM()
+void InitElementProperties_MM(void)
{
int i,j;
Elementeigenschaften[i] |= EP_BIT_WALL;
}
-void mm_open_all()
+void mm_open_all(void)
{
InitElementProperties_MM();
}
-void mm_close_all()
+void mm_close_all(void)
{
}
SetTileCursorSXSY(cSX, cSY);
}
-void ClearWindow()
+void ClearWindow(void)
{
ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
DrawElement_MM(x, y, element);
}
-void DrawLevel_MM()
+void DrawLevel_MM(void)
{
int x,y;
}
}
-void RedrawPlayfield_MM()
+void RedrawPlayfield_MM(void)
{
DrawLevel_MM();
DrawLaser_MM();
void SetDrawtoField_MM(int);
-void BackToFront();
-void FadeToFront();
-void ClearWindow();
+void BackToFront(void);
+void FadeToFront(void);
+void ClearWindow(void);
void MarkTileDirty(int, int);
unsigned int CloseDoor(unsigned int);
unsigned int GetDoorState(void);
unsigned int MoveDoor(unsigned int);
-void DrawSpecialEditorDoor_MM();
-void UndrawSpecialEditorDoor();
+void DrawSpecialEditorDoor_MM(void);
+void UndrawSpecialEditorDoor(void);
Pixel ReadPixel(DrawBuffer *, int, int);
void SetRGB(unsigned int, unsigned short, unsigned short, unsigned short);
-void CreateToolButtons();
+void CreateToolButtons(void);
int get_base_element(int);
int get_element_phase(int);
// Randomize random number generator
// ==========================================================================
-void subRandomize()
+void subRandomize(void)
{
int Tick = MyGetTickCount();
// Generate new random number, first method (see also sub_g_8580)
// ==========================================================================
-int subGetRandomNumber()
+int subGetRandomNumber(void)
{
RandomSeed = (RandomSeed * 0x5E5 + 0x31) & 0xFFFF;
extern void subAnimateBugs(int si);
extern void subAnimateTerminals(int si);
-extern void subRandomize();
-extern int subGetRandomNumber();
+extern void subRandomize(void);
+extern int subGetRandomNumber(void);
#endif /* BUGSTERMINALS_H */
int ScreenBuffer[2 + MAX_PLAYFIELD_WIDTH + 2][2 + MAX_PLAYFIELD_HEIGHT + 2];
-int getFieldbufferOffsetX_SP()
+int getFieldbufferOffsetX_SP(void)
{
int px = 2 * TILEX + (mScrollX - mScrollX_last) % TILEX;
return px;
}
-int getFieldbufferOffsetY_SP()
+int getFieldbufferOffsetY_SP(void)
{
int py = 2 * TILEY + (mScrollY - mScrollY_last) % TILEY;
return py;
}
-void RestorePlayfield()
+void RestorePlayfield(void)
{
int x1 = mScrollX / TILEX - 2;
int y1 = mScrollY / TILEY - 2;
}
}
-static void ScrollPlayfieldIfNeeded()
+static void ScrollPlayfieldIfNeeded(void)
{
ScrollPlayfieldIfNeededExt(FALSE);
}
-void InitScrollPlayfield()
+void InitScrollPlayfield(void)
{
ScrollPlayfieldIfNeededExt(TRUE);
}
extern int mScrollX_last, mScrollY_last;
-extern void InitScrollPlayfield();
+extern void InitScrollPlayfield(void);
extern void UpdatePlayfield(boolean);
-extern void RestorePlayfield();
+extern void RestorePlayfield(void);
extern void DDScrollBuffer_ScrollTo(int X, int Y);
extern void DDScrollBuffer_ScrollTowards(int X, int Y, double Step);
int DisplayMinY, DisplayMaxY;
-void subDisplayLevel()
+void subDisplayLevel(void)
{
if (NoDisplayFlag || ! LevelLoaded)
return;
extern int DisplayMinX, DisplayMaxX;
extern int DisplayMinY, DisplayMaxY;
-extern void subDisplayLevel();
+extern void subDisplayLevel(void);
extern void ScrollTo(int, int);
extern void ScrollTowards(int, int);
extern void SoftScrollTo(int, int, int, int);
// Do game stuff
// ==========================================================================
-void subDoGameStuff()
+void subDoGameStuff(void)
{
int si, cx, dx, bl;
int InfotronsNeeded_last = InfotronsNeeded;
extern int AnimationPosTable[SP_MAX_PLAYFIELD_SIZE];
extern byte AnimationSubTable[SP_MAX_PLAYFIELD_SIZE];
-extern void subDoGameStuff();
+extern void subDoGameStuff(void);
#endif /* DOGAMESTUFF_H */
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
}
-void subRedDiskReleaseExplosion()
+void subRedDiskReleaseExplosion(void)
{
int al, X, Y, si;
}
}
-void subFollowUpExplosions()
+void subFollowUpExplosions(void)
{
int ax, si;
extern void ExplodeFieldSP(int);
extern void subAnimateExplosion(int);
extern void subClearFieldDueToExplosion(int);
-extern void subFollowUpExplosions();
-extern void subRedDiskReleaseExplosion();
+extern void subFollowUpExplosions(void);
+extern void subRedDiskReleaseExplosion(void);
#endif /* EXPLOSIONS_H */
}
}
-void InitGlobals()
+void InitGlobals(void)
{
InitPrecedingPlayfieldMemory();
return StretchWidth * (si / FieldWidth);
}
-void PrepareLevel()
+void PrepareLevel(void)
{
copyInternalEngineVars_SP();
extern int GetStretchY(int si);
extern int GetX(int si);
extern int GetY(int si);
-extern void InitGlobals();
+extern void InitGlobals(void);
-extern void PrepareLevel();
+extern void PrepareLevel(void);
extern int getSequenceLength(int sequence);
extern boolean isSnappingSequence(int sequence);
// Init game conditions (variables)
// ==========================================================================
-void subInitGameConditions()
+void subInitGameConditions(void)
{
MurphyVarFaceLeft = 0;
KillMurphyFlag = 0; // no "kill Murphy"
// Locate Murphy and init location.
// ==========================================================================
-void InitMurphyPos()
+void InitMurphyPos(void)
{
int si;
// Convert to easy symbols and reset Infotron count If not ThenVer62
// ==========================================================================
-int subConvertToEasySymbols()
+int subConvertToEasySymbols(void)
{
int ax, bx, cx, dx, i;
int al;
// Fetch and initialize a level
// ==========================================================================
-void subFetchAndInitLevelB()
+void subFetchAndInitLevelB(void)
{
subFetchAndInitLevelA();
}
-void subFetchAndInitLevelA()
+void subFetchAndInitLevelA(void)
{
GameBusyFlag = 0; // restore scissors too
subFetchAndInitLevel(); // fetch and initialize a level
DemoKeyCode = 0; // delete last demo key!
}
-void subFetchAndInitLevel()
+void subFetchAndInitLevel(void)
{
int InfoCountInLevel;
#include "global.h"
-extern int subConvertToEasySymbols();
+extern int subConvertToEasySymbols(void);
-extern void InitMurphyPos();
+extern void InitMurphyPos(void);
extern void InitMurphyPosB(int);
extern void ResetInfotronsNeeded(int);
-extern void subFetchAndInitLevel();
-extern void subFetchAndInitLevelA();
-extern void subFetchAndInitLevelB();
-extern void subInitGameConditions();
+extern void subFetchAndInitLevel(void);
+extern void subFetchAndInitLevelA(void);
+extern void subFetchAndInitLevelB(void);
+extern void subInitGameConditions(void);
#endif /* INITGAMECONDITIONS_H */
static void DrawFrame(int Delta);
-static void ReStretch();
+static void ReStretch(void);
void DrawField(int X, int Y);
void DrawFieldAnimated(int X, int Y);
void DrawFieldNoAnimated(int X, int Y);
-void DrawFrameIfNeeded()
+void DrawFrameIfNeeded(void)
{
DrawFrame(0);
DrawFrame(1);
}
-void DisplayLevel()
+void DisplayLevel(void)
{
int X, Y;
}
}
-void Form_Load()
+void Form_Load(void)
{
InitGlobals();
}
}
-static void RestoreFrame()
+static void RestoreFrame(void)
{
int i, LX, tY, RX, BY;
}
}
-void SetDisplayRegion()
+void SetDisplayRegion(void)
{
if (! menBorder)
{
}
}
-void menPlay_Click()
+void menPlay_Click(void)
{
bPlaying = True;
subMainGameLoop_Init();
}
-static void ReStretch()
+static void ReStretch(void)
{
if (LevelLoaded)
{
ScrollTo(ScreenScrollXPos, ScreenScrollYPos);
}
-void SetScrollEdges()
+void SetScrollEdges(void)
{
int border1_offset = (menBorder ? 1 : 2);
int border2_offset = (menBorder ? 0 : TILESIZE / 2);
#include "global.h"
-extern void DrawFrameIfNeeded();
+extern void DrawFrameIfNeeded(void);
-extern void DisplayLevel();
+extern void DisplayLevel(void);
extern void DrawField(int X, int Y);
extern void DrawFieldAnimated(int X, int Y);
extern void DrawFieldNoAnimated(int X, int Y);
extern void DrawSprite(int X, int Y, int SpritePos);
extern void DrawImage(int X, int Y, int graphic);
-extern void SetDisplayRegion();
-extern void SetScrollEdges();
+extern void SetDisplayRegion(void);
+extern void SetScrollEdges(void);
-extern void menPlay_Click();
+extern void menPlay_Click(void);
-extern void Form_Load();
+extern void Form_Load(void);
#endif /* MAINFORM_H */
// Play a game/demo
// ==========================================================================
-void subMainGameLoop_Init()
+void subMainGameLoop_Init(void)
{
// This was a bug in the original Supaplex: sometimes red disks could not
// be released. This happened if Murphy was killed DURING a red disk release
game_sp.GameOver = TRUE;
}
-void subCalculateScreenScrollPos()
+void subCalculateScreenScrollPos(void)
{
int jump_pos = TILEX / 2;
extern int ExitToMenuFlag;
extern int LeadOutCounter;
-extern void subMainGameLoop_Init();
+extern void subMainGameLoop_Init(void);
extern void subMainGameLoop_Main(byte, boolean);
-extern void subCalculateScreenScrollPos();
+extern void subCalculateScreenScrollPos(void);
#endif /* MAINGAMELOOP_H */
extern struct GraphicInfo_SP graphic_info_sp_player[MAX_PLAYERS][SPR_MAX][8];
extern struct EngineSnapshotInfo_SP engine_snapshot_sp;
-extern void sp_open_all();
-extern void sp_close_all();
+extern void sp_open_all(void);
+extern void sp_close_all(void);
-extern void InitPrecedingPlayfieldMemory();
-extern void InitGfxBuffers_SP();
+extern void InitPrecedingPlayfieldMemory(void);
+extern void InitGfxBuffers_SP(void);
-extern void InitGameEngine_SP();
+extern void InitGameEngine_SP(void);
extern void GameActions_SP(byte *, boolean);
extern unsigned int InitEngineRandom_SP(int);
-extern void setLevelInfoToDefaults_SP();
-extern void copyInternalEngineVars_SP();
+extern void setLevelInfoToDefaults_SP(void);
+extern void copyInternalEngineVars_SP(void);
extern boolean LoadNativeLevel_SP(char *, int, boolean);
extern void SaveNativeLevel_SP(char *);
-extern int getFieldbufferOffsetX_SP();
-extern int getFieldbufferOffsetY_SP();
+extern int getFieldbufferOffsetX_SP(void);
+extern int getFieldbufferOffsetY_SP(void);
extern void BlitScreenToBitmap_SP(Bitmap *);
extern void RedrawPlayfield_SP(boolean);
-extern void LoadEngineSnapshotValues_SP();
+extern void LoadEngineSnapshotValues_SP(void);
extern void SaveEngineSnapshotValues_SP(ListNode **);
extern int map_key_RND_to_SP(int);
extern int map_key_SP_to_RND(int);
-extern int getRedDiskReleaseFlag_SP();
+extern int getRedDiskReleaseFlag_SP(void);
#endif /* GAME_SP_EXPORT_H */
/* functions for loading Supaplex level */
/* ------------------------------------------------------------------------- */
-void setTapeInfoToDefaults_SP()
+void setTapeInfoToDefaults_SP(void)
{
native_sp_level.demo.is_available = FALSE;
native_sp_level.demo.length = 0;
}
-void setLevelInfoToDefaults_SP()
+void setLevelInfoToDefaults_SP(void)
{
LevelInfoType *header = &native_sp_level.header;
char *empty_title = "-------- EMPTY --------";
setTapeInfoToDefaults_SP();
}
-void copyInternalEngineVars_SP()
+void copyInternalEngineVars_SP(void)
{
int count;
int i, x, y;
struct EngineSnapshotInfo_SP engine_snapshot_sp;
-void sp_open_all()
+void sp_open_all(void)
{
Form_Load();
}
-void sp_close_all()
+void sp_close_all(void)
{
}
-void InitPrecedingPlayfieldMemory()
+void InitPrecedingPlayfieldMemory(void)
{
int preceding_buffer_size = 0;
int i;
game_sp.preceding_buffer_size = preceding_buffer_size;
}
-void InitGfxBuffers_SP()
+void InitGfxBuffers_SP(void)
{
ReCreateBitmap(&bitmap_db_field_sp, FXSIZE, FYSIZE);
}
SaveEngineSnapshotValues_SP_Murphy(buffers);
}
-void LoadEngineSnapshotValues_SP()
+void LoadEngineSnapshotValues_SP(void)
{
int i;
int GfxFrame[SP_MAX_PLAYFIELD_WIDTH][SP_MAX_PLAYFIELD_HEIGHT];
-void InitGameEngine_SP()
+void InitGameEngine_SP(void)
{
int x, y;
UpdatePlayfield(force_redraw);
}
-void UpdateGameDoorValues_SP()
+void UpdateGameDoorValues_SP(void)
{
game_sp.time_played = TimerVar / FRAMES_PER_SECOND;
game_sp.infotrons_still_needed = InfotronsNeeded;
GfxFrame[x][y]++;
}
-int getRedDiskReleaseFlag_SP()
+int getRedDiskReleaseFlag_SP(void)
{
/* 0: when Murphy is moving (including the destination tile!) */
/* 1: when Murphy is not moving for at least one game frame */
/* helper functions for constructs not supported by C */
-int MyGetTickCount()
+int MyGetTickCount(void)
{
return random_linux_libc(RANDOM_SIMPLE);
}
/* helper functions for constructs not supported by C */
-extern int MyGetTickCount();
+extern int MyGetTickCount(void);
#endif /* VB_LIB_H */
static int get_graphic_parameter_value(char *, char *, int);
-void DrawInitAnim()
+void DrawInitAnim(void)
{
struct GraphicInfo *graphic_info_last = graphic_info;
int graphic = 0;
FrameCounter++;
}
-void FreeGadgets()
+void FreeGadgets(void)
{
FreeLevelEditorGadgets();
FreeGameButtons();
FreeScreenGadgets();
}
-void InitGadgets()
+void InitGadgets(void)
{
static boolean gadgets_initialized = FALSE;
CreateImageWithSmallImages(graphic, g->scale_up_factor, g->tile_size);
}
-void InitElementSmallImages()
+void InitElementSmallImages(void)
{
print_timestamp_init("InitElementSmallImages");
ScaleImage(graphic, g->scale_up_factor);
}
-void InitScaledImages()
+void InitScaledImages(void)
{
struct PropertyMapping *property_mapping = getImageListPropertyMapping();
int num_property_mappings = getImageListPropertyMappingSize();
InitScaledImagesScaledUp(property_mapping[i].artwork_index);
}
-void InitBitmapPointers()
+void InitBitmapPointers(void)
{
int num_images = getImageListSize();
int i;
graphic_info[i].bitmap = graphic_info[i].bitmaps[IMG_BITMAP_STANDARD];
}
-void InitImageTextures()
+void InitImageTextures(void)
{
int i, j, k;
return FONT_INITIAL_1;
}
-void InitFontGraphicInfo()
+void InitFontGraphicInfo(void)
{
static struct FontBitmapInfo *font_bitmap_info = NULL;
struct PropertyMapping *property_mapping = getImageListPropertyMapping();
getFontBitmapID, getFontFromToken);
}
-void InitGlobalAnimGraphicInfo()
+void InitGlobalAnimGraphicInfo(void)
{
struct PropertyMapping *property_mapping = getImageListPropertyMapping();
int num_property_mappings = getImageListPropertyMappingSize();
#endif
}
-void InitGlobalAnimSoundInfo()
+void InitGlobalAnimSoundInfo(void)
{
struct PropertyMapping *property_mapping = getSoundListPropertyMapping();
int num_property_mappings = getSoundListPropertyMappingSize();
#endif
}
-void InitGlobalAnimMusicInfo()
+void InitGlobalAnimMusicInfo(void)
{
struct PropertyMapping *property_mapping = getMusicListPropertyMapping();
int num_property_mappings = getMusicListPropertyMappingSize();
#endif
}
-void InitElementGraphicInfo()
+void InitElementGraphicInfo(void)
{
struct PropertyMapping *property_mapping = getImageListPropertyMapping();
int num_property_mappings = getImageListPropertyMappingSize();
UPDATE_BUSY_STATE();
}
-void InitElementSpecialGraphicInfo()
+void InitElementSpecialGraphicInfo(void)
{
struct PropertyMapping *property_mapping = getImageListPropertyMapping();
int num_property_mappings = getImageListPropertyMappingSize();
}
}
-static void InitGraphicInfo()
+static void InitGraphicInfo(void)
{
int fallback_graphic = IMG_CHAR_EXCLAM;
int num_images = getImageListSize();
}
}
-static void InitGraphicCompatibilityInfo()
+static void InitGraphicCompatibilityInfo(void)
{
struct FileInfo *fi_global_door =
getImageListEntryFromImageID(IMG_GLOBAL_DOOR);
InitGraphicCompatibilityInfo_Doors();
}
-static void InitElementSoundInfo()
+static void InitElementSoundInfo(void)
{
struct PropertyMapping *property_mapping = getSoundListPropertyMapping();
int num_property_mappings = getSoundListPropertyMappingSize();
element_info[copy_properties[i][0]].sound[act];
}
-static void InitGameModeSoundInfo()
+static void InitGameModeSoundInfo(void)
{
int i;
sound_info[sound].priority = parameter[SND_ARG_PRIORITY];
}
-static void InitSoundInfo()
+static void InitSoundInfo(void)
{
int *sound_effect_properties;
int num_sounds = getSoundListSize();
free(sound_effect_properties);
}
-static void InitGameModeMusicInfo()
+static void InitGameModeMusicInfo(void)
{
struct PropertyMapping *property_mapping = getMusicListPropertyMapping();
int num_property_mappings = getMusicListPropertyMappingSize();
music_info[music].loop = parameter[MUS_ARG_MODE_LOOP];
}
-static void InitMusicInfo()
+static void InitMusicInfo(void)
{
int num_music = getMusicListSize();
int i, j;
}
}
-static void ReinitializeGraphics()
+static void ReinitializeGraphics(void)
{
print_timestamp_init("ReinitializeGraphics");
print_timestamp_done("ReinitializeGraphics");
}
-static void ReinitializeSounds()
+static void ReinitializeSounds(void)
{
InitSoundInfo(); /* sound properties mapping */
InitElementSoundInfo(); /* element game sound mapping */
InitPlayLevelSound(); /* internal game sound settings */
}
-static void ReinitializeMusic()
+static void ReinitializeMusic(void)
{
InitMusicInfo(); /* music properties mapping */
InitGameModeMusicInfo(); /* game mode music mapping */
ResolveGroupElementExt(group_element, 0);
}
-void InitElementPropertiesStatic()
+void InitElementPropertiesStatic(void)
{
static boolean clipboard_elements_initialized = FALSE;
InitElementGraphicInfo();
}
-void InitElementPropertiesGfxElement()
+void InitElementPropertiesGfxElement(void)
{
int i;
}
}
-static void InitGlobal()
+static void InitGlobal(void)
{
int graphic;
int i;
options.network = setup.network_mode = FALSE;
}
-static void InitSetup()
+static void InitSetup(void)
{
LoadSetup(); /* global setup info */
LoadSetup_AutoSetup(); /* global auto setup info */
global.show_frames_per_second = TRUE;
}
-static void InitGameInfo()
+static void InitGameInfo(void)
{
game.restart_level = FALSE;
game.restart_game_message = NULL;
}
-static void InitPlayerInfo()
+static void InitPlayerInfo(void)
{
int i;
local_player->connected_locally = TRUE;
}
-static void InitArtworkInfo()
+static void InitArtworkInfo(void)
{
LoadArtworkInfo();
}
return id_suffix;
}
-static void InitArtworkConfig()
+static void InitArtworkConfig(void)
{
static char *image_id_prefix[MAX_NUM_ELEMENTS +
NUM_FONTS +
level_id_suffix, ignore_music_tokens);
}
-static void InitMixer()
+static void InitMixer(void)
{
OpenAudio();
StartMixer();
}
-static void InitVideoOverlay()
+static void InitVideoOverlay(void)
{
// if virtual buttons are not loaded from setup file, repeat initializing
// virtual buttons grid with default values now that video is initialized
InitOverlayInfo();
}
-void InitGfxBuffers()
+void InitGfxBuffers(void)
{
static int win_xsize_last = -1;
static int win_ysize_last = -1;
InitGfxBuffers_SP();
}
-void InitGfx()
+void InitGfx(void)
{
struct GraphicInfo *graphic_info_last = graphic_info;
char *filename_font_initial = NULL;
init_last = init;
}
-void InitGfxBackground()
+void InitGfxBackground(void)
{
fieldbuffer = bitmap_db_field;
SetDrawtoField(DRAW_TO_BACKBUFFER);
redraw_mask = REDRAW_ALL;
}
-static void InitLevelInfo()
+static void InitLevelInfo(void)
{
LoadLevelInfo(); /* global level info */
LoadLevelSetup_LastSeries(); /* last played series info */
SetLevelSetInfo(leveldir_current->identifier, level_nr);
}
-static void InitLevelArtworkInfo()
+static void InitLevelArtworkInfo(void)
{
LoadLevelArtworkInfo();
}
-static void InitImages()
+static void InitImages(void)
{
print_timestamp_init("InitImages");
print_timestamp_done("InitMusic");
}
-static void InitArtworkDone()
+static void InitArtworkDone(void)
{
if (program.headless)
return;
InitGlobalAnimations();
}
-void InitNetworkSettings()
+void InitNetworkSettings(void)
{
InitNetworkInfo(options.network || setup.network_mode,
FALSE,
options.server_port);
}
-void InitNetworkServer()
+void InitNetworkServer(void)
{
if (!network.enabled || network.connected)
return;
return redefined_ce_found;
}
-static void InitOverrideArtwork()
+static void InitOverrideArtwork(void)
{
boolean redefined_ce_found = FALSE;
LimitScreenUpdates(FALSE);
}
-void KeyboardAutoRepeatOffUnlessAutoplay()
+void KeyboardAutoRepeatOffUnlessAutoplay(void)
{
if (global.autoplay_leveldir == NULL)
KeyboardAutoRepeatOff();
/* OpenAll() */
/* ========================================================================= */
-void OpenAll()
+void OpenAll(void)
{
print_timestamp_init("OpenAll");
void ResolveGroupElement(int);
void InitElementPropertiesStatic(void);
void InitElementPropertiesEngine(int);
-void InitElementPropertiesGfxElement();
+void InitElementPropertiesGfxElement(void);
void ReloadCustomArtwork(int);
-void RedrawGlobalBorder();
+void RedrawGlobalBorder(void);
-void KeyboardAutoRepeatOffUnlessAutoplay();
+void KeyboardAutoRepeatOffUnlessAutoplay(void);
-void InitGfxBuffers();
-void InitGadgets();
-void InitImageTextures();
+void InitGfxBuffers(void);
+void InitGadgets(void);
+void InitImageTextures(void);
-void InitNetworkServer();
+void InitNetworkServer(void);
void DisplayExitMessage(char *, va_list);
return gi;
}
-static int getNewGadgetID()
+static int getNewGadgetID(void)
{
int id = next_free_gadget_id++;
}
}
-void UnmapAllGadgets()
+void UnmapAllGadgets(void)
{
MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_UNMAP);
}
-void RemapAllGadgets()
+void RemapAllGadgets(void)
{
MultiMapGadgets(MULTIMAP_ALL | MULTIMAP_REMAP);
}
-boolean anyTextInputGadgetActive()
+boolean anyTextInputGadgetActive(void)
{
return (last_gi && (last_gi->type & GD_TYPE_TEXT_INPUT) && last_gi->mapped);
}
-boolean anyTextAreaGadgetActive()
+boolean anyTextAreaGadgetActive(void)
{
return (last_gi && (last_gi->type & GD_TYPE_TEXT_AREA) && last_gi->mapped);
}
-boolean anySelectboxGadgetActive()
+boolean anySelectboxGadgetActive(void)
{
return (last_gi && (last_gi->type & GD_TYPE_SELECTBOX) && last_gi->mapped);
}
-boolean anyScrollbarGadgetActive()
+boolean anyScrollbarGadgetActive(void)
{
return (last_gi && (last_gi->type & GD_TYPE_SCROLLBAR) && last_gi->mapped);
}
-boolean anyTextGadgetActive()
+boolean anyTextGadgetActive(void)
{
return (anyTextInputGadgetActive() ||
anyTextAreaGadgetActive() ||
return TRUE;
}
-void DumpGadgetIdentifiers()
+void DumpGadgetIdentifiers(void)
{
struct GadgetInfo *gi;
void MapGadget(struct GadgetInfo *);
void UnmapGadget(struct GadgetInfo *);
-void UnmapAllGadgets();
-void RemapAllGadgets();
-
-boolean anyTextInputGadgetActive();
-boolean anyTextAreaGadgetActive();
-boolean anySelectboxGadgetActive();
-boolean anyScrollbarGadgetActive();
-boolean anyTextGadgetActive();
+void UnmapAllGadgets(void);
+void RemapAllGadgets(void);
+
+boolean anyTextInputGadgetActive(void);
+boolean anyTextAreaGadgetActive(void);
+boolean anySelectboxGadgetActive(void);
+boolean anyScrollbarGadgetActive(void);
+boolean anyTextGadgetActive(void);
void ClickOnGadget(struct GadgetInfo *, int);
free(image);
}
-int getImageListSize()
+int getImageListSize(void)
{
return (image_info->num_file_list_entries +
image_info->num_dynamic_file_list_entries);
return -1;
}
-char *getImageConfigFilename()
+char *getImageConfigFilename(void)
{
return getCustomArtworkConfigFilename(image_info->type);
}
-int getImageListPropertyMappingSize()
+int getImageListPropertyMappingSize(void)
{
return image_info->num_property_mapping_entries;
}
-struct PropertyMapping *getImageListPropertyMapping()
+struct PropertyMapping *getImageListPropertyMapping(void)
{
return image_info->property_mapping;
}
image_info->free_artwork = FreeImage;
}
-void ReloadCustomImages()
+void ReloadCustomImages(void)
{
print_timestamp_init("ReloadCustomImages");
img_info->contains_textures = FALSE;
}
-void FreeAllImageTextures()
+void FreeAllImageTextures(void)
{
int num_images = getImageListSize();
int i;
img_info->scaled_up = TRUE;
}
-void FreeAllImages()
+void FreeAllImages(void)
{
FreeCustomArtworkLists(image_info);
}
0)
-int getImageListSize();
+int getImageListSize(void);
struct FileInfo *getImageListEntryFromImageID(int);
Bitmap **getBitmapsFromImageID(int);
int getOriginalImageWidthFromImageID(int);
char *getTokenFromImageID(int);
char *getFilenameFromImageID(int);
int getImageIDFromToken(char *);
-char *getImageConfigFilename();
-int getImageListPropertyMappingSize();
-struct PropertyMapping *getImageListPropertyMapping();
+char *getImageConfigFilename(void);
+int getImageListPropertyMappingSize(void);
+struct PropertyMapping *getImageListPropertyMapping(void);
void InitImageList(struct ConfigInfo *, int, struct ConfigTypeInfo *,
char **, char **, char **, char **, char **);
-void ReloadCustomImages();
+void ReloadCustomImages(void);
void CreateImageWithSmallImages(int, int, int);
void CreateImageTextures(int);
-void FreeAllImageTextures();
+void FreeAllImageTextures(void);
void ScaleImage(int, int);
-void FreeAllImages();
+void FreeAllImages(void);
#endif /* IMAGE_H */
return percent;
}
-void CheckJoystickData()
+void CheckJoystickData(void)
{
int i;
int distance = 100;
return JoystickButtonExt(player_nr, FALSE);
}
-int AnyJoystick()
+int AnyJoystick(void)
{
int i;
int result = 0;
return result;
}
-int AnyJoystickButton()
+int AnyJoystickButton(void)
{
int i;
int result = JOY_BUTTON_NOT_PRESSED;
return result;
}
-void DeactivateJoystick()
+void DeactivateJoystick(void)
{
/* Temporarily deactivate joystick. This is needed for calibration
screens, where the player has to select a joystick device that
joystick.status &= ~JOYSTICK_ACTIVE;
}
-void ActivateJoystick()
+void ActivateJoystick(void)
{
/* reactivate temporarily deactivated joystick */
int AnyJoystick(void);
int AnyJoystickButton(void);
-void DeactivateJoystick();
-void ActivateJoystick();
+void DeactivateJoystick(void);
+void ActivateJoystick(void);
#endif /* JOYSTICK_H */
/* maximal allowed length of a command line option */
#define MAX_OPTION_LEN 256
-static unsigned int getCurrentMS()
+static unsigned int getCurrentMS(void)
{
return SDL_GetTicks();
}
}
#endif
-char *getLoginName()
+char *getLoginName(void)
{
static char *login_name = NULL;
return login_name;
}
-char *getRealName()
+char *getRealName(void)
{
static char *real_name = NULL;
va_end(ap);
}
-char *GetError()
+char *GetError(void)
{
return internal_error;
}
/* functions for generic lists */
/* ------------------------------------------------------------------------- */
-ListNode *newListNode()
+ListNode *newListNode(void)
{
return checked_calloc(sizeof(ListNode));
}
return getPath2(getUserGameDataDir(), basename);
}
-void OpenLogFiles()
+void OpenLogFiles(void)
{
int i;
}
}
-void CloseLogFiles()
+void CloseLogFiles(void)
{
int i;
fclose(log_file);
}
-void NotifyUserAboutErrorFile()
+void NotifyUserAboutErrorFile(void)
{
#if defined(PLATFORM_WIN32)
char *title_text = getStringCat2(program.program_title, " Error Message");
#define DEBUG_TIME_IN_MICROSECONDS 0
#if DEBUG_TIME_IN_MICROSECONDS
-static double Counter_Microseconds()
+static double Counter_Microseconds(void)
{
static struct timeval base_time = { 0, 0 };
struct timeval current_time;
void FreeCustomArtworkLists(struct ArtworkListInfo *);
char *getLogFilename(char *);
-void OpenLogFiles();
-void CloseLogFiles();
+void OpenLogFiles(void);
+void CloseLogFiles(void);
void DumpLogFile(int);
-void NotifyUserAboutErrorFile();
+void NotifyUserAboutErrorFile(void);
#if DEBUG
void debug_print_timestamp(int, char *);
SDLSetWindowTitle();
}
-inline static void SDLInitVideoBuffer_DrawBuffer()
+inline static void SDLInitVideoBuffer_DrawBuffer(void)
{
/* SDL cannot directly draw to the visible video framebuffer like X11,
but always uses a backbuffer, which is then blitted to the visible
return success;
}
-void SDLSetWindowTitle()
+void SDLSetWindowTitle(void)
{
#if defined(TARGET_SDL2)
if (sdl_window == NULL)
}
}
-void SDLSetDisplaySize()
+void SDLSetDisplaySize(void)
{
SDL_Rect display_bounds;
SDL_RenderSetLogicalSize(sdl_renderer, width, height);
}
-void SDLSetScreenProperties()
+void SDLSetScreenProperties(void)
{
SDLSetScreenSizeAndOffsets(video.width, video.height);
SDLSetScreenSizeForRenderer(video.screen_width, video.screen_height);
#endif
}
-void SDLRedrawWindow()
+void SDLRedrawWindow(void)
{
UpdateScreen_WithoutFrameDelay(NULL);
}
static int sdl_js_button[MAX_PLAYERS][2];
static boolean sdl_is_controller[MAX_PLAYERS];
-void SDLClearJoystickState()
+void SDLClearJoystickState(void)
{
int i, j;
}
}
-void SDLInitJoysticks()
+void SDLInitJoysticks(void)
{
static boolean sdl_joystick_subsystem_initialized = FALSE;
boolean print_warning = !sdl_joystick_subsystem_initialized;
SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 255);
}
-static void DrawTouchInputOverlay()
+static void DrawTouchInputOverlay(void)
{
static SDL_Texture *texture = NULL;
static boolean initialized = FALSE;
#endif
void SDLSetScreenRenderingMode(char *);
-void SDLRedrawWindow();
+void SDLRedrawWindow(void);
void SDLSetWindowTitle(void);
void SDLLimitScreenUpdates(boolean);
void SDLInitJoysticks(void);
boolean SDLReadJoystick(int, int *, int *, boolean *, boolean *);
boolean SDLCheckJoystickOpened(int);
-void SDLClearJoystickState();
+void SDLClearJoystickState(void);
boolean SDLOpenJoystick(int);
void SDLCloseJoystick(int);
return levelsetup_dir;
}
-static char *getCacheDir()
+static char *getCacheDir(void)
{
static char *cache_dir = NULL;
return cache_dir;
}
-static char *getNetworkDir()
+static char *getNetworkDir(void)
{
static char *network_dir = NULL;
return network_level_dir;
}
-char *getCurrentLevelDir()
+char *getCurrentLevelDir(void)
{
return getLevelDirFromTreeInfo(leveldir_current);
}
-char *getNewUserLevelSubdir()
+char *getNewUserLevelSubdir(void)
{
static char *new_level_subdir = NULL;
char *subdir_prefix = getLoginName();
return tape_dir;
}
-static char *getSolutionTapeDir()
+static char *getSolutionTapeDir(void)
{
static char *tape_dir = NULL;
char *data_dir = getCurrentLevelDir();
getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : "");
}
-static char *getUserGraphicsDir()
+static char *getUserGraphicsDir(void)
{
static char *usergraphics_dir = NULL;
return usergraphics_dir;
}
-static char *getUserSoundsDir()
+static char *getUserSoundsDir(void)
{
static char *usersounds_dir = NULL;
return usersounds_dir;
}
-static char *getUserMusicDir()
+static char *getUserMusicDir(void)
{
static char *usermusic_dir = NULL;
return filename;
}
-char *getSetupFilename()
+char *getSetupFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getDefaultSetupFilename()
+char *getDefaultSetupFilename(void)
{
return program.config_filename;
}
-char *getEditorSetupFilename()
+char *getEditorSetupFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getHelpAnimFilename()
+char *getHelpAnimFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getHelpTextFilename()
+char *getHelpTextFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getLevelSetInfoFilename()
+char *getLevelSetInfoFilename(void)
{
static char *filename = NULL;
char *basenames[] =
createDirectory(getScoreDir(level_subdir), "level score", permissions);
}
-static void SaveUserLevelInfo();
+static void SaveUserLevelInfo(void);
void InitUserLevelDirectory(char *level_subdir)
{
createDirectory(getLevelSetupDir(level_subdir), "level setup", PERMS_PRIVATE);
}
-void InitCacheDirectory()
+void InitCacheDirectory(void)
{
createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
createDirectory(getCacheDir(), "cache data", PERMS_PRIVATE);
/* some functions to handle lists of level and artwork directories */
/* ------------------------------------------------------------------------- */
-TreeInfo *newTreeInfo()
+TreeInfo *newTreeInfo(void)
{
return checked_calloc(sizeof(TreeInfo));
}
#define FILE_PERMS_PUBLIC_ALL (MODE_R_ALL | MODE_W_ALL)
-char *getHomeDir()
+char *getHomeDir(void)
{
static char *dir = NULL;
return user_game_data_dir;
}
-char *getSetupDir()
+char *getSetupDir(void)
{
return getUserGameDataDir();
}
#endif
}
-static boolean posix_process_running_setgid()
+static boolean posix_process_running_setgid(void)
{
#if defined(PLATFORM_UNIX)
return (getgid() != getegid());
posix_umask(last_umask); /* restore previous umask */
}
-void InitUserDataDirectory()
+void InitUserDataDirectory(void)
{
createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
}
return (strEqual((char *)key1, (char *)key2));
}
-SetupFileHash *newSetupFileHash()
+SetupFileHash *newSetupFileHash(void)
{
SetupFileHash *new_hash =
create_hashtable(16, 0.75, get_hash_from_key, keys_are_equal);
/* functions for handling level and custom artwork info cache */
/* -------------------------------------------------------------------------- */
-static void LoadArtworkInfoCache()
+static void LoadArtworkInfoCache(void)
{
InitCacheDirectory();
artworkinfo_cache_new = newSetupFileHash();
}
-static void SaveArtworkInfoCache()
+static void SaveArtworkInfoCache(void)
{
char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
level_directory);
}
-boolean AdjustGraphicsForEMC()
+boolean AdjustGraphicsForEMC(void)
{
boolean settings_changed = FALSE;
return settings_changed;
}
-void LoadLevelInfo()
+void LoadLevelInfo(void)
{
InitUserLevelDirectory(getLoginName());
return artwork_new;
}
-void LoadArtworkInfo()
+void LoadArtworkInfo(void)
{
LoadArtworkInfoCache();
}
}
-void LoadLevelArtworkInfo()
+void LoadLevelArtworkInfo(void)
{
print_timestamp_init("LoadLevelArtworkInfo");
return getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
}
-boolean checkIfCustomArtworkExistsForCurrentLevelSet()
+boolean checkIfCustomArtworkExistsForCurrentLevelSet(void)
{
char *graphics_set =
getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
return TRUE;
}
-static void SaveUserLevelInfo()
+static void SaveUserLevelInfo(void)
{
CreateUserLevelSet(getLoginName(), getLoginName(), getRealName(), 100, FALSE);
}
return line;
}
-void LoadLevelSetup_LastSeries()
+void LoadLevelSetup_LastSeries(void)
{
/* ----------------------------------------------------------------------- */
/* ~/.<program>/levelsetup.conf */
free(filename);
}
-void SaveLevelSetup_LastSeries()
+void SaveLevelSetup_LastSeries(void)
{
SaveLevelSetup_LastSeries_Ext(FALSE);
}
-void SaveLevelSetup_LastSeries_Deactivate()
+void SaveLevelSetup_LastSeries_Deactivate(void)
{
SaveLevelSetup_LastSeries_Ext(TRUE);
}
-static void checkSeriesInfo()
+static void checkSeriesInfo(void)
{
static char *level_directory = NULL;
Directory *dir;
closeDirectory(dir);
}
-void LoadLevelSetup_SeriesInfo()
+void LoadLevelSetup_SeriesInfo(void)
{
char *filename;
SetupFileHash *level_setup_hash = NULL;
free(filename);
}
-void SaveLevelSetup_SeriesInfo()
+void SaveLevelSetup_SeriesInfo(void)
{
char *filename;
char *level_subdir = leveldir_current->subdir;
void InitNetworkLevelDirectory(char *);
void InitLevelSetupDirectory(char *);
-TreeInfo *newTreeInfo();
+TreeInfo *newTreeInfo(void);
TreeInfo *newTreeInfo_setDefaults(int);
void pushTreeInfo(TreeInfo **, TreeInfo *);
int numTreeInfo(TreeInfo *);
SetupFileList *addListEntry(SetupFileList *, char *, char *);
SetupFileList *loadSetupFileList(char *);
-SetupFileHash *newSetupFileHash();
+SetupFileHash *newSetupFileHash(void);
void freeSetupFileHash(SetupFileHash *);
char *getHashEntry(SetupFileHash *, char *);
void setHashEntry(SetupFileHash *, char *, char *);
unsigned int get_hash_from_key(void *);
-boolean AdjustGraphicsForEMC();
+boolean AdjustGraphicsForEMC(void);
void LoadLevelInfo(void);
void LoadArtworkInfo(void);
char *getArtworkIdentifierForUserLevelSet(int);
TreeInfo *getArtworkTreeInfoForUserLevelSet(int);
-boolean checkIfCustomArtworkExistsForCurrentLevelSet();
+boolean checkIfCustomArtworkExistsForCurrentLevelSet(void);
void AddUserLevelSetToLevelInfo(char *);
boolean UpdateUserLevelSet(char *, char *, char *, int);
boolean CreateUserLevelSet(char *, char *, char *, int, boolean);
void LoadLevelSetup_LastSeries(void);
void SaveLevelSetup_LastSeries(void);
-void SaveLevelSetup_LastSeries_Deactivate();
+void SaveLevelSetup_LastSeries_Deactivate(void);
void LoadLevelSetup_SeriesInfo(void);
void SaveLevelSetup_SeriesInfo(void);
FreeSnapshotBuffers(snapshot_buffers_ptr);
}
-void FreeSnapshotSingle()
+void FreeSnapshotSingle(void)
{
FreeSnapshotBuffers(snapshot_single);
}
}
-void FreeSnapshotList()
+void FreeSnapshotList(void)
{
#if DEBUG_SNAPSHOTS
printf("::: FreeSnapshotList()\n");
snapshot_current = NULL;
}
-void ReduceSnapshotList()
+void ReduceSnapshotList(void)
{
#if DEBUG_SNAPSHOTS
printf("::: (Reducing number of snapshots from %d ",
ReduceSnapshotList();
}
-boolean LoadSnapshotSingle()
+boolean LoadSnapshotSingle(void)
{
if (snapshot_single)
{
return FALSE;
}
-boolean CheckSnapshotList()
+boolean CheckSnapshotList(void)
{
return (snapshot_list ? TRUE : FALSE);
}
void SaveSnapshotSingle(ListNode *);
void SaveSnapshotToList(ListNode *);
-boolean LoadSnapshotSingle();
+boolean LoadSnapshotSingle(void);
boolean LoadSnapshotFromList_Older(int);
boolean LoadSnapshotFromList_Newer(int);
-boolean CheckSnapshotList();
-void FreeSnapshotSingle();
-void FreeSnapshotList();
+boolean CheckSnapshotList(void);
+void FreeSnapshotSingle(void);
+void FreeSnapshotList(void);
#endif /* SNAPSHOT_H */
static int mixer_active_channels = 0;
static boolean expire_loop_sounds = FALSE;
-static void ReloadCustomSounds();
-static void ReloadCustomMusic();
+static void ReloadCustomSounds(void);
+static void ReloadCustomMusic(void);
static void FreeSound(void *);
static void FreeMusic(void *);
-static void FreeAllMusic_NoConf();
+static void FreeAllMusic_NoConf(void);
static SoundInfo *getSoundInfoEntryFromSoundID(int);
static MusicInfo *getMusicInfoEntryFromMusicID(int);
/* mixer functions */
/* ------------------------------------------------------------------------- */
-void Mixer_InitChannels()
+void Mixer_InitChannels(void)
{
int i;
mixer_active_channels++;
}
-static void Mixer_PlayMusicChannel()
+static void Mixer_PlayMusicChannel(void)
{
Mixer_PlayChannel(audio.music_channel);
mixer_active_channels--;
}
-static void Mixer_StopMusicChannel()
+static void Mixer_StopMusicChannel(void)
{
Mixer_StopChannel(audio.music_channel);
Mix_FadeOutChannel(channel, SOUND_FADING_INTERVAL);
}
-static void Mixer_FadeMusicChannel()
+static void Mixer_FadeMusicChannel(void)
{
Mixer_FadeChannel(audio.music_channel);
draw_init_text = FALSE;
}
-int getSoundListSize()
+int getSoundListSize(void)
{
return (sound_info->num_file_list_entries +
sound_info->num_dynamic_file_list_entries);
}
-int getMusicListSize()
+int getMusicListSize(void)
{
return (music_info->num_file_list_entries +
music_info->num_dynamic_file_list_entries);
return getBaseNamePtr(mus_info->source_filename);
}
-char *getCurrentlyPlayingMusicFilename()
+char *getCurrentlyPlayingMusicFilename(void)
{
return currently_playing_music_filename;
}
-int getSoundListPropertyMappingSize()
+int getSoundListPropertyMappingSize(void)
{
return sound_info->num_property_mapping_entries;
}
-int getMusicListPropertyMappingSize()
+int getMusicListPropertyMappingSize(void)
{
return music_info->num_property_mapping_entries;
}
-struct PropertyMapping *getSoundListPropertyMapping()
+struct PropertyMapping *getSoundListPropertyMapping(void)
{
return sound_info->property_mapping;
}
-struct PropertyMapping *getMusicListPropertyMapping()
+struct PropertyMapping *getMusicListPropertyMapping(void)
{
return music_info->property_mapping;
}
StopSoundExt(nr, SND_CTRL_FADE_SOUND);
}
-void FadeSounds()
+void FadeSounds(void)
{
StopSoundExt(-1, SND_CTRL_FADE_ALL);
}
-void FadeSoundsAndMusic()
+void FadeSoundsAndMusic(void)
{
FadeSounds();
FadeMusic();
StopSoundExt(nr, SND_CTRL_STOP_SOUND);
}
-void StopSounds()
+void StopSounds(void)
{
StopMusic();
StopSoundExt(-1, SND_CTRL_STOP_ALL);
HandleSoundRequest(snd_ctrl);
}
-static void ReloadCustomSounds()
+static void ReloadCustomSounds(void)
{
LoadArtworkConfig(sound_info);
ReloadCustomArtworkList(sound_info);
}
-static void ReloadCustomMusic()
+static void ReloadCustomMusic(void)
{
LoadArtworkConfig(music_info);
ReloadCustomArtworkList(music_info);
free(music);
}
-static void FreeAllMusic_NoConf()
+static void FreeAllMusic_NoConf(void)
{
int i;
num_music_noconf = 0;
}
-void FreeAllSounds()
+void FreeAllSounds(void)
{
FreeCustomArtworkLists(sound_info);
}
-void FreeAllMusic()
+void FreeAllMusic(void)
{
FreeCustomArtworkLists(music_info);
FreeAllMusic_NoConf();
void StopSoundExt(int, int);
void ExpireSoundLoops(boolean);
-int getSoundListSize();
-int getMusicListSize();
+int getSoundListSize(void);
+int getMusicListSize(void);
struct FileInfo *getSoundListEntry(int);
struct FileInfo *getMusicListEntry(int);
char *getMusicInfoEntryFilename(int);
-char *getCurrentlyPlayingMusicFilename();
-int getSoundListPropertyMappingSize();
-int getMusicListPropertyMappingSize();
-struct PropertyMapping *getSoundListPropertyMapping();
-struct PropertyMapping *getMusicListPropertyMapping();
+char *getCurrentlyPlayingMusicFilename(void);
+int getSoundListPropertyMappingSize(void);
+int getMusicListPropertyMappingSize(void);
+struct PropertyMapping *getSoundListPropertyMapping(void);
+struct PropertyMapping *getMusicListPropertyMapping(void);
void InitSoundList(struct ConfigInfo *, int, struct ConfigTypeInfo *,
char **, char **, char **, char **, char **);
void InitMusicList(struct ConfigInfo *, int, struct ConfigTypeInfo *,
network.server_port = server_port;
}
-void InitScoresInfo()
+void InitScoresInfo(void)
{
char *global_scores_dir = getPath2(getCommonDataDir(), SCORES_DIRECTORY);
free(global_scores_dir);
}
-void SetWindowTitle()
+void SetWindowTitle(void)
{
program.window_title = program.window_title_function();
gfx.draw_tile_cursor_function = draw_tile_cursor_function;
}
-void InitGfxCustomArtworkInfo()
+void InitGfxCustomArtworkInfo(void)
{
gfx.override_level_graphics = FALSE;
gfx.override_level_sounds = FALSE;
gfx.draw_init_text = TRUE;
}
-void InitGfxOtherSettings()
+void InitGfxOtherSettings(void)
{
gfx.cursor_mode = CURSOR_DEFAULT;
}
-void InitTileCursorInfo()
+void InitTileCursorInfo(void)
{
tile_cursor.enabled = FALSE;
tile_cursor.active = FALSE;
tile_cursor.sy = 0;
}
-void InitOverlayInfo()
+void InitOverlayInfo(void)
{
int nr = GRID_ACTIVE_NR();
int x, y;
SetOverlayEnabled(TRUE);
}
-boolean GetOverlayActive()
+boolean GetOverlayActive(void)
{
return overlay.active;
}
gfx.draw_deactivation_mask = draw_deactivation_mask;
}
-int GetDrawDeactivationMask()
+int GetDrawDeactivationMask(void)
{
return gfx.draw_deactivation_mask;
}
return FALSE;
}
-boolean DrawingDeactivatedField()
+boolean DrawingDeactivatedField(void)
{
if (program.headless)
return TRUE;
video.frame_delay_value = frame_delay_value;
}
-unsigned int GetVideoFrameDelay()
+unsigned int GetVideoFrameDelay(void)
{
return video.frame_delay_value;
}
return current_modifiers;
}
-KeyMod GetKeyModState()
+KeyMod GetKeyModState(void)
{
return (KeyMod)SDL_GetModState();
}
-KeyMod GetKeyModStateFromEvents()
+KeyMod GetKeyModStateFromEvents(void)
{
/* always use key modifier state as tracked from key events (this is needed
if the modifier key event was injected into the event queue, but the key
#endif
}
-void StopTextInput()
+void StopTextInput(void)
{
#if defined(TARGET_SDL2)
#if defined(HAS_SCREEN_KEYBOARD)
/* joystick functions */
/* ========================================================================= */
-void InitJoysticks()
+void InitJoysticks(void)
{
int i;
return SDLCheckJoystickOpened(nr);
}
-void ClearJoystickState()
+void ClearJoystickState(void)
{
SDLClearJoystickState();
}
char *, int);
void InitNetworkInfo(boolean, boolean, boolean, char *, int);
-void InitScoresInfo();
-void SetWindowTitle();
+void InitScoresInfo(void);
+void SetWindowTitle(void);
void InitWindowTitleFunction(char *(*window_title_function)(void));
void InitExitMessageFunction(void (*exit_message_function)(char *, va_list));
void InitGfxDrawGlobalAnimFunction(void (*draw_global_anim_function)(int, int));
void InitGfxDrawGlobalBorderFunction(void (*draw_global_border_function)(int));
void InitGfxDrawTileCursorFunction(void (*draw_tile_cursor_function)(int));
-void InitGfxCustomArtworkInfo();
-void InitGfxOtherSettings();
-void InitTileCursorInfo();
-void InitOverlayInfo();
+void InitGfxCustomArtworkInfo(void);
+void InitGfxOtherSettings(void);
+void InitTileCursorInfo(void);
+void InitOverlayInfo(void);
void SetTileCursorEnabled(boolean);
void SetTileCursorActive(boolean);
void SetTileCursorTargetXY(int, int);
void SetOverlayEnabled(boolean);
void SetOverlayActive(boolean);
void SetOverlayShowGrid(boolean);
-boolean GetOverlayActive();
+boolean GetOverlayActive(void);
void SetDrawDeactivationMask(int);
int GetDrawDeactivationMask(void);
void SetDrawBackgroundMask(int);
boolean DrawingDeactivatedField(void);
boolean DrawingDeactivated(int, int, int, int);
boolean DrawingOnBackground(int, int);
-boolean DrawingAreaChanged();
+boolean DrawingAreaChanged(void);
void BlitBitmapOnBackground(Bitmap *, Bitmap *, int, int, int, int, int, int);
void BlitTexture(Bitmap *, int, int, int, int, int, int);
void BlitTextureMasked(Bitmap *, int, int, int, int, int, int);
void KeyboardAutoRepeatOff(void);
boolean SetVideoMode(boolean);
void SetVideoFrameDelay(unsigned int);
-unsigned int GetVideoFrameDelay();
+unsigned int GetVideoFrameDelay(void);
boolean ChangeVideoModeIfNeeded(boolean);
Bitmap *LoadImage(char *);
void CheckQuitEvent(void);
Key GetEventKey(KeyEvent *, boolean);
KeyMod HandleKeyModState(Key, int);
-KeyMod GetKeyModState();
-KeyMod GetKeyModStateFromEvents();
+KeyMod GetKeyModState(void);
+KeyMod GetKeyModStateFromEvents(void);
void StartTextInput(int, int, int, int);
-void StopTextInput();
+void StopTextInput(void);
boolean CheckCloseWindowEvent(ClientMessageEvent *);
-void InitJoysticks();
+void InitJoysticks(void);
boolean ReadJoystick(int, int *, int *, boolean *, boolean *);
boolean CheckJoystickOpened(int);
-void ClearJoystickState();
+void ClearJoystickState(void);
#endif /* SYSTEM_H */
/* main() */
/* ========================================================================= */
-static void print_usage()
+static void print_usage(void)
{
Print("\n"
"Usage: %s [OPTION]... [HOSTNAME [PORT]]\n"
program.command_basename);
}
-static void print_version()
+static void print_version(void)
{
Print("%s", getProgramInitString());
return strlen(s) + 1;
}
-struct NetworkBuffer *newNetworkBuffer()
+struct NetworkBuffer *newNetworkBuffer(void)
{
struct NetworkBuffer *new = checked_calloc(sizeof(struct NetworkBuffer));
char *getNetworkString(byte *);
int putNetworkString(byte *, char *);
-struct NetworkBuffer *newNetworkBuffer();
+struct NetworkBuffer *newNetworkBuffer(void);
void initNetworkBufferForReceiving(struct NetworkBuffer *);
void initNetworkBufferForReading(struct NetworkBuffer *);
void initNetworkBufferForWriting(struct NetworkBuffer *, int, int);
Error(ERR_NETWORK_CLIENT, "you set your player name to \"%s\"", player_name);
}
-void SendToServer_ProtocolVersion()
+void SendToServer_ProtocolVersion(void)
{
initNetworkBufferForWriting(write_buffer, OP_PROTOCOL_VERSION, 0);
SendNetworkBufferToServer(write_buffer);
}
-void SendToServer_LevelFile()
+void SendToServer_LevelFile(void)
{
initNetworkBufferForWriting(write_buffer, OP_LEVEL_FILE, 0);
#endif
}
-void SendToServer_StartPlaying()
+void SendToServer_StartPlaying(void)
{
unsigned int new_random_seed = InitRND(level.random_seed);
SendNetworkBufferToServer(write_buffer);
}
-void SendToServer_PausePlaying()
+void SendToServer_PausePlaying(void)
{
initNetworkBufferForWriting(write_buffer, OP_PAUSE_PLAYING, 0);
SendNetworkBufferToServer(write_buffer);
}
-void SendToServer_ContinuePlaying()
+void SendToServer_ContinuePlaying(void)
{
initNetworkBufferForWriting(write_buffer, OP_CONTINUE_PLAYING, 0);
SendNetworkBufferToServer(write_buffer);
}
-static void Handle_OP_BAD_PROTOCOL_VERSION()
+static void Handle_OP_BAD_PROTOCOL_VERSION(void)
{
int protocol_version_major = getNetworkBuffer8BitInteger(read_buffer);
int protocol_version_minor = getNetworkBuffer8BitInteger(read_buffer);
stop_network_client = TRUE;
}
-static void Handle_OP_YOUR_NUMBER()
+static void Handle_OP_YOUR_NUMBER(void)
{
int old_client_nr = getNetworkBuffer8BitInteger(read_buffer);
int new_client_nr = getNetworkBuffer8BitInteger(read_buffer);
stored_player[new_index_nr].connected_network = TRUE;
}
-static void Handle_OP_NUMBER_WANTED()
+static void Handle_OP_NUMBER_WANTED(void)
{
int old_client_nr = getNetworkBuffer8BitInteger(read_buffer);
int client_nr_wanted = getNetworkBuffer8BitInteger(read_buffer);
DrawNetworkPlayers();
}
-static void Handle_OP_PLAYER_NAME()
+static void Handle_OP_PLAYER_NAME(void)
{
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
char *player_name = getNetworkBufferString(read_buffer);
player_nr, player->name);
}
-static void Handle_OP_PLAYER_CONNECTED()
+static void Handle_OP_PLAYER_CONNECTED(void)
{
struct NetworkClientPlayerInfo *player, *last_player = NULL;
int new_client_nr = getNetworkBuffer8BitInteger(read_buffer);
stored_player[new_index_nr].connected_network = TRUE;
}
-static void Handle_OP_PLAYER_DISCONNECTED()
+static void Handle_OP_PLAYER_DISCONNECTED(void)
{
struct NetworkClientPlayerInfo *player, *player_disconnected;
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
}
}
-static void Handle_OP_START_PLAYING()
+static void Handle_OP_START_PLAYING(void)
{
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
char *new_leveldir_identifier = getNetworkBufferString(read_buffer);
StartGameActions(FALSE, setup.autorecord, new_random_seed);
}
-static void Handle_OP_PAUSE_PLAYING()
+static void Handle_OP_PAUSE_PLAYING(void)
{
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
}
}
-static void Handle_OP_CONTINUE_PLAYING()
+static void Handle_OP_CONTINUE_PLAYING(void)
{
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
}
}
-static void Handle_OP_STOP_PLAYING()
+static void Handle_OP_STOP_PLAYING(void)
{
int client_nr = getNetworkBuffer8BitInteger(read_buffer);
int cause_for_stopping = getNetworkBuffer8BitInteger(read_buffer);
}
}
-static void Handle_OP_MOVE_PLAYER()
+static void Handle_OP_MOVE_PLAYER(void)
{
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
int server_frame_counter = getNetworkBuffer32BitInteger(read_buffer);
network_player_action_received = TRUE;
}
-static void Handle_OP_BROADCAST_MESSAGE()
+static void Handle_OP_BROADCAST_MESSAGE(void)
{
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
Error(ERR_NETWORK_CLIENT, "client %d sends message", player_nr);
}
-static void Handle_OP_LEVEL_FILE()
+static void Handle_OP_LEVEL_FILE(void)
{
int player_nr = getNetworkBuffer8BitInteger(read_buffer);
char *leveldir_identifier;
#endif
}
-static void HandleNetworkingMessage()
+static void HandleNetworkingMessage(void)
{
stop_network_game = FALSE;
SendToServer_StopPlaying(NETWORK_STOP_BY_ERROR);
}
-static char *HandleNetworkingPackets()
+static char *HandleNetworkingPackets(void)
{
while (1)
{
checked_free(player);
}
-static void HandleNetworkingDisconnect()
+static void HandleNetworkingDisconnect(void)
{
int i;
first_player.next = NULL;
}
-void HandleNetworking()
+void HandleNetworking(void)
{
char *error_message = HandleNetworkingPackets();
}
}
-void DisconnectFromNetworkServer()
+void DisconnectFromNetworkServer(void)
{
DrawNetworkText_Title("Terminating Network");
DrawNetworkText("Disconnecting from network server ...");
static void HandleSetupScreen_Input(int, int, int, int, int);
static void CustomizeKeyboard(int);
static void ConfigureJoystick(int);
-static void ConfigureVirtualButtons();
+static void ConfigureVirtualButtons(void);
static void execSetupGame(void);
static void execSetupGraphics(void);
static void execSetupSound(void);
return (pos != NULL && pos->x != -1 && pos->y != -1);
}
-static void InitializeMainControls()
+static void InitializeMainControls(void)
{
boolean local_team_mode = (!network.enabled && setup.team_mode);
int i;
first_entry);
}
-static void clearMenuListArea()
+static void clearMenuListArea(void)
{
int scrollbar_xpos = mSX + SC_SCROLLBAR_XPOS + menu.scrollbar_xoffset;
drawCursorExt(0, ypos, active, -1);
}
-void DrawHeadline()
+void DrawHeadline(void)
{
DrawTextSCentered(MENU_TITLE1_YPOS, FONT_TITLE_1, main_text_title_1);
DrawTextSCentered(MENU_TITLE2_YPOS, FONT_TITLE_2, main_text_title_2);
ResetFontStatus();
}
-void DrawTitleScreen()
+void DrawTitleScreen(void)
{
KeyboardAutoRepeatOff();
return (show_titlescreen && num_title_screens > 0);
}
-void DrawMainMenu()
+void DrawMainMenu(void)
{
static LevelDirTree *leveldir_last_valid = NULL;
boolean levelset_has_changed = FALSE;
OpenDoor(DOOR_CLOSE_1 | DOOR_OPEN_2);
}
-static void gotoTopLevelDir()
+static void gotoTopLevelDir(void)
{
/* move upwards until inside (but not above) top level directory */
while (leveldir_current->node_parent &&
static int num_info_info; /* number of info entries shown on screen */
static int max_info_info; /* total number of info entries in list */
-static void execInfoTitleScreen()
+static void execInfoTitleScreen(void)
{
info_mode = INFO_MODE_TITLE;
DrawInfoScreen();
}
-static void execInfoElements()
+static void execInfoElements(void)
{
info_mode = INFO_MODE_ELEMENTS;
DrawInfoScreen();
}
-static void execInfoMusic()
+static void execInfoMusic(void)
{
info_mode = INFO_MODE_MUSIC;
DrawInfoScreen();
}
-static void execInfoCredits()
+static void execInfoCredits(void)
{
info_mode = INFO_MODE_CREDITS;
DrawInfoScreen();
}
-static void execInfoProgram()
+static void execInfoProgram(void)
{
info_mode = INFO_MODE_PROGRAM;
DrawInfoScreen();
}
-static void execInfoVersion()
+static void execInfoVersion(void)
{
info_mode = INFO_MODE_VERSION;
DrawInfoScreen();
}
-static void execInfoLevelSet()
+static void execInfoLevelSet(void)
{
info_mode = INFO_MODE_LEVELSET;
DrawInfoScreen();
}
-static void execExitInfo()
+static void execExitInfo(void)
{
SetGameStatus(GAME_MODE_MAIN);
}
}
-static void DrawInfoScreen_Main()
+static void DrawInfoScreen_Main(void)
{
int fade_mask = REDRAW_FIELD;
int i;
TRUE, FALSE, FALSE);
}
-void DrawInfoScreen_TitleScreen()
+void DrawInfoScreen_TitleScreen(void)
{
SetGameStatus(GAME_MODE_TITLE);
HandleTitleScreen(0, 0, 0, 0, button);
}
-void DrawInfoScreen_Elements()
+void DrawInfoScreen_Elements(void)
{
SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_ELEMENTS);
}
}
-void DrawInfoScreen_Music()
+void DrawInfoScreen_Music(void)
{
SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_MUSIC);
"Press any key or button for next page");
}
-void DrawInfoScreen_Credits()
+void DrawInfoScreen_Credits(void)
{
SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_CREDITS);
}
}
-void DrawInfoScreen_Program()
+void DrawInfoScreen_Program(void)
{
int font_title = MENU_INFO_FONT_TITLE;
int font_head = MENU_INFO_FONT_HEAD;
}
}
-void DrawInfoScreen_Version()
+void DrawInfoScreen_Version(void)
{
int font_title = MENU_INFO_FONT_TITLE;
int font_head = MENU_INFO_FONT_HEAD;
}
}
-void DrawInfoScreen_LevelSet()
+void DrawInfoScreen_LevelSet(void)
{
struct TitleMessageInfo *tmi = &readme;
char *filename = getLevelSetInfoFilename();
}
}
-static void DrawInfoScreen()
+static void DrawInfoScreen(void)
{
if (info_mode == INFO_MODE_TITLE)
DrawInfoScreen_TitleScreen();
}
}
-void DrawChooseLevelSet()
+void DrawChooseLevelSet(void)
{
FadeMenuSoundsAndMusic();
HandleChooseTree(mx, my, dx, dy, button, &leveldir_current);
}
-void DrawChooseLevelNr()
+void DrawChooseLevelNr(void)
{
int i;
static char *transparency_text;
static char *grid_size_text[2][2];
-static void execSetupMain()
+static void execSetupMain(void)
{
setup_mode = SETUP_MODE_MAIN;
DrawSetupScreen();
}
-static void execSetupGame_setGameSpeeds()
+static void execSetupGame_setGameSpeeds(void)
{
if (game_speeds == NULL)
{
game_speed_text = game_speed_current->name;
}
-static void execSetupGame_setScrollDelays()
+static void execSetupGame_setScrollDelays(void)
{
if (scroll_delays == NULL)
{
scroll_delay_text = scroll_delay_current->name;
}
-static void execSetupGame_setSnapshotModes()
+static void execSetupGame_setSnapshotModes(void)
{
if (snapshot_modes == NULL)
{
snapshot_mode_text = snapshot_mode_current->name;
}
-static void execSetupGame()
+static void execSetupGame(void)
{
execSetupGame_setGameSpeeds();
execSetupGame_setScrollDelays();
DrawSetupScreen();
}
-static void execSetupChooseGameSpeed()
+static void execSetupChooseGameSpeed(void)
{
setup_mode = SETUP_MODE_CHOOSE_GAME_SPEED;
DrawSetupScreen();
}
-static void execSetupChooseScrollDelay()
+static void execSetupChooseScrollDelay(void)
{
setup_mode = SETUP_MODE_CHOOSE_SCROLL_DELAY;
DrawSetupScreen();
}
-static void execSetupChooseSnapshotMode()
+static void execSetupChooseSnapshotMode(void)
{
setup_mode = SETUP_MODE_CHOOSE_SNAPSHOT_MODE;
DrawSetupScreen();
}
-static void execSetupEditor()
+static void execSetupEditor(void)
{
setup_mode = SETUP_MODE_EDITOR;
window_size_text = window_size_current->name;
}
-static void execSetupGraphics_setScalingTypes()
+static void execSetupGraphics_setScalingTypes(void)
{
if (scaling_types == NULL)
{
scaling_type_text = scaling_type_current->name;
}
-static void execSetupGraphics_setRenderingModes()
+static void execSetupGraphics_setRenderingModes(void)
{
if (rendering_modes == NULL)
{
rendering_mode_text = rendering_mode_current->name;
}
-static void execSetupGraphics()
+static void execSetupGraphics(void)
{
// update "setup.window_scaling_percent" from list selection
// (in this case, window scaling was changed on setup screen)
#endif
}
-static void execSetupChooseWindowSize()
+static void execSetupChooseWindowSize(void)
{
setup_mode = SETUP_MODE_CHOOSE_WINDOW_SIZE;
DrawSetupScreen();
}
-static void execSetupChooseScalingType()
+static void execSetupChooseScalingType(void)
{
setup_mode = SETUP_MODE_CHOOSE_SCALING_TYPE;
DrawSetupScreen();
}
-static void execSetupChooseRenderingMode()
+static void execSetupChooseRenderingMode(void)
{
setup_mode = SETUP_MODE_CHOOSE_RENDERING;
DrawSetupScreen();
}
-static void execSetupChooseVolumeSimple()
+static void execSetupChooseVolumeSimple(void)
{
setup_mode = SETUP_MODE_CHOOSE_VOLUME_SIMPLE;
DrawSetupScreen();
}
-static void execSetupChooseVolumeLoops()
+static void execSetupChooseVolumeLoops(void)
{
setup_mode = SETUP_MODE_CHOOSE_VOLUME_LOOPS;
DrawSetupScreen();
}
-static void execSetupChooseVolumeMusic()
+static void execSetupChooseVolumeMusic(void)
{
setup_mode = SETUP_MODE_CHOOSE_VOLUME_MUSIC;
DrawSetupScreen();
}
-static void execSetupSound()
+static void execSetupSound(void)
{
if (volumes_simple == NULL)
{
DrawSetupScreen();
}
-static void execSetupChooseTouchControls()
+static void execSetupChooseTouchControls(void)
{
setup_mode = SETUP_MODE_CHOOSE_TOUCH_CONTROL;
DrawSetupScreen();
}
-static void execSetupChooseMoveDistance()
+static void execSetupChooseMoveDistance(void)
{
setup_mode = SETUP_MODE_CHOOSE_MOVE_DISTANCE;
DrawSetupScreen();
}
-static void execSetupChooseDropDistance()
+static void execSetupChooseDropDistance(void)
{
setup_mode = SETUP_MODE_CHOOSE_DROP_DISTANCE;
DrawSetupScreen();
}
-static void execSetupChooseTransparency()
+static void execSetupChooseTransparency(void)
{
setup_mode = SETUP_MODE_CHOOSE_TRANSPARENCY;
DrawSetupScreen();
}
-static void execSetupChooseGridXSize_0()
+static void execSetupChooseGridXSize_0(void)
{
setup_mode = SETUP_MODE_CHOOSE_GRID_XSIZE_0;
DrawSetupScreen();
}
-static void execSetupChooseGridYSize_0()
+static void execSetupChooseGridYSize_0(void)
{
setup_mode = SETUP_MODE_CHOOSE_GRID_YSIZE_0;
DrawSetupScreen();
}
-static void execSetupChooseGridXSize_1()
+static void execSetupChooseGridXSize_1(void)
{
setup_mode = SETUP_MODE_CHOOSE_GRID_XSIZE_1;
DrawSetupScreen();
}
-static void execSetupChooseGridYSize_1()
+static void execSetupChooseGridYSize_1(void)
{
setup_mode = SETUP_MODE_CHOOSE_GRID_YSIZE_1;
DrawSetupScreen();
}
-static void execSetupConfigureVirtualButtons()
+static void execSetupConfigureVirtualButtons(void)
{
setup_mode = SETUP_MODE_CONFIG_VIRT_BUTTONS;
DrawSetupScreen();
}
-static void execSetupTouch()
+static void execSetupTouch(void)
{
int i, j, k;
DrawSetupScreen();
}
-static void execSetupArtwork()
+static void execSetupArtwork(void)
{
#if 0
printf("::: '%s', '%s', '%s'\n",
DrawSetupScreen();
}
-static void execSetupChooseGraphics()
+static void execSetupChooseGraphics(void)
{
setup_mode = SETUP_MODE_CHOOSE_GRAPHICS;
DrawSetupScreen();
}
-static void execSetupChooseSounds()
+static void execSetupChooseSounds(void)
{
setup_mode = SETUP_MODE_CHOOSE_SOUNDS;
DrawSetupScreen();
}
-static void execSetupChooseMusic()
+static void execSetupChooseMusic(void)
{
setup_mode = SETUP_MODE_CHOOSE_MUSIC;
DrawSetupScreen();
}
-static void execSetupInput()
+static void execSetupInput(void)
{
setup_mode = SETUP_MODE_INPUT;
DrawSetupScreen();
}
-static void execSetupShortcuts()
+static void execSetupShortcuts(void)
{
setup_mode = SETUP_MODE_SHORTCUTS;
DrawSetupScreen();
}
-static void execSetupShortcuts1()
+static void execSetupShortcuts1(void)
{
setup_mode = SETUP_MODE_SHORTCUTS_1;
DrawSetupScreen();
}
-static void execSetupShortcuts2()
+static void execSetupShortcuts2(void)
{
setup_mode = SETUP_MODE_SHORTCUTS_2;
DrawSetupScreen();
}
-static void execSetupShortcuts3()
+static void execSetupShortcuts3(void)
{
setup_mode = SETUP_MODE_SHORTCUTS_3;
DrawSetupScreen();
}
-static void execSetupShortcuts4()
+static void execSetupShortcuts4(void)
{
setup_mode = SETUP_MODE_SHORTCUTS_4;
DrawSetupScreen();
}
-static void execSetupShortcuts5()
+static void execSetupShortcuts5(void)
{
setup_mode = SETUP_MODE_SHORTCUTS_5;
DrawSetupScreen();
}
-static void execExitSetup()
+static void execExitSetup(void)
{
SetGameStatus(GAME_MODE_MAIN);
DrawMainMenu();
}
-static void execSaveAndExitSetup()
+static void execSaveAndExitSetup(void)
{
SaveSetup();
execExitSetup();
{ NULL, NULL }
};
-void setHideRelatedSetupEntries()
+void setHideRelatedSetupEntries(void)
{
int i;
{ 0, NULL, NULL }
};
-static Key getSetupKey()
+static Key getSetupKey(void)
{
Key key = KSYM_UNDEFINED;
boolean got_key_event = FALSE;
return setup_info_final;
}
-static void DrawSetupScreen_Generic()
+static void DrawSetupScreen_Generic(void)
{
int fade_mask = REDRAW_FIELD;
boolean redraw_all = FALSE;
setup_mode, num_setup_info, max_setup_info);
}
-void DrawSetupScreen_Input()
+void DrawSetupScreen_Input(void)
{
int i;
DrawSetupScreen_Input();
}
-boolean ConfigureVirtualButtonsMain()
+boolean ConfigureVirtualButtonsMain(void)
{
static char *customize_step_text[] =
{
return success;
}
-void ConfigureVirtualButtons()
+void ConfigureVirtualButtons(void)
{
boolean success = ConfigureVirtualButtonsMain();
}
}
-void DrawSetupScreen()
+void DrawSetupScreen(void)
{
if (setup_mode == SETUP_MODE_INPUT)
DrawSetupScreen_Input();
PlayMenuSoundsAndMusic();
}
-void RedrawSetupScreenAfterFullscreenToggle()
+void RedrawSetupScreenAfterFullscreenToggle(void)
{
if (setup_mode == SETUP_MODE_GRAPHICS ||
setup_mode == SETUP_MODE_CHOOSE_WINDOW_SIZE)
HandleSetupScreen_Generic(mx, my, dx, dy, button);
}
-void HandleGameActions()
+void HandleGameActions(void)
{
if (game.restart_game_message != NULL)
RequestRestartGame(game.restart_game_message);
}
};
-static void CreateScreenMenubuttons()
+static void CreateScreenMenubuttons(void)
{
struct GadgetInfo *gi;
unsigned int event_mask;
}
}
-static void CreateScreenScrollbuttons()
+static void CreateScreenScrollbuttons(void)
{
struct GadgetInfo *gi;
unsigned int event_mask;
}
}
-static void CreateScreenScrollbars()
+static void CreateScreenScrollbars(void)
{
int i;
}
}
-void CreateScreenGadgets()
+void CreateScreenGadgets(void)
{
CreateScreenMenubuttons();
CreateScreenScrollbars();
}
-void FreeScreenGadgets()
+void FreeScreenGadgets(void)
{
int i;
}
}
-void DumpScreenIdentifiers()
+void DumpScreenIdentifiers(void)
{
int i;
void DrawMainMenu(void);
void DrawHallOfFame(int, int);
-void RedrawSetupScreenAfterFullscreenToggle();
+void RedrawSetupScreenAfterFullscreenToggle(void);
void RedrawSetupScreenAfterScreenRotation(int);
void HandleTitleScreen(int, int, int, int, int);
void HandleTypeName(int, Key);
void HandleGameActions(void);
-void CreateScreenGadgets();
-void FreeScreenGadgets();
+void CreateScreenGadgets(void);
+void FreeScreenGadgets(void);
-void setHideRelatedSetupEntries();
+void setHideRelatedSetupEntries(void);
void DumpScreenIdentifiers(void);
boolean DoScreenAction(int);
/* forward declaration for internal use */
static void HandleTapeButtons(struct GadgetInfo *);
-static void TapeStopWarpForward();
-static float GetTapeLengthSecondsFloat();
+static void TapeStopWarpForward(void);
+static float GetTapeLengthSecondsFloat(void);
static struct GadgetInfo *tape_gadget[NUM_TAPE_BUTTONS];
DrawVideoDisplay(state, VIDEO_DISPLAY_SYMBOL_ONLY);
}
-void DrawVideoDisplayCurrentState()
+void DrawVideoDisplayCurrentState(void)
{
int state = 0;
DrawVideoDisplaySymbol(state);
}
-void DrawCompleteVideoDisplay()
+void DrawCompleteVideoDisplay(void)
{
struct GraphicInfo *g_tape = &graphic_info[IMG_BACKGROUND_TAPE];
0, 0);
}
-void TapeDeactivateDisplayOn()
+void TapeDeactivateDisplayOn(void)
{
SetDrawDeactivationMask(REDRAW_FIELD);
audio.sound_deactivated = TRUE;
tape.date = 10000 * (lt->tm_year % 100) + 100 * lt->tm_mon + lt->tm_mday;
}
-void TapeSetDateFromNow()
+void TapeSetDateFromNow(void)
{
TapeSetDateFromEpochSeconds(time(NULL));
}
-void TapeErase()
+void TapeErase(void)
{
int i;
tape.use_mouse = (level.game_engine_type == GAME_ENGINE_TYPE_MM);
}
-static void TapeRewind()
+static void TapeRewind(void)
{
tape.counter = 0;
tape.delay_played = 0;
audio.sound_deactivated = FALSE;
}
-static void TapeStartGameRecording()
+static void TapeStartGameRecording(void)
{
StartGameActions(network.enabled, TRUE, level.random_seed);
}
-static void TapeAppendRecording()
+static void TapeAppendRecording(void)
{
if (!tape.playing || !tape.pausing)
return;
UpdateAndDisplayGameControlValues();
}
-void TapeHaltRecording()
+void TapeHaltRecording(void)
{
tape.counter++;
tape.length_seconds = GetTapeLengthSeconds();
}
-void TapeStopRecording()
+void TapeStopRecording(void)
{
if (tape.recording)
TapeHaltRecording();
}
}
-void TapeStartPlaying()
+void TapeStartPlaying(void)
{
if (TAPE_IS_EMPTY(tape))
return;
audio.sound_deactivated = FALSE;
}
-static void TapeStartGamePlaying()
+static void TapeStartGamePlaying(void)
{
TapeStartPlaying();
InitGame();
}
-void TapeStopPlaying()
+void TapeStopPlaying(void)
{
tape.playing = FALSE;
tape.pausing = FALSE;
MapTapeEjectButton();
}
-byte *TapePlayAction()
+byte *TapePlayAction(void)
{
int update_delay = FRAMES_PER_SECOND / 2;
boolean update_video_display = (FrameCounter % update_delay == 0);
return action;
}
-void TapeStop()
+void TapeStop(void)
{
if (tape.pausing)
TapeTogglePause(TAPE_TOGGLE_MANUAL);
}
}
-unsigned int GetTapeLengthFrames()
+unsigned int GetTapeLengthFrames(void)
{
unsigned int tape_length_frames = 0;
int i;
return tape_length_frames;
}
-unsigned int GetTapeLengthSeconds()
+unsigned int GetTapeLengthSeconds(void)
{
return (GetTapeLengthFrames() * GAME_FRAME_DELAY / 1000);
}
-static float GetTapeLengthSecondsFloat()
+static float GetTapeLengthSecondsFloat(void)
{
return ((float)GetTapeLengthFrames() * GAME_FRAME_DELAY / 1000);
}
DrawVideoDisplayCurrentState();
}
-static void TapeStopWarpForward()
+static void TapeStopWarpForward(void)
{
tape.fast_forward = FALSE;
tape.warp_forward = FALSE;
DrawVideoDisplayCurrentState();
}
-static void TapeSingleStep()
+static void TapeSingleStep(void)
{
if (network.enabled)
return;
DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
}
-void TapeQuickSave()
+void TapeQuickSave(void)
{
if (game_status == GAME_MODE_MAIN)
{
SaveEngineSnapshotSingle();
}
-void TapeQuickLoad()
+void TapeQuickLoad(void)
{
char *filename = getTapeFilename(level_nr);
}
}
-boolean hasSolutionTape()
+boolean hasSolutionTape(void)
{
boolean tape_file_exists = fileExists(getSolutionTapeFilename(level_nr));
boolean level_has_tape = (level.game_engine_type == GAME_ENGINE_TYPE_SP &&
return (tape_file_exists || level_has_tape);
}
-boolean InsertSolutionTape()
+boolean InsertSolutionTape(void)
{
if (!hasSolutionTape())
{
return TRUE;
}
-boolean PlaySolutionTape()
+boolean PlaySolutionTape(void)
{
if (!InsertSolutionTape())
return FALSE;
* tape autoplay functions
* ------------------------------------------------------------------------- */
-void AutoPlayTape()
+void AutoPlayTape(void)
{
static LevelDirTree *autoplay_leveldir = NULL;
static boolean autoplay_initialized = FALSE;
}
};
-void CreateTapeButtons()
+void CreateTapeButtons(void)
{
int i;
}
}
-void FreeTapeButtons()
+void FreeTapeButtons(void)
{
int i;
FreeGadget(tape_gadget[i]);
}
-void MapTapeEjectButton()
+void MapTapeEjectButton(void)
{
UnmapGadget(tape_gadget[TAPE_CTRL_ID_EXTRA]);
MapGadget(tape_gadget[TAPE_CTRL_ID_EJECT]);
}
-void MapTapeWarpButton()
+void MapTapeWarpButton(void)
{
UnmapGadget(tape_gadget[TAPE_CTRL_ID_EJECT]);
MapGadget(tape_gadget[TAPE_CTRL_ID_EXTRA]);
}
-void MapTapeButtons()
+void MapTapeButtons(void)
{
int i;
MapGameButtonsOnTape();
}
-void UnmapTapeButtons()
+void UnmapTapeButtons(void)
{
int i;
UnmapGameButtonsOnTape();
}
-void RedrawTapeButtons()
+void RedrawTapeButtons(void)
{
int i;
redraw_mask &= ~REDRAW_ALL;
}
-void RedrawOrRemapTapeButtons()
+void RedrawOrRemapTapeButtons(void)
{
if (tape_gadget[TAPE_CTRL_ID_PLAY]->mapped)
{
void DrawVideoDisplay(unsigned int, unsigned int);
void DrawCompleteVideoDisplay(void);
-void TapeDeactivateDisplayOn();
+void TapeDeactivateDisplayOn(void);
void TapeDeactivateDisplayOff(boolean);
void TapeSetDateFromEpochSeconds(time_t);
-void TapeSetDateFromNow();
+void TapeSetDateFromNow(void);
void TapeStartRecording(int);
void TapeHaltRecording(void);
void TapeQuickSave(void);
void TapeQuickLoad(void);
-boolean hasSolutionTape();
+boolean hasSolutionTape(void);
boolean InsertSolutionTape(void);
boolean PlaySolutionTape(void);
void AutoPlayTape(void);
-void CreateTapeButtons();
-void FreeTapeButtons();
-void MapTapeEjectButton();
-void MapTapeWarpButton();
-void MapTapeButtons();
-void UnmapTapeButtons();
-void RedrawTapeButtons();
-void RedrawOrRemapTapeButtons();
+void CreateTapeButtons(void);
+void FreeTapeButtons(void);
+void MapTapeEjectButton(void);
+void MapTapeWarpButton(void);
+void MapTapeButtons(void);
+void UnmapTapeButtons(void);
+void RedrawTapeButtons(void);
+void RedrawOrRemapTapeButtons(void);
void HandleTapeButtonKeys(Key);
/* 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()
+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;
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);
}
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()
+boolean CheckIfGlobalBorderRedrawIsNeeded(void)
{
// if game status has not changed, nothing has to be redrawn
if (game_status == game_status_last)
ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
}
-void RedrawGlobalBorder()
+void RedrawGlobalBorder(void)
{
Bitmap *bitmap = getGlobalBorderBitmapFromStatus(game_status);
#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;
}
}
-void DrawPreviewPlayers()
+void DrawPreviewPlayers(void)
{
if (game_status != GAME_MODE_MAIN)
return;
}
}
-void DrawPreviewLevelInitial()
+void DrawPreviewLevelInitial(void)
{
DrawPreviewLevelExt(TRUE);
DrawPreviewPlayers();
}
-void DrawPreviewLevelAnimation()
+void DrawPreviewLevelAnimation(void)
{
DrawPreviewLevelExt(FALSE);
}
}
}
-void DrawNetworkPlayers()
+void DrawNetworkPlayers(void)
{
DrawNetworkPlayersExt(FALSE);
}
-void ClearNetworkPlayers()
+void ClearNetworkPlayers(void)
{
DrawNetworkPlayersExt(TRUE);
}
g1->anim_mode == g2->anim_mode);
}
-void DrawAllPlayers()
+void DrawAllPlayers(void)
{
int i;
/* ------------------------------------------------------------------------- */
-void WaitForEventToContinue()
+void WaitForEventToContinue(void)
{
boolean still_wait = TRUE;
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 (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 || network_playing;
}
PlaySound(sound);
}
-void PlayMenuSound()
+void PlayMenuSound(void)
{
PlayMenuSoundExt(menu.sound[game_status]);
}
PlaySoundLoop(sound);
}
-void PlayMenuSoundIfLoop()
+void PlayMenuSoundIfLoop(void)
{
PlayMenuSoundIfLoopExt(menu.sound[game_status]);
}
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 ResetFontStatus()
+void ResetFontStatus(void)
{
SetFontStatus(-1);
}
levelset.level_nr = level_nr;
}
-boolean CheckIfPlayfieldViewportHasChanged()
+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);
void DumpTile(int, int);
void DumpTileFromScreen(int, int);
-void DrawMaskedBorder_FIELD();
-void DrawMaskedBorder_DOOR_1();
-void DrawMaskedBorder_DOOR_2();
-void DrawMaskedBorder_DOOR_3();
-void DrawMaskedBorder_ALL();
+void DrawMaskedBorder_FIELD(void);
+void DrawMaskedBorder_DOOR_1(void);
+void DrawMaskedBorder_DOOR_2(void);
+void DrawMaskedBorder_DOOR_3(void);
+void DrawMaskedBorder_ALL(void);
void DrawMaskedBorder(int);
void DrawMaskedBorderToTarget(int);
void DrawTileCursor(int);
void SetDrawtoField(int);
-void RedrawPlayfield();
+void RedrawPlayfield(void);
void BlitScreenToBitmap_RND(Bitmap *);
void BlitScreenToBitmap(Bitmap *);
-void BackToFront();
+void BackToFront(void);
void BackToFront_WithFrameDelay(unsigned int);
void FadeIn(int);
void FadeOut(int);
-void FadeSetEnterMenu();
-void FadeSetLeaveMenu();
-void FadeSetEnterScreen();
-void FadeSetNextScreen();
-void FadeSetLeaveScreen();
+void FadeSetEnterMenu(void);
+void FadeSetLeaveMenu(void);
+void FadeSetEnterScreen(void);
+void FadeSetNextScreen(void);
+void FadeSetLeaveScreen(void);
void FadeSetFromType(int);
-void FadeSetDisabled();
-void FadeSkipNextFadeIn();
-void FadeSkipNextFadeOut();
+void FadeSetDisabled(void);
+void FadeSkipNextFadeIn(void);
+void FadeSkipNextFadeOut(void);
Bitmap *getGlobalBorderBitmapFromStatus(int);
-void ClearField();
+void ClearField(void);
void SetWindowBackgroundImageIfDefined(int);
void SetMainBackgroundImageIfDefined(int);
void SetDoorBackgroundImageIfDefined(int);
void SetWindowBackgroundImage(int);
void SetMainBackgroundImage(int);
void SetDoorBackgroundImage(int);
-void SetPanelBackground();
+void SetPanelBackground(void);
void DrawBackground(int, int, int, int);
void DrawBackgroundForFont(int, int, int, int, int);
void DrawBackgroundForGraphic(int, int, int, int, int);
-boolean CheckIfGlobalBorderHasChanged();
-void RedrawGlobalBorder();
+boolean CheckIfGlobalBorderHasChanged(void);
+void RedrawGlobalBorder(void);
void MarkTileDirty(int, int);
-void SetBorderElement();
+void SetBorderElement(void);
void FloodFillLevel(int, int, int, short[][MAX_LEV_FIELDY], int, int);
void FloodFillLevelExt(int, int, int, int, int y, short field[][y], int, int);
unsigned int SetDoorState(unsigned int);
unsigned int MoveDoor(unsigned int);
-void DrawSpecialEditorDoor();
-void UndrawSpecialEditorDoor();
+void DrawSpecialEditorDoor(void);
+void UndrawSpecialEditorDoor(void);
-void CreateToolButtons();
-void FreeToolButtons();
+void CreateToolButtons(void);
+void FreeToolButtons(void);
int map_element_RND_to_EM(int);
int map_element_EM_to_RND(int);
void InitGraphicInfo_EM(void);
void PlayMenuSoundExt(int);
-void PlayMenuSound();
+void PlayMenuSound(void);
void PlayMenuSoundStereo(int, int);
void PlayMenuSoundIfLoopExt(int);
-void PlayMenuSoundIfLoop();
+void PlayMenuSoundIfLoop(void);
void PlayMenuMusicExt(int);
-void PlayMenuMusic();
-void PlayMenuSoundsAndMusic();
-void FadeMenuSoundsAndMusic();
-void PlaySoundActivating();
-void PlaySoundSelecting();
+void PlayMenuMusic(void);
+void PlayMenuSoundsAndMusic(void);
+void FadeMenuSoundsAndMusic(void);
+void PlaySoundActivating(void);
+void PlaySoundSelecting(void);
void SetAnimStatus(int);
void SetGameStatus(int);
void SetFontStatus(int);
-void ResetFontStatus();
+void ResetFontStatus(void);
void SetLevelSetInfo(char *, int);
-void ToggleFullscreenOrChangeWindowScalingIfNeeded();
-void ChangeViewportPropertiesIfNeeded();
+void ToggleFullscreenOrChangeWindowScalingIfNeeded(void);
+void ChangeViewportPropertiesIfNeeded(void);
-boolean CheckIfPlayfieldViewportHasChanged();
-boolean CheckIfGlobalBorderOrPlayfieldViewportHasChanged();
+boolean CheckIfPlayfieldViewportHasChanged(void);
+boolean CheckIfGlobalBorderOrPlayfieldViewportHasChanged(void);
#endif /* TOOLS_H */
projects / rocksndiamonds.git / commitdiff