/* ========================================================================= */
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;
struct SetupInfo setup;
LevelDirTree *leveldir_current = NULL;
int level_nr;
+struct LevelSetInfo levelset;
struct LevelStats level_stats[MAX_LEVELS];
DrawWindow *window = NULL;
void InitProgramInfo(char *argv0, char *config_filename, char *userdata_subdir,
char *program_title, char *icon_title,
char *icon_filename, char *cookie_prefix,
- int program_version)
+ char *program_version_string, int program_version)
{
program.command_basepath = getBasePath(argv0);
program.command_basename = getBaseName(argv0);
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.log_filename[LOG_OUT_ID] = getLogFilename(LOG_OUT_BASENAME);
program.log_filename[LOG_ERR_ID] = getLogFilename(LOG_ERR_BASENAME);
program.log_file[LOG_OUT_ID] = program.log_file_default[LOG_OUT_ID] = stdout;
program.log_file[LOG_ERR_ID] = program.log_file_default[LOG_ERR_ID] = stderr;
+
+ program.headless = FALSE;
+}
+
+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 global, multi-user scores directory '%s'.",
+ global_scores_dir);
+ Error(ERR_DEBUG, "Remove to enable single-user scores directory.");
+ Error(ERR_DEBUG, "(This enables multipe score entries per user.)");
+ }
+ else
+ {
+ 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 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;
+
+ 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;
+}
+
+void SetOverlayActive(boolean active)
+{
+ overlay.active = active;
+}
+
+void SetOverlayShowGrid(boolean show_grid)
+{
+ overlay.show_grid = show_grid;
+
+ SetOverlayActive(show_grid);
+
+ if (show_grid)
+ SetOverlayEnabled(TRUE);
+}
+
+boolean GetOverlayActive(void)
+{
+ return overlay.active;
+}
+
void SetDrawDeactivationMask(int draw_deactivation_mask)
{
gfx.draw_deactivation_mask = draw_deactivation_mask;
}
+int GetDrawDeactivationMask(void)
+{
+ return gfx.draw_deactivation_mask;
+}
+
void SetDrawBackgroundMask(int draw_background_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;
SDLLimitScreenUpdates(enable);
}
+void InitVideoDefaults(void)
+{
+ video.default_depth = 32;
+}
+
void InitVideoDisplay(void)
{
+ if (program.headless)
+ return;
+
SDLInitVideoDisplay();
+#if defined(TARGET_SDL2)
+ SDLSetDisplaySize();
+#endif
}
void CloseVideoDisplay(void)
video.height = height;
video.depth = GetRealDepth(depth);
+ video.screen_width = width;
+ video.screen_height = height;
+ video.screen_xoffset = 0;
+ video.screen_yoffset = 0;
+
video.fullscreen_available = FULLSCREEN_STATUS;
video.fullscreen_enabled = FALSE;
video.frame_delay = 0;
video.frame_delay_value = GAME_FRAME_DELAY;
+ video.shifted_up = FALSE;
+ video.shifted_up_pos = 0;
+ video.shifted_up_pos_last = 0;
+ video.shifted_up_delay = 0;
+ video.shifted_up_delay_value = ONE_SECOND_DELAY / 4;
+
SDLInitVideoBuffer(fullscreen);
- video.initialized = TRUE;
+ video.initialized = !program.headless;
drawto = backbuffer;
}
void ReCreateBitmap(Bitmap **bitmap, int width, int height)
{
+ if (*bitmap != NULL)
+ {
+ /* 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 */
+ width = MAX(width, (*bitmap)->width);
+ height = MAX(height, (*bitmap)->height);
+ }
+
Bitmap *new_bitmap = CreateBitmap(width, height, DEFAULT_DEPTH);
if (*bitmap == NULL)
}
}
-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(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 dst_x_unclipped = dst_x;
int dst_y_unclipped = dst_y;
+ if (program.headless)
+ return;
+
if (src_bitmap == NULL || dst_bitmap == NULL)
return;
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;
}
free(new_bitmap);
}
-static void SetMaskedBitmapSurface(Bitmap *bitmap)
-{
- if (bitmap == NULL)
- return;
-
- SDL_Surface *surface = bitmap->surface;
-
- if (bitmap->surface_masked)
- SDL_FreeSurface(bitmap->surface_masked);
-
- SDL_SetColorKey(surface, SET_TRANSPARENT_PIXEL,
- SDL_MapRGB(surface->format, 0x00, 0x00, 0x00));
-
- if ((bitmap->surface_masked = SDLGetNativeSurface(surface)) == NULL)
- Error(ERR_EXIT, "SDL_DisplayFormat() failed");
-
- SDL_SetColorKey(surface, UNSET_TRANSPARENT_PIXEL, 0);
-}
-
static Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
{
- Bitmap *dst_bitmap = SDLZoomBitmap(src_bitmap, zoom_width, zoom_height);
-
- SetMaskedBitmapSurface(dst_bitmap);
-
- return dst_bitmap;
+ return SDLZoomBitmap(src_bitmap, zoom_width, zoom_height);
}
void ReCreateGameTileSizeBitmap(Bitmap **bitmaps)
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
{
/* event functions */
/* ========================================================================= */
-void InitEventFilter(EventFilter filter_function)
-{
- /* set event filter to filter out certain events */
-#if defined(TARGET_SDL2)
- SDL_SetEventFilter(filter_function, NULL);
-#else
- SDL_SetEventFilter(filter_function);
-#endif
-}
-
boolean PendingEvent(void)
{
return (SDL_PollEvent(NULL) ? TRUE : FALSE);
}
-void NextEvent(Event *event)
+void WaitEvent(Event *event)
{
- SDLNextEvent(event);
+ SDLWaitEvent(event);
}
void PeekEvent(Event *event)
#endif
}
+void CheckQuitEvent(void)
+{
+ if (SDL_QuitRequested())
+ program.exit_function(0);
+}
+
Key GetEventKey(KeyEvent *event, boolean with_modifiers)
{
#if defined(TARGET_SDL2)
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
return HandleKeyModState(KSYM_UNDEFINED, 0);
}
+void StartTextInput(int x, int y, int width, int height)
+{
+#if defined(TARGET_SDL2)
+#if defined(HAS_SCREEN_KEYBOARD)
+ SDL_StartTextInput();
+
+ if (y + height > SCREEN_KEYBOARD_POS(video.height))
+ {
+ video.shifted_up_pos = y + height - SCREEN_KEYBOARD_POS(video.height);
+ video.shifted_up_delay = SDL_GetTicks();
+ video.shifted_up = TRUE;
+ }
+#endif
+#endif
+}
+
+void StopTextInput(void)
+{
+#if defined(TARGET_SDL2)
+#if defined(HAS_SCREEN_KEYBOARD)
+ SDL_StopTextInput();
+
+ if (video.shifted_up)
+ {
+ video.shifted_up_pos = 0;
+ video.shifted_up_delay = SDL_GetTicks();
+ video.shifted_up = FALSE;
+ }
+#endif
+#endif
+}
+
boolean CheckCloseWindowEvent(ClientMessageEvent *event)
{
if (event->type != EVENT_CLIENTMESSAGE)
/* joystick functions */
/* ========================================================================= */
-void InitJoysticks()
+void InitJoysticks(void)
{
int i;
/* always start with reliable default values */
joystick.status = JOYSTICK_NOT_AVAILABLE;
for (i = 0; i < MAX_PLAYERS; i++)
- joystick.fd[i] = -1; /* joystick device closed */
+ joystick.nr[i] = -1; /* no joystick configured */
SDLInitJoysticks();
}
{
return SDLReadJoystick(nr, x, y, b1, b2);
}
+
+boolean CheckJoystickOpened(int nr)
+{
+ return SDLCheckJoystickOpened(nr);
+}
+
+void ClearJoystickState(void)
+{
+ SDLClearJoystickState();
+}
projects / rocksndiamonds.git / blobdiff