/* ========================================================================= */
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;
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();
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;
SDLInitVideoBuffer(fullscreen);
- video.initialized = TRUE;
+ video.initialized = !program.headless;
drawto = backbuffer;
}
}
}
-void CloseWindow(DrawWindow *window)
+#if 0
+static void CloseWindow(DrawWindow *window)
{
}
+#endif
void SetRedrawMaskFromArea(int x, int y, int width, int height)
{
return FALSE;
}
-boolean DrawingDeactivatedField()
+boolean DrawingDeactivatedField(void)
{
if (program.headless)
return TRUE;
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;
video.frame_delay_value = frame_delay_value;
}
-unsigned int GetVideoFrameDelay()
+unsigned int GetVideoFrameDelay(void)
{
return video.frame_delay_value;
}
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
{
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();
}
projects / rocksndiamonds.git / blobdiff