#include "joystick.h"
#include "misc.h"
-#define ENABLE_UNUSED_CODE 0 /* currently unused functions */
+#define ENABLE_UNUSED_CODE 0 // currently unused functions
-/* ========================================================================= */
-/* exported variables */
-/* ========================================================================= */
+// ============================================================================
+// exported variables
+// ============================================================================
struct ProgramInfo program;
+struct NetworkInfo network;
struct OptionInfo options;
struct VideoSystemInfo video;
struct AudioSystemInfo audio;
struct GfxInfo gfx;
+struct TileCursorInfo tile_cursor;
struct OverlayInfo overlay;
struct ArtworkInfo artwork;
struct JoystickInfo joystick;
LevelDirTree *leveldir_current = NULL;
int level_nr;
+struct LevelSetInfo levelset;
struct LevelStats level_stats[MAX_LEVELS];
DrawWindow *window = NULL;
int FrameCounter = 0;
-/* ========================================================================= */
-/* init/close functions */
-/* ========================================================================= */
+// ============================================================================
+// init/close functions
+// ============================================================================
void InitProgramInfo(char *argv0, char *config_filename, char *userdata_subdir,
char *program_title, char *icon_title,
program.cookie_prefix = cookie_prefix;
+ program.version_super = VERSION_SUPER(program_version);
program.version_major = VERSION_MAJOR(program_version);
program.version_minor = VERSION_MINOR(program_version);
program.version_patch = VERSION_PATCH(program_version);
- program.version_build = VERSION_BUILD(program_version);
program.version_ident = program_version;
program.version_string = program_version_string;
program.headless = FALSE;
}
-void InitScoresInfo()
+void InitNetworkInfo(boolean enabled, boolean connected, boolean serveronly,
+ char *server_host, int server_port)
+{
+ network.enabled = enabled;
+ network.connected = connected;
+ network.serveronly = serveronly;
+
+ network.server_host = server_host;
+ network.server_port = server_port;
+}
+
+void InitScoresInfo(void)
{
char *global_scores_dir = getPath2(getCommonDataDir(), SCORES_DIRECTORY);
program.global_scores = directoryExists(global_scores_dir);
program.many_scores_per_name = !program.global_scores;
+#if 0
if (options.debug)
{
if (program.global_scores)
Error(ERR_DEBUG, "Using private, single-user scores directory.");
}
}
+#endif
free(global_scores_dir);
}
-void SetWindowTitle()
+void SetWindowTitle(void)
{
program.window_title = program.window_title_function();
{
program.exit_function = exit_function;
- /* set signal handlers to custom exit function */
+ // set signal handlers to custom exit function
// signal(SIGINT, exit_function);
signal(SIGTERM, exit_function);
- /* set exit function to automatically cleanup SDL stuff after exit() */
+ // set exit function to automatically cleanup SDL stuff after exit()
atexit(SDL_Quit);
}
gfx.field_save_buffer = field_save_buffer;
- SetDrawDeactivationMask(REDRAW_NONE); /* do not deactivate drawing */
- SetDrawBackgroundMask(REDRAW_NONE); /* deactivate masked drawing */
+ SetDrawDeactivationMask(REDRAW_NONE); // do not deactivate drawing
+ SetDrawBackgroundMask(REDRAW_NONE); // deactivate masked drawing
}
void InitGfxTileSizeInfo(int game_tile_size, int standard_tile_size)
void InitGfxScrollbufferInfo(int scrollbuffer_width, int scrollbuffer_height)
{
- /* currently only used by MSDOS code to alloc VRAM buffer, if available */
- /* 2009-03-24: also (temporarily?) used for overlapping blit workaround */
+ // currently only used by MSDOS code to alloc VRAM buffer, if available
+ // 2009-03-24: also (temporarily?) used for overlapping blit workaround
gfx.scrollbuffer_width = scrollbuffer_width;
gfx.scrollbuffer_height = scrollbuffer_height;
}
gfx.draw_global_border_function = draw_global_border_function;
}
-void InitGfxCustomArtworkInfo()
+void InitGfxDrawTileCursorFunction(void (*draw_tile_cursor_function)(int))
+{
+ gfx.draw_tile_cursor_function = draw_tile_cursor_function;
+}
+
+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 InitOverlayInfo()
+void InitTileCursorInfo(void)
+{
+ tile_cursor.enabled = FALSE;
+ tile_cursor.active = FALSE;
+ tile_cursor.moving = FALSE;
+
+ tile_cursor.xpos = 0;
+ tile_cursor.ypos = 0;
+ tile_cursor.x = 0;
+ tile_cursor.y = 0;
+ tile_cursor.target_x = 0;
+ tile_cursor.target_y = 0;
+
+ tile_cursor.sx = 0;
+ tile_cursor.sy = 0;
+}
+
+void InitOverlayInfo(void)
{
+ int nr = GRID_ACTIVE_NR();
+ int x, y;
+
overlay.enabled = FALSE;
overlay.active = FALSE;
-#if defined(PLATFORM_ANDROID)
+ overlay.show_grid = FALSE;
+
+ overlay.grid_xsize = setup.touch.grid_xsize[nr];
+ overlay.grid_ysize = setup.touch.grid_ysize[nr];
+
+ for (x = 0; x < MAX_GRID_XSIZE; x++)
+ for (y = 0; y < MAX_GRID_YSIZE; y++)
+ overlay.grid_button[x][y] = setup.touch.grid_button[nr][x][y];
+
+ overlay.grid_button_highlight = CHAR_GRID_BUTTON_NONE;
+ overlay.grid_button_action = JOY_NO_ACTION;
+
+#if defined(USE_TOUCH_INPUT_OVERLAY)
if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
overlay.enabled = TRUE;
#endif
}
+void SetTileCursorEnabled(boolean enabled)
+{
+ tile_cursor.enabled = enabled;
+}
+
+void SetTileCursorActive(boolean active)
+{
+ tile_cursor.active = active;
+}
+
+void SetTileCursorTargetXY(int x, int y)
+{
+ // delayed placement of tile selection cursor at target position
+ // (tile cursor will be moved to target position step by step)
+
+ tile_cursor.xpos = x;
+ tile_cursor.ypos = y;
+ tile_cursor.target_x = tile_cursor.sx + x * gfx.game_tile_size;
+ tile_cursor.target_y = tile_cursor.sy + y * gfx.game_tile_size;
+
+ tile_cursor.moving = TRUE;
+}
+
+void SetTileCursorXY(int x, int y)
+{
+ // immediate placement of tile selection cursor at target position
+
+ SetTileCursorTargetXY(x, y);
+
+ tile_cursor.x = tile_cursor.target_x;
+ tile_cursor.y = tile_cursor.target_y;
+
+ tile_cursor.moving = FALSE;
+}
+
+void SetTileCursorSXSY(int sx, int sy)
+{
+ tile_cursor.sx = sx;
+ tile_cursor.sy = sy;
+}
+
void SetOverlayEnabled(boolean enabled)
{
overlay.enabled = enabled;
overlay.active = active;
}
-boolean GetOverlayActive()
+void SetOverlayShowGrid(boolean show_grid)
+{
+ overlay.show_grid = show_grid;
+
+ SetOverlayActive(show_grid);
+
+ if (show_grid)
+ SetOverlayEnabled(TRUE);
+}
+
+boolean GetOverlayActive(void)
{
return overlay.active;
}
gfx.draw_deactivation_mask = draw_deactivation_mask;
}
-int GetDrawDeactivationMask()
+int GetDrawDeactivationMask(void)
{
return gfx.draw_deactivation_mask;
}
gfx.draw_background_mask = draw_background_mask;
}
-void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
+static void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
{
if (background_bitmap_tile != NULL)
gfx.background_bitmap_mask |= mask;
else
gfx.background_bitmap_mask &= ~mask;
- if (background_bitmap_tile == NULL) /* empty background requested */
+ if (background_bitmap_tile == NULL) // empty background requested
return;
if (mask == REDRAW_ALL)
void SetWindowBackgroundBitmap(Bitmap *background_bitmap_tile)
{
- /* remove every mask before setting mask for window */
- /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
- SetBackgroundBitmap(NULL, 0xffff); /* !!! FIX THIS !!! */
+ // remove every mask before setting mask for window
+ // (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!)
+ SetBackgroundBitmap(NULL, 0xffff); // !!! FIX THIS !!!
SetBackgroundBitmap(background_bitmap_tile, REDRAW_ALL);
}
void SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
{
- /* remove window area mask before setting mask for main area */
- /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
- SetBackgroundBitmap(NULL, REDRAW_ALL); /* !!! FIX THIS !!! */
+ // remove window area mask before setting mask for main area
+ // (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!)
+ SetBackgroundBitmap(NULL, REDRAW_ALL); // !!! FIX THIS !!!
SetBackgroundBitmap(background_bitmap_tile, REDRAW_FIELD);
}
void SetDoorBackgroundBitmap(Bitmap *background_bitmap_tile)
{
- /* remove window area mask before setting mask for door area */
- /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
- SetBackgroundBitmap(NULL, REDRAW_ALL); /* !!! FIX THIS !!! */
+ // remove window area mask before setting mask for door area
+ // (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!)
+ SetBackgroundBitmap(NULL, REDRAW_ALL); // !!! FIX THIS !!!
SetBackgroundBitmap(background_bitmap_tile, REDRAW_DOOR_1);
}
-/* ========================================================================= */
-/* video functions */
-/* ========================================================================= */
+// ============================================================================
+// video functions
+// ============================================================================
-inline static int GetRealDepth(int depth)
+static int GetRealDepth(int depth)
{
return (depth == DEFAULT_DEPTH ? video.default_depth : depth);
}
-inline static void sysFillRectangle(Bitmap *bitmap, int x, int y,
- int width, int height, Pixel color)
+static void sysFillRectangle(Bitmap *bitmap, int x, int y,
+ int width, int height, Pixel color)
{
SDLFillRectangle(bitmap, x, y, width, height, color);
SetRedrawMaskFromArea(x, y, width, height);
}
-inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
- int src_x, int src_y, int width, int height,
- int dst_x, int dst_y, int mask_mode)
+static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y, int width, int height,
+ int dst_x, int dst_y, int mask_mode)
{
SDLCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
dst_x, dst_y, mask_mode);
SDLLimitScreenUpdates(enable);
}
+void InitVideoDefaults(void)
+{
+ video.default_depth = 32;
+}
+
void InitVideoDisplay(void)
{
if (program.headless)
SDLInitVideoBuffer(fullscreen);
- video.initialized = TRUE;
+ video.initialized = !program.headless;
drawto = backbuffer;
}
-inline static void FreeBitmapPointers(Bitmap *bitmap)
+static void FreeBitmapPointers(Bitmap *bitmap)
{
if (bitmap == NULL)
return;
bitmap->source_filename = NULL;
}
-inline static void TransferBitmapPointers(Bitmap *src_bitmap,
- Bitmap *dst_bitmap)
+static void TransferBitmapPointers(Bitmap *src_bitmap,
+ Bitmap *dst_bitmap)
{
if (src_bitmap == NULL || dst_bitmap == NULL)
return;
Bitmap *CreateBitmap(int width, int height, int depth)
{
Bitmap *new_bitmap = CreateBitmapStruct();
- int real_width = MAX(1, width); /* prevent zero bitmap width */
- int real_height = MAX(1, height); /* prevent zero bitmap height */
+ int real_width = MAX(1, width); // prevent zero bitmap width
+ int real_height = MAX(1, height); // prevent zero bitmap height
int real_depth = GetRealDepth(depth);
SDLCreateBitmapContent(new_bitmap, real_width, real_height, real_depth);
{
if (*bitmap != NULL)
{
- /* if new bitmap size fits into old one, no need to re-create it */
+ // if new bitmap size fits into old one, no need to re-create it
if (width <= (*bitmap)->width &&
height <= (*bitmap)->height)
return;
- /* else adjust size so that old and new bitmap size fit into it */
+ // else adjust size so that old and new bitmap size fit into it
width = MAX(width, (*bitmap)->width);
height = MAX(height, (*bitmap)->height);
}
}
}
-void CloseWindow(DrawWindow *window)
+#if 0
+static void CloseWindow(DrawWindow *window)
{
}
+#endif
void SetRedrawMaskFromArea(int x, int y, int width, int height)
{
redraw_mask = REDRAW_ALL;
}
-inline static boolean CheckDrawingArea(int x, int y, int width, int height,
- int draw_mask)
+static boolean CheckDrawingArea(int x, int y, int width, int height,
+ int draw_mask)
{
if (draw_mask == REDRAW_NONE)
return FALSE;
return FALSE;
}
+boolean DrawingDeactivatedField(void)
+{
+ if (program.headless)
+ return TRUE;
+
+ if (gfx.draw_deactivation_mask & REDRAW_FIELD)
+ return TRUE;
+
+ return FALSE;
+}
+
boolean DrawingDeactivated(int x, int y, int width, int height)
{
return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
{
int clip_x, clip_y, clip_width, clip_height;
- if (gfx.clipping_enabled && is_dest) /* only clip destination bitmap */
+ if (gfx.clipping_enabled && is_dest) // only clip destination bitmap
{
clip_x = MIN(MAX(0, gfx.clip_x), bitmap->width);
clip_y = MIN(MAX(0, gfx.clip_y), bitmap->height);
clip_height = bitmap->height;
}
- /* skip if rectangle completely outside bitmap */
+ // skip if rectangle completely outside bitmap
if (*x + *width <= clip_x ||
*y + *height <= clip_y ||
*y >= clip_y + clip_height)
return FALSE;
- /* clip if rectangle overlaps bitmap */
+ // clip if rectangle overlaps bitmap
if (*x < clip_x)
{
!InClippedRectangle(dst_bitmap, &dst_x, &dst_y, &width, &height, TRUE))
return;
- /* source x/y might need adjustment if destination x/y was clipped top/left */
+ // source x/y might need adjustment if destination x/y was clipped top/left
src_x += dst_x - dst_x_unclipped;
src_y += dst_y - dst_y_unclipped;
#if defined(TARGET_SDL2)
- /* !!! 2013-12-11: An "old friend" is back. Same bug in SDL2 2.0.1 !!! */
- /* !!! 2009-03-30: Fixed by using self-compiled, patched SDL.dll !!! */
+ // !!! 2013-12-11: An "old friend" is back. Same bug in SDL2 2.0.1 !!!
+ // !!! 2009-03-30: Fixed by using self-compiled, patched SDL.dll !!!
/* (This bug still exists in the actual (as of 2009-06-15) version 1.2.13,
but is already fixed in SVN and should therefore finally be fixed with
the next official SDL release, which is probably version 1.2.14.) */
- /* !!! 2009-03-24: It seems that this problem still exists in 1.2.12 !!! */
+ // !!! 2009-03-24: It seems that this problem still exists in 1.2.12 !!!
if (src_bitmap == dst_bitmap)
{
static int tmp_bitmap_xsize = 0;
static int tmp_bitmap_ysize = 0;
- /* start with largest static bitmaps for initial bitmap size ... */
+ // start with largest static bitmaps for initial bitmap size ...
if (tmp_bitmap_xsize == 0 && tmp_bitmap_ysize == 0)
{
tmp_bitmap_xsize = MAX(gfx.win_xsize, gfx.scrollbuffer_width);
tmp_bitmap_ysize = MAX(gfx.win_ysize, gfx.scrollbuffer_height);
}
- /* ... and allow for later re-adjustments due to custom artwork bitmaps */
+ // ... and allow for later re-adjustments due to custom artwork bitmaps
if (src_bitmap->width > tmp_bitmap_xsize ||
src_bitmap->height > tmp_bitmap_ysize)
{
int fade_mode, int fade_delay, int post_delay,
void (*draw_border_function)(void))
{
- /* (use destination bitmap "backbuffer" -- "bitmap_cross" may be undefined) */
+ // (use destination bitmap "backbuffer" -- "bitmap_cross" may be undefined)
if (!InClippedRectangle(backbuffer, &x, &y, &width, &height, TRUE))
return;
{
if (DrawingOnBackground(dst_x, dst_y))
{
- /* draw background */
+ // draw background
BlitBitmap(gfx.background_bitmap, dst_bitmap, dst_x, dst_y, width, height,
dst_x, dst_y);
- /* draw foreground */
+ // draw foreground
BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y, width, height,
dst_x, dst_y);
}
SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, WHITE_PIXEL);
}
-void DrawLine(Bitmap *bitmap, int from_x, int from_y,
- int to_x, int to_y, Pixel pixel, int line_width)
+static void DrawLine(Bitmap *bitmap, int from_x, int from_y,
+ int to_x, int to_y, Pixel pixel, int line_width)
{
int x, y;
+ if (program.headless)
+ return;
+
for (x = 0; x < line_width; x++)
{
for (y = 0; y < line_width; y++)
Pixel GetPixel(Bitmap *bitmap, int x, int y)
{
+ if (program.headless)
+ return BLACK_PIXEL;
+
if (x < 0 || x >= bitmap->width ||
y < 0 || y >= bitmap->height)
return BLACK_PIXEL;
Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
unsigned int color_g, unsigned int color_b)
{
+ if (program.headless)
+ return BLACK_PIXEL;
+
return SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
}
video.frame_delay_value = frame_delay_value;
}
-unsigned int GetVideoFrameDelay()
+unsigned int GetVideoFrameDelay(void)
{
return video.frame_delay_value;
}
char *filename = getCustomImageFilename(basename);
Bitmap *new_bitmap;
- if (filename == NULL) /* (should never happen) */
+ if (filename == NULL) // (should never happen)
{
Error(ERR_WARN, "ReloadCustomImage(): cannot find file '%s'", basename);
return;
old_width = old_bitmap->width;
old_height = old_bitmap->height;
- /* calculate new image dimensions for final image size */
+ // calculate new image dimensions for final image size
width_final = old_width * zoom_factor;
height_final = old_height * zoom_factor;
- /* get image with final size (this might require scaling up) */
- /* ("final" size may result in non-standard tile size image) */
+ // get image with final size (this might require scaling up)
+ // ("final" size may result in non-standard tile size image)
if (zoom_factor != 1)
tmp_bitmap_final = ZoomBitmap(old_bitmap, width_final, height_final);
else
if (create_small_bitmaps)
{
- /* check if we have a non-gameplay tile size image */
+ // check if we have a non-gameplay tile size image
if (tile_size != gfx.game_tile_size)
{
- /* get image with gameplay tile size */
+ // get image with gameplay tile size
width_0 = width_final * gfx.game_tile_size / tile_size;
height_0 = height_final * gfx.game_tile_size / tile_size;
UPDATE_BUSY_STATE();
}
- /* check if we have a non-standard tile size image */
+ // check if we have a non-standard tile size image
if (tile_size != gfx.standard_tile_size)
{
- /* get image with standard tile size */
+ // get image with standard tile size
width_1 = width_final * gfx.standard_tile_size / tile_size;
height_1 = height_final * gfx.standard_tile_size / tile_size;
UPDATE_BUSY_STATE();
}
- /* calculate new image dimensions for small images */
+ // calculate new image dimensions for small images
width_2 = width_1 / 2;
height_2 = height_1 / 2;
width_4 = width_1 / 4;
width_32 = width_1 / 32;
height_32 = height_1 / 32;
- /* get image with 1/2 of normal size (for use in the level editor) */
+ // get image with 1/2 of normal size (for use in the level editor)
if (width_2 == old_width)
tmp_bitmap_2 = old_bitmap;
else
UPDATE_BUSY_STATE();
- /* get image with 1/4 of normal size (for use in the level editor) */
+ // get image with 1/4 of normal size (for use in the level editor)
if (width_4 == old_width)
tmp_bitmap_4 = old_bitmap;
else
UPDATE_BUSY_STATE();
- /* get image with 1/8 of normal size (for use on the preview screen) */
+ // get image with 1/8 of normal size (for use on the preview screen)
if (width_8 == old_width)
tmp_bitmap_8 = old_bitmap;
else
UPDATE_BUSY_STATE();
- /* get image with 1/16 of normal size (for use on the preview screen) */
+ // get image with 1/16 of normal size (for use on the preview screen)
if (width_16 == old_width)
tmp_bitmap_16 = old_bitmap;
else
UPDATE_BUSY_STATE();
- /* get image with 1/32 of normal size (for use on the preview screen) */
+ // get image with 1/32 of normal size (for use on the preview screen)
if (width_32 == old_width)
tmp_bitmap_32 = old_bitmap;
else
free_old_bitmap = FALSE;
if (free_old_bitmap)
+ {
+ // copy image filename from old to new standard sized bitmap
+ bitmaps[IMG_BITMAP_STANDARD]->source_filename =
+ getStringCopy(old_bitmap->source_filename);
+
FreeBitmap(old_bitmap);
+ }
}
else
{
}
-/* ------------------------------------------------------------------------- */
-/* mouse pointer functions */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// mouse pointer functions
+// ----------------------------------------------------------------------------
#define USE_ONE_PIXEL_PLAYFIELD_MOUSEPOINTER 0
-/* XPM image definitions */
+// XPM image definitions
static const char *cursor_image_none[] =
{
- /* width height num_colors chars_per_pixel */
+ // width height num_colors chars_per_pixel
" 16 16 3 1",
- /* colors */
+ // colors
"X c #000000",
". c #ffffff",
" c None",
- /* pixels */
+ // pixels
" ",
" ",
" ",
" ",
" ",
- /* hot spot */
+ // hot spot
"0,0"
};
#if USE_ONE_PIXEL_PLAYFIELD_MOUSEPOINTER
static const char *cursor_image_dot[] =
{
- /* width height num_colors chars_per_pixel */
+ // width height num_colors chars_per_pixel
" 16 16 3 1",
- /* colors */
+ // colors
"X c #000000",
". c #ffffff",
" c None",
- /* pixels */
+ // pixels
" X ",
"X.X ",
" X ",
" ",
" ",
- /* hot spot */
+ // hot spot
"1,1"
};
static const char **cursor_image_playfield = cursor_image_dot;
}
-/* ========================================================================= */
-/* audio functions */
-/* ========================================================================= */
+// ============================================================================
+// audio functions
+// ============================================================================
void OpenAudio(void)
{
- /* always start with reliable default values */
+ // always start with reliable default values
audio.sound_available = FALSE;
audio.music_available = FALSE;
audio.loops_available = FALSE;
}
-/* ========================================================================= */
-/* event functions */
-/* ========================================================================= */
+// ============================================================================
+// event functions
+// ============================================================================
boolean PendingEvent(void)
{
Key GetEventKey(KeyEvent *event, boolean with_modifiers)
{
#if defined(TARGET_SDL2)
- /* key up/down events in SDL2 do not return text characters anymore */
+ // key up/down events in SDL2 do not return text characters anymore
return event->keysym.sym;
#else
{
static KeyMod current_modifiers = KMOD_None;
- if (key != KSYM_UNDEFINED) /* new key => check for modifier key change */
+ if (key != KSYM_UNDEFINED) // new key => check for modifier key change
{
KeyMod new_modifier = KMOD_None;
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)
if (event->type != EVENT_CLIENTMESSAGE)
return FALSE;
- return TRUE; /* the only possible message here is SDL_QUIT */
+ return TRUE; // the only possible message here is SDL_QUIT
}
-/* ========================================================================= */
-/* joystick functions */
-/* ========================================================================= */
+// ============================================================================
+// joystick functions
+// ============================================================================
-void InitJoysticks()
+void InitJoysticks(void)
{
int i;
#if defined(NO_JOYSTICK)
- return; /* joysticks generally deactivated by compile-time directive */
+ return; // joysticks generally deactivated by compile-time directive
#endif
- /* always start with reliable default values */
+ // always start with reliable default values
joystick.status = JOYSTICK_NOT_AVAILABLE;
for (i = 0; i < MAX_PLAYERS; i++)
- joystick.nr[i] = -1; /* no joystick configured */
+ joystick.nr[i] = -1; // no joystick configured
SDLInitJoysticks();
}
return SDLCheckJoystickOpened(nr);
}
-void ClearJoystickState()
+void ClearJoystickState(void)
{
SDLClearJoystickState();
}