/***********************************************************
* Artsoft Retro-Game Library *
*----------------------------------------------------------*
-* (c) 1994-2001 Artsoft Entertainment *
+* (c) 1994-2002 Artsoft Entertainment *
* Holger Schemel *
* Detmolder Strasse 189 *
* 33604 Bielefeld *
struct VideoSystemInfo video;
struct AudioSystemInfo audio;
struct GfxInfo gfx;
+struct FontInfo font;
+struct AnimInfo anim;
struct ArtworkInfo artwork;
struct JoystickInfo joystick;
struct SetupInfo setup;
#if !defined(PLATFORM_UNIX)
program.userdata_directory = "userdata";
+#endif
+
+#if defined(PLATFORM_MSDOS)
initErrorFile();
#endif
void ClosePlatformDependantStuff(void)
{
-#if !defined(PLATFORM_UNIX)
+#if defined(PLATFORM_MSDOS)
dumpErrorFile();
#endif
}
gfx.full_sxsize = full_sxsize;
gfx.full_sysize = full_sysize;
+ gfx.background_bitmap = NULL;
+ gfx.background_bitmap_mask = REDRAW_NONE;
+
SetDrawDeactivationMask(REDRAW_NONE); /* do not deactivate drawing */
+ SetDrawBackgroundMask(REDRAW_NONE); /* deactivate masked drawing */
}
void InitGfxDoor1Info(int dx, int dy, int dxsize, int dysize)
gfx.draw_deactivation_mask = draw_deactivation_mask;
}
+void SetDrawBackgroundMask(int draw_background_mask)
+{
+ gfx.draw_background_mask = draw_background_mask;
+}
+
+static void DrawBitmapFromTile(Bitmap *bitmap, Bitmap *tile,
+ int dest_x, int dest_y, int width, int height)
+{
+ int bitmap_xsize = width;
+ int bitmap_ysize = height;
+ int tile_xsize = tile->width;
+ int tile_ysize = tile->height;
+ int tile_xsteps = (bitmap_xsize + tile_xsize - 1) / tile_xsize;
+ int tile_ysteps = (bitmap_ysize + tile_ysize - 1) / tile_ysize;
+ int x, y;
+
+ for (y=0; y < tile_ysteps; y++)
+ {
+ for (x=0; x < tile_xsteps; x++)
+ {
+ int draw_x = dest_x + x * tile_xsize;
+ int draw_y = dest_y + y * tile_ysize;
+ int draw_xsize = MIN(tile_xsize, bitmap_xsize - x * tile_xsize);
+ int draw_ysize = MIN(tile_ysize, bitmap_ysize - y * tile_ysize);
+
+ BlitBitmap(tile, bitmap, 0, 0, draw_xsize, draw_ysize, draw_x, draw_y);
+ }
+ }
+}
+
+void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
+{
+ static Bitmap *main_bitmap_tile = NULL;
+ static Bitmap *door_bitmap_tile = NULL;
+
+ if (mask == REDRAW_FIELD)
+ {
+ if (background_bitmap_tile == main_bitmap_tile)
+ return; /* main background tile has not changed */
+
+ main_bitmap_tile = background_bitmap_tile;
+ }
+ else if (mask == REDRAW_DOOR_1)
+ {
+ if (background_bitmap_tile == door_bitmap_tile)
+ return; /* main background tile has not changed */
+
+ door_bitmap_tile = background_bitmap_tile;
+ }
+ else /* should not happen */
+ return;
+
+ if (background_bitmap_tile)
+ gfx.background_bitmap_mask |= mask;
+ else
+ gfx.background_bitmap_mask &= ~mask;
+
+ if (gfx.background_bitmap == NULL)
+ gfx.background_bitmap = CreateBitmap(video.width, video.height,
+ DEFAULT_DEPTH);
+
+ if (background_bitmap_tile == NULL) /* empty background requested */
+ return;
+
+ if (mask == REDRAW_FIELD)
+ DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
+ gfx.real_sx, gfx.real_sy,
+ gfx.full_sxsize, gfx.full_sysize);
+ else
+ DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
+ gfx.dx, gfx.dy,
+ gfx.dxsize, gfx.dysize);
+}
+
+void SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
+{
+ SetBackgroundBitmap(background_bitmap_tile, REDRAW_FIELD);
+}
+
+void SetDoorBackgroundBitmap(Bitmap *background_bitmap_tile)
+{
+ SetBackgroundBitmap(background_bitmap_tile, REDRAW_DOOR_1);
+}
+
/* ========================================================================= */
/* video functions */
new_bitmap->line_gc[1] = window->line_gc[1];
#endif
+ new_bitmap->width = width;
+ new_bitmap->height = height;
+
return new_bitmap;
}
bitmap->surface_masked = NULL;
#else
/* The X11 version seems to have a memory leak here -- although
- "XFreePixmap()" is called, the correspondig memory seems not
+ "XFreePixmap()" is called, the corresponding memory seems not
to be freed (according to "ps"). The SDL version apparently
does not have this problem. */
#endif
}
-inline boolean DrawingDeactivated(int x, int y, int width, int height)
+static inline boolean CheckDrawingArea(int x, int y, int width, int height,
+ int draw_mask)
{
- if (gfx.draw_deactivation_mask != REDRAW_NONE)
- {
- if ((gfx.draw_deactivation_mask & REDRAW_FIELD) &&
- x < gfx.sx + gfx.sxsize)
- return TRUE;
- else if ((gfx.draw_deactivation_mask & REDRAW_DOORS) &&
- x > gfx.dx)
- {
- if ((gfx.draw_deactivation_mask & REDRAW_DOOR_1) &&
- y < gfx.dy + gfx.dysize)
- return TRUE;
- else if ((gfx.draw_deactivation_mask & REDRAW_DOOR_2) &&
- y > gfx.vy)
- return TRUE;
- }
- }
+ if (draw_mask == REDRAW_NONE)
+ return FALSE;
+
+ if (draw_mask & REDRAW_ALL)
+ return TRUE;
+
+ if ((draw_mask & REDRAW_FIELD) && x < gfx.real_sx + gfx.full_sxsize)
+ return TRUE;
+
+ if ((draw_mask & REDRAW_DOOR_1) && x >= gfx.dx && y < gfx.dy + gfx.dysize)
+ return TRUE;
+
+ if ((draw_mask & REDRAW_DOOR_2) && x >= gfx.dx && y >= gfx.vy)
+ return TRUE;
return FALSE;
}
+inline boolean DrawingDeactivated(int x, int y, int width, int height)
+{
+ return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
+}
+
+inline boolean DrawingOnBackground(int x, int y)
+{
+ return ((gfx.draw_background_mask & gfx.background_bitmap_mask) &&
+ CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
+}
+
inline void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
int src_x, int src_y,
int width, int height,
#endif
}
+inline void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
+ int width, int height)
+{
+ if (DrawingOnBackground(x, y))
+ BlitBitmap(gfx.background_bitmap, bitmap, x, y, width, height, x, y);
+ else
+ ClearRectangle(bitmap, x, y, width, height);
+}
+
#if 0
#ifndef TARGET_SDL
static GC last_clip_gc = 0; /* needed for XCopyArea() through clip mask */
#endif
}
+inline void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y,
+ int width, int height,
+ int dst_x, int dst_y)
+{
+ if (DrawingOnBackground(src_x, src_y))
+ {
+ /* draw background */
+ BlitBitmap(gfx.background_bitmap, dst_bitmap, dst_x, dst_y, width, height,
+ dst_x, dst_y);
+
+ /* draw foreground */
+ SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc,
+ dst_x - src_x, dst_y - src_y);
+ BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+ dst_x, dst_y);
+ }
+ else
+ BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+ dst_x, dst_y);
+}
+
inline void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
int to_x, int to_y)
{
new_bitmap = X11LoadImage(filename);
#endif
- new_bitmap->source_filename = getStringCopy(filename);
+ if (new_bitmap)
+ new_bitmap->source_filename = getStringCopy(filename);
return new_bitmap;
}
if (bitmap->width != new_bitmap->width ||
bitmap->height != new_bitmap->height)
{
- Error(ERR_WARN, "ReloadCustomImage: new image has wrong dimensions");
+ Error(ERR_WARN, "ReloadCustomImage: new image '%s' has wrong dimensions",
+ filename);
FreeBitmap(new_bitmap);
return;
}
free(new_bitmap);
}
+Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
+{
+ Bitmap *dst_bitmap = CreateBitmap(zoom_width, zoom_height, DEFAULT_DEPTH);
+
+#if defined(TARGET_SDL)
+ SDLZoomBitmap(src_bitmap, dst_bitmap);
+#else
+ X11ZoomBitmap(src_bitmap, dst_bitmap);
+#endif
+
+ return dst_bitmap;
+}
+
+void CreateBitmapWithSmallBitmaps(Bitmap *src_bitmap)
+{
+ Bitmap *tmp_bitmap, *tmp_bitmap_2, *tmp_bitmap_8;
+ int src_width, src_height;
+ int tmp_width, tmp_height;
+
+ src_width = src_bitmap->width;
+ src_height = src_bitmap->height;
+
+ tmp_width = src_width;
+ tmp_height = src_height + src_height / 2;
+
+ tmp_bitmap = CreateBitmap(tmp_width, tmp_height, DEFAULT_DEPTH);
+
+ tmp_bitmap_2 = ZoomBitmap(src_bitmap, src_width / 2, src_height / 2);
+ tmp_bitmap_8 = ZoomBitmap(src_bitmap, src_width / 8, src_height / 8);
+
+ BlitBitmap(src_bitmap, tmp_bitmap, 0, 0, src_width, src_height, 0, 0);
+ BlitBitmap(tmp_bitmap_2, tmp_bitmap, 0, 0, src_width / 2, src_height / 2,
+ 0, src_height);
+ BlitBitmap(tmp_bitmap_8, tmp_bitmap, 0, 0, src_width / 8, src_height / 8,
+ 3 * src_width / 4, src_height);
+
+ FreeBitmap(tmp_bitmap_2);
+ FreeBitmap(tmp_bitmap_8);
+
+#ifdef TARGET_SDL
+ src_bitmap->surface = tmp_bitmap->surface;
+ tmp_bitmap->surface = NULL;
+#else
+ src_bitmap->drawable = tmp_bitmap->drawable;
+ tmp_bitmap->drawable = None;
+#endif
+
+ src_bitmap->height = tmp_bitmap->height;
+
+ FreeBitmap(tmp_bitmap);
+}
+
/* ========================================================================= */
/* audio functions */
audio.sound_available = FALSE;
audio.music_available = FALSE;
audio.loops_available = FALSE;
- audio.mods_available = FALSE;
- audio.sound_enabled = FALSE;
+ audio.sound_enabled = FALSE;
audio.sound_deactivated = FALSE;
- audio.soundserver_pipe[0] = audio.soundserver_pipe[1] = 0;
- audio.soundserver_pid = -1;
+ audio.mixer_pipe[0] = audio.mixer_pipe[1] = 0;
+ audio.mixer_pid = 0;
audio.device_name = NULL;
- audio.device_fd = 0;
+ audio.device_fd = -1;
- audio.channels = 0;
+ audio.num_channels = 0;
audio.music_channel = 0;
- audio.music_nr = 0;
+ audio.first_sound_channel = 0;
#if defined(TARGET_SDL)
SDLOpenAudio();
(int)SDL_GetModState());
#endif
- if (with_modifiers && event->keysym.unicode != 0)
+ if (with_modifiers &&
+ event->keysym.unicode > 0x0000 &&
+ event->keysym.unicode < 0x2000)
return event->keysym.unicode;
else
return event->keysym.sym;
projects / rocksndiamonds.git / blobdiff