#include <stdarg.h>
-#ifdef __FreeBSD__
+#if defined(PLATFORM_FREEBSD)
#include <machine/joystick.h>
#endif
+#include "libgame/libgame.h"
+
#include "tools.h"
#include "game.h"
#include "events.h"
-#include "sound.h"
-#include "misc.h"
-#include "buttons.h"
#include "joystick.h"
#include "cartoons.h"
#include "network.h"
+#include "tape.h"
-#ifdef MSDOS
+#if defined(PLATFORM_MSDOS)
extern boolean wait_for_vsync;
#endif
if (!redraw_mask)
return;
-
-
- if (1 && game_status == PLAYING)
+ if (global.fps_slowdown && game_status == PLAYING)
{
- static boolean last_frame_skipped = 0;
- int fps_slowdown_factor = 2;
- boolean skip_even_when_not_scrolling = 1;
+ static boolean last_frame_skipped = FALSE;
+ boolean skip_even_when_not_scrolling = TRUE;
boolean just_scrolling = (ScreenMovDir != 0);
- boolean p = 0;
-
- /*
- printf("ScreenMovDir = %d\n", ScreenMovDir);
- */
+ boolean verbose = FALSE;
- /*
- printf("ScreenGfxPos = %d\n", ScreenGfxPos);
- */
-
- if (fps_slowdown_factor > 1 &&
- (FrameCounter % fps_slowdown_factor) &&
+ if (global.fps_slowdown_factor > 1 &&
+ (FrameCounter % global.fps_slowdown_factor) &&
(just_scrolling || skip_even_when_not_scrolling))
{
redraw_mask &= ~REDRAW_MAIN;
- if (p)
- printf("FRAME SKIPPED\n");
+ last_frame_skipped = TRUE;
- last_frame_skipped = 1;
+ if (verbose)
+ printf("FRAME SKIPPED\n");
}
else
{
if (last_frame_skipped)
redraw_mask |= REDRAW_FIELD;
- last_frame_skipped = 0;
+ last_frame_skipped = FALSE;
- if (p)
+ if (verbose)
printf("frame not skipped\n");
}
}
-
-
/* synchronize X11 graphics at this point; if we would synchronize the
display immediately after the buffer switching (after the XFlush),
this could mean that we have to wait for the graphics to complete,
if (redraw_mask & REDRAW_FPS) /* display frames per second */
{
char text[100];
+ char info1[100];
- sprintf(text, "%.1f fps", global.frames_per_second);
- DrawTextExt(window, gc, SX, SY, text, FS_SMALL, FC_YELLOW);
+ sprintf(info1, " (only every %d. frame)", global.fps_slowdown_factor);
+ if (!global.fps_slowdown)
+ info1[0] = '\0';
+
+ sprintf(text, "%.1f fps%s", global.frames_per_second, info1);
+ DrawTextExt(window, SX, SY, text, FS_SMALL, FC_YELLOW);
}
FlushDisplay();
redraw_mask |= REDRAW_FIELD;
}
-int getFontWidth(int font_size, int font_type)
-{
- return (font_size == FS_BIG ? FONT1_XSIZE :
- font_size == FS_MEDIUM ? FONT6_XSIZE :
- font_type == FC_SPECIAL1 ? FONT3_XSIZE :
- font_type == FC_SPECIAL2 ? FONT4_XSIZE :
- font_type == FC_SPECIAL3 ? FONT5_XSIZE :
- FONT2_XSIZE);
-}
-
-int getFontHeight(int font_size, int font_type)
-{
- return (font_size == FS_BIG ? FONT1_YSIZE :
- font_size == FS_MEDIUM ? FONT6_YSIZE :
- font_type == FC_SPECIAL1 ? FONT3_YSIZE :
- font_type == FC_SPECIAL2 ? FONT4_YSIZE :
- font_type == FC_SPECIAL3 ? FONT5_YSIZE :
- FONT2_YSIZE);
-}
-
-void DrawInitText(char *text, int ypos, int color)
-{
- if (window && pix[PIX_SMALLFONT])
- {
- ClearRectangle(window, 0, ypos, WIN_XSIZE, FONT2_YSIZE);
- DrawTextExt(window, gc, (WIN_XSIZE - strlen(text) * FONT2_XSIZE)/2,
- ypos, text, FS_SMALL, color);
- FlushDisplay();
- }
-}
-
-void DrawTextFCentered(int y, int font_type, char *format, ...)
+void MarkTileDirty(int x, int y)
{
- char buffer[FULL_SXSIZE / FONT5_XSIZE + 10];
- int font_width = getFontWidth(FS_SMALL, font_type);
- va_list ap;
+ int xx = redraw_x1 + x;
+ int yy = redraw_y1 + y;
- va_start(ap, format);
- vsprintf(buffer, format, ap);
- va_end(ap);
+ if (!redraw[xx][yy])
+ redraw_tiles++;
- DrawText(SX + (SXSIZE - strlen(buffer) * font_width) / 2, SY + y,
- buffer, FS_SMALL, font_type);
+ redraw[xx][yy] = TRUE;
+ redraw_mask |= REDRAW_TILES;
}
-void DrawTextF(int x, int y, int font_type, char *format, ...)
+void SetBorderElement()
{
- char buffer[FULL_SXSIZE / FONT5_XSIZE + 10];
- va_list ap;
-
- va_start(ap, format);
- vsprintf(buffer, format, ap);
- va_end(ap);
-
- DrawText(SX + x, SY + y, buffer, FS_SMALL, font_type);
-}
-
-void DrawText(int x, int y, char *text, int font_size, int font_type)
-{
- DrawTextExt(drawto, gc, x, y, text, font_size, font_type);
-
- if (x < DX)
- redraw_mask |= REDRAW_FIELD;
- else if (y < VY)
- redraw_mask |= REDRAW_DOOR_1;
-}
-
-void DrawTextExt(DrawBuffer d, GC gc, int x, int y,
- char *text, int font_size, int font_type)
-{
- int font_width, font_height, font_start;
- int font_bitmap;
- boolean print_inverse = FALSE;
-
- if (font_size != FS_SMALL && font_size != FS_BIG && font_size != FS_MEDIUM)
- font_size = FS_SMALL;
- if (font_type < FC_RED || font_type > FC_SPECIAL3)
- font_type = FC_RED;
-
- font_width = getFontWidth(font_size, font_type);
- font_height = getFontHeight(font_size, font_type);
-
- font_bitmap = (font_size == FS_BIG ? PIX_BIGFONT :
- font_size == FS_MEDIUM ? PIX_MEDIUMFONT :
- PIX_SMALLFONT);
- font_start = (font_type * (font_size == FS_BIG ? FONT1_YSIZE :
- font_size == FS_MEDIUM ? FONT6_YSIZE :
- FONT2_YSIZE) *
- FONT_LINES_PER_FONT);
+ int x, y;
- if (font_type == FC_SPECIAL3)
- font_start += (FONT4_YSIZE - FONT2_YSIZE) * FONT_LINES_PER_FONT;
+ BorderElement = EL_LEERRAUM;
- while (*text)
+ for(y=0; y<lev_fieldy && BorderElement == EL_LEERRAUM; y++)
{
- char c = *text++;
-
- if (c == '~' && font_size == FS_SMALL)
+ for(x=0; x<lev_fieldx; x++)
{
- print_inverse = TRUE;
- continue;
- }
-
- if (c >= 'a' && c <= 'z')
- c = 'A' + (c - 'a');
- else if (c == 'ä' || c == 'Ä')
- c = 91;
- else if (c == 'ö' || c == 'Ö')
- c = 92;
- else if (c == 'ü' || c == 'Ü')
- c = 93;
+ if (!IS_MASSIVE(Feld[x][y]))
+ BorderElement = EL_BETON;
- if (c >= 32 && c <= 95)
- {
- int src_x = ((c - 32) % FONT_CHARS_PER_LINE) * font_width;
- int src_y = ((c - 32) / FONT_CHARS_PER_LINE) * font_height + font_start;
- int dest_x = x, dest_y = y;
-
- if (print_inverse)
- {
- BlitBitmap(pix[font_bitmap], d,
- FONT_CHARS_PER_LINE * font_width,
- 3 * font_height + font_start,
- font_width, font_height, x, y);
-
- SetClipOrigin(clip_gc[font_bitmap], dest_x - src_x, dest_y - src_y);
- BlitBitmapMasked(pix_masked[font_bitmap], d,
- 0, 0, font_width, font_height, dest_x, dest_y);
- }
- else
- BlitBitmap(pix[font_bitmap], d,
- src_x, src_y, font_width, font_height, dest_x, dest_y);
+ if (y != 0 && y != lev_fieldy - 1 && x != lev_fieldx - 1)
+ x = lev_fieldx - 2;
}
-
- x += font_width;
}
}
}
#endif
- DrawGraphicExt(drawto_field, gc, FX + x*TILEX, FY + y*TILEY, graphic);
+ DrawGraphicExt(drawto_field, FX + x*TILEX, FY + y*TILEY, graphic);
MarkTileDirty(x,y);
}
-void DrawGraphicExt(DrawBuffer d, GC gc, int x, int y, int graphic)
+void DrawGraphicExt(DrawBuffer bitmap, int x, int y, int graphic)
{
int bitmap_nr;
int src_x, src_y;
getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y);
- BlitBitmap(pix[bitmap_nr], d, src_x, src_y, TILEX, TILEY, x, y);
+ BlitBitmap(pix[bitmap_nr], bitmap, src_x, src_y, TILEX, TILEY, x, y);
}
void DrawGraphicThruMask(int x, int y, int graphic)
return;
getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y);
- src_bitmap = pix_masked[bitmap_nr];
- drawing_gc = clip_gc[bitmap_nr];
+ src_bitmap = pix[bitmap_nr];
+ drawing_gc = pix[bitmap_nr]->stored_clip_gc;
if (tile_clipmask[tile] != None)
{
- SetClipMask(tile_clip_gc, tile_clipmask[tile]);
- SetClipOrigin(tile_clip_gc, dest_x, dest_y);
+ SetClipMask(src_bitmap, tile_clip_gc, tile_clipmask[tile]);
+ SetClipOrigin(src_bitmap, tile_clip_gc, dest_x, dest_y);
BlitBitmapMasked(src_bitmap, d,
src_x, src_y, TILEX, TILEY, dest_x, dest_y);
}
else
{
#if DEBUG
-#ifndef USE_SDL_LIBRARY
+#ifndef TARGET_SDL
printf("DrawGraphicThruMask(): tile '%d' needs clipping!\n", tile);
#endif
#endif
- SetClipOrigin(drawing_gc, dest_x-src_x, dest_y-src_y);
+ SetClipOrigin(src_bitmap, drawing_gc, dest_x-src_x, dest_y-src_y);
BlitBitmapMasked(src_bitmap, d,
src_x, src_y, TILEX, TILEY, dest_x, dest_y);
}
void DrawMiniGraphic(int x, int y, int graphic)
{
- DrawMiniGraphicExt(drawto,gc, SX + x*MINI_TILEX, SY + y*MINI_TILEY, graphic);
+ DrawMiniGraphicExt(drawto, SX + x*MINI_TILEX, SY + y*MINI_TILEY, graphic);
MarkTileDirty(x/2, y/2);
}
}
}
-void DrawMiniGraphicExt(DrawBuffer d, GC gc, int x, int y, int graphic)
+void DrawMiniGraphicExt(DrawBuffer d, int x, int y, int graphic)
{
Bitmap bitmap;
int src_x, src_y;
int src_x, src_y, dest_x, dest_y;
int tile = graphic;
int bitmap_nr;
+ Bitmap src_bitmap;
GC drawing_gc;
if (graphic < 0)
}
getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y);
- drawing_gc = clip_gc[bitmap_nr];
+ src_bitmap = pix[bitmap_nr];
+ drawing_gc = pix[bitmap_nr]->stored_clip_gc;
src_x += cx;
src_y += cy;
{
if (tile_clipmask[tile] != None)
{
- SetClipMask(tile_clip_gc, tile_clipmask[tile]);
- SetClipOrigin(tile_clip_gc, dest_x, dest_y);
- BlitBitmapMasked(pix_masked[bitmap_nr], drawto_field,
+ SetClipMask(src_bitmap, tile_clip_gc, tile_clipmask[tile]);
+ SetClipOrigin(src_bitmap, tile_clip_gc, dest_x, dest_y);
+ BlitBitmapMasked(src_bitmap, drawto_field,
src_x, src_y, TILEX, TILEY, dest_x, dest_y);
}
else
{
#if DEBUG
-#ifndef USE_SDL_LIBRARY
+#ifndef TARGET_SDL
printf("DrawGraphicShifted(): tile '%d' needs clipping!\n", tile);
#endif
#endif
- SetClipOrigin(drawing_gc, dest_x - src_x, dest_y - src_y);
- BlitBitmapMasked(pix_masked[bitmap_nr], drawto_field,
+ SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y);
+ BlitBitmapMasked(src_bitmap, drawto_field,
src_x, src_y, width, height, dest_x, dest_y);
}
}
int mx, my, ty, result = -1;
unsigned int old_door_state;
-#if !defined(MSDOS) && !defined(WIN32)
+#if defined(PLATFORM_UNIX)
/* pause network game while waiting for request to answer */
if (options.network &&
game_status == PLAYING &&
}
sprintf(txt, text);
txt[tl] = 0;
- DrawTextExt(drawto, gc,
- DX + 51 - (tl * 14)/2, DY + 8 + ty * 16,
+ DrawTextExt(drawto, DX + 51 - (tl * 14)/2, DY + 8 + ty * 16,
txt, FS_SMALL, FC_YELLOW);
text += tl + (tc == 32 ? 1 : 0);
}
case EVENT_KEYPRESS:
switch(GetEventKey((KeyEvent *)&event, TRUE))
{
- case KEY_Return:
+ case KSYM_Return:
result = 1;
break;
- case KEY_Escape:
+ case KSYM_Escape:
result = 0;
break;
RemapAllGadgets();
-#if !defined(MSDOS) && !defined(WIN32)
+#if defined(PLATFORM_UNIX)
/* continue network game after request */
if (options.network &&
game_status == PLAYING &&
for(x=start; x<=DXSIZE; x+=stepsize)
{
+ Bitmap bitmap = pix[PIX_DOOR];
+ GC gc = bitmap->stored_clip_gc;
+
WaitUntilDelayReached(&door_delay, door_delay_value);
if (door_state & DOOR_ACTION_1)
ClearRectangle(drawto, DX, DY + DYSIZE - i/2, DXSIZE,i/2);
- SetClipOrigin(clip_gc[PIX_DOOR], DX - i, (DY + j) - DOOR_GFX_PAGEY1);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE, DOOR_GFX_PAGEY1, i, 77,
DX + DXSIZE - i, DY + j);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE, DOOR_GFX_PAGEY1 + 140, i, 63,
DX + DXSIZE - i, DY + 140 + j);
- SetClipOrigin(clip_gc[PIX_DOOR],
- DX - DXSIZE + i, DY - (DOOR_GFX_PAGEY1 + j));
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ SetClipOrigin(bitmap, gc, DX - DXSIZE + i, DY - (DOOR_GFX_PAGEY1 + j));
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE - i, DOOR_GFX_PAGEY1 + j, i, 77 - j,
DX, DY);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE-i, DOOR_GFX_PAGEY1 + 140, i, 63,
DX, DY + 140 - j);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE - i, DOOR_GFX_PAGEY1 + 77, i, 63,
DX, DY + 77 - j);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE - i, DOOR_GFX_PAGEY1 + 203, i, 77,
DX, DY + 203 - j);
- SetClipOrigin(clip_gc[PIX_DOOR], DX - i, (DY + j) - DOOR_GFX_PAGEY1);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ SetClipOrigin(bitmap, gc, DX - i, (DY + j) - DOOR_GFX_PAGEY1);
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE, DOOR_GFX_PAGEY1 + 77, i, 63,
DX + DXSIZE - i, DY + 77 + j);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ BlitBitmapMasked(bitmap, drawto,
DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j,
DX + DXSIZE - i, DY + 203 + j);
ClearRectangle(drawto, VX, VY + VYSIZE-i/2, VXSIZE, i/2);
- SetClipOrigin(clip_gc[PIX_DOOR], VX - i, (VY + j) - DOOR_GFX_PAGEY2);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
+ BlitBitmapMasked(bitmap, drawto,
VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2,
VX + VXSIZE-i, VY+j);
- SetClipOrigin(clip_gc[PIX_DOOR],
+ SetClipOrigin(bitmap, gc,
VX - VXSIZE + i, VY - (DOOR_GFX_PAGEY2 + j));
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ BlitBitmapMasked(bitmap, drawto,
VXSIZE - i, DOOR_GFX_PAGEY2 + j, i, VYSIZE / 2 - j,
VX, VY);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ BlitBitmapMasked(bitmap, drawto,
VXSIZE - i, DOOR_GFX_PAGEY2 + VYSIZE / 2,
i, VYSIZE / 2, VX, VY + VYSIZE / 2 - j);
- SetClipOrigin(clip_gc[PIX_DOOR], VX - i, (VY + j) - DOOR_GFX_PAGEY2);
- BlitBitmapMasked(pix_masked[PIX_DOOR], drawto,
+ SetClipOrigin(bitmap, gc, VX - i, (VY + j) - DOOR_GFX_PAGEY2);
+ BlitBitmapMasked(bitmap, drawto,
VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2,
i, VYSIZE / 2 - j,
VX + VXSIZE - i, VY + VYSIZE / 2 + j);
redraw_mask |= REDRAW_ALL;
}
-#ifndef USE_SDL_LIBRARY
-int ReadPixel(DrawBuffer d, int x, int y)
+#ifndef TARGET_SDL
+int ReadPixel(DrawBuffer bitmap, int x, int y)
{
XImage *pixel_image;
unsigned long pixel_value;
- pixel_image = XGetImage(display, d, x, y, 1, 1, AllPlanes, ZPixmap);
+ pixel_image = XGetImage(display, bitmap->drawable,
+ x, y, 1, 1, AllPlanes, ZPixmap);
pixel_value = XGetPixel(pixel_image, 0, 0);
XDestroyImage(pixel_image);
}
};
+#if 0
static void DoNotDisplayInfoText(void *ptr)
{
return;
}
+#endif
void CreateToolButtons()
{
GDI_DECORATION_SIZE, MINI_TILEX, MINI_TILEY,
GDI_DECORATION_SHIFTING, 1, 1,
GDI_EVENT_MASK, event_mask,
- GDI_CALLBACK_ACTION, HandleToolButtons,
+
+#if 0
GDI_CALLBACK_INFO, DoNotDisplayInfoText,
+#endif
+
+ GDI_CALLBACK_ACTION, HandleToolButtons,
GDI_END);
if (gi == NULL)