X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=3bf2c5a5ad9644c6587e4a4b1655528ff763a7e9;hb=b9c7e4a42762c8526702726f1404d3e75dbc29f5;hp=41fd86eb12a560033ca6864d414deb58862f4cbe;hpb=2fe139696892ee39f804b5c7315b8f0977ab01ec;p=rocksndiamonds.git diff --git a/src/tools.c b/src/tools.c index 41fd86eb..3bf2c5a5 100644 --- a/src/tools.c +++ b/src/tools.c @@ -44,6 +44,8 @@ extern boolean wait_for_vsync; /* forward declaration for internal use */ static int getGraphicAnimationPhase(int, int, int); +static void DrawGraphicAnimationShiftedThruMask(int, int, int, int, int, + int, int, int); static void UnmapToolButtons(); static void HandleToolButtons(struct GadgetInfo *); @@ -83,7 +85,7 @@ void SetDrawtoField(int mode) void BackToFront() { int x,y; - Drawable buffer = (drawto_field == window ? backbuffer : drawto_field); + DrawBuffer buffer = (drawto_field == window ? backbuffer : drawto_field); if (setup.direct_draw && game_status == PLAYING) redraw_mask &= ~REDRAW_MAIN; @@ -102,13 +104,11 @@ void BackToFront() this could mean that we have to wait for the graphics to complete, although we could go on doing calculations for the next frame */ - XSync(display, FALSE); + SyncDisplay(); if (redraw_mask & REDRAW_ALL) { - XCopyArea(display, backbuffer, window, gc, - 0, 0, WIN_XSIZE, WIN_YSIZE, - 0, 0); + BlitBitmap(backbuffer, window, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0); redraw_mask = 0; } @@ -116,9 +116,8 @@ void BackToFront() { if (game_status != PLAYING || redraw_mask & REDRAW_FROM_BACKBUFFER) { - XCopyArea(display, backbuffer, window, gc, - REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, - REAL_SX, REAL_SY); + BlitBitmap(backbuffer, window, + REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY); } else { @@ -135,7 +134,7 @@ void BackToFront() ABS(ScreenMovPos) == ScrollStepSize || redraw_tiles > REDRAWTILES_THRESHOLD) { - XCopyArea(display, buffer, window, gc, fx, fy, SXSIZE, SYSIZE, SX, SY); + BlitBitmap(buffer, window, fx, fy, SXSIZE, SYSIZE, SX, SY); #ifdef DEBUG #if 0 @@ -158,49 +157,43 @@ void BackToFront() if (redraw_mask & REDRAW_DOORS) { if (redraw_mask & REDRAW_DOOR_1) - XCopyArea(display, backbuffer, window, gc, - DX, DY, DXSIZE, DYSIZE, - DX, DY); + BlitBitmap(backbuffer, window, DX, DY, DXSIZE, DYSIZE, DX, DY); if (redraw_mask & REDRAW_DOOR_2) { if ((redraw_mask & REDRAW_DOOR_2) == REDRAW_DOOR_2) - XCopyArea(display,backbuffer,window,gc, - VX,VY, VXSIZE,VYSIZE, - VX,VY); + BlitBitmap(backbuffer, window, VX,VY, VXSIZE,VYSIZE, VX,VY); else { if (redraw_mask & REDRAW_VIDEO_1) - XCopyArea(display,backbuffer,window,gc, - VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS, - VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE, - VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS); + BlitBitmap(backbuffer, window, + VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS, + VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE, + VX+VIDEO_DISPLAY1_XPOS,VY+VIDEO_DISPLAY1_YPOS); if (redraw_mask & REDRAW_VIDEO_2) - XCopyArea(display,backbuffer,window,gc, - VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS, - VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE, - VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS); + BlitBitmap(backbuffer, window, + VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS, + VIDEO_DISPLAY_XSIZE,VIDEO_DISPLAY_YSIZE, + VX+VIDEO_DISPLAY2_XPOS,VY+VIDEO_DISPLAY2_YPOS); if (redraw_mask & REDRAW_VIDEO_3) - XCopyArea(display,backbuffer,window,gc, - VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS, - VIDEO_CONTROL_XSIZE,VIDEO_CONTROL_YSIZE, - VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS); + BlitBitmap(backbuffer, window, + VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS, + VIDEO_CONTROL_XSIZE,VIDEO_CONTROL_YSIZE, + VX+VIDEO_CONTROL_XPOS,VY+VIDEO_CONTROL_YPOS); } } if (redraw_mask & REDRAW_DOOR_3) - XCopyArea(display, backbuffer, window, gc, - EX, EY, EXSIZE, EYSIZE, - EX, EY); + BlitBitmap(backbuffer, window, EX, EY, EXSIZE, EYSIZE, EX, EY); redraw_mask &= ~REDRAW_DOORS; } if (redraw_mask & REDRAW_MICROLEVEL) { - XCopyArea(display,backbuffer,window,gc, - MICROLEV_XPOS, MICROLEV_YPOS, MICROLEV_XSIZE, MICROLEV_YSIZE, - MICROLEV_XPOS, MICROLEV_YPOS); - XCopyArea(display,backbuffer,window,gc, - SX, MICROLABEL_YPOS, SXSIZE, FONT4_YSIZE, - SX, MICROLABEL_YPOS); + BlitBitmap(backbuffer, window, + MICROLEV_XPOS, MICROLEV_YPOS, MICROLEV_XSIZE, MICROLEV_YSIZE, + MICROLEV_XPOS, MICROLEV_YPOS); + BlitBitmap(backbuffer, window, + SX, MICROLABEL_YPOS, SXSIZE, FONT4_YSIZE, + SX, MICROLABEL_YPOS); redraw_mask &= ~REDRAW_MICROLEVEL; } @@ -209,12 +202,12 @@ void BackToFront() for(x=0; x FC_SPECIAL3) font_type = FC_RED; @@ -383,8 +390,12 @@ void DrawTextExt(Drawable d, GC gc, int x, int y, font_width = getFontWidth(font_size, font_type); font_height = getFontHeight(font_size, font_type); - font_pixmap = (font_size == FS_BIG ? PIX_BIGFONT : PIX_SMALLFONT); - font_start = (font_type * (font_size == FS_BIG ? FONT1_YSIZE : FONT2_YSIZE) * + 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); if (font_type == FC_SPECIAL3) @@ -417,19 +428,18 @@ void DrawTextExt(Drawable d, GC gc, int x, int y, if (print_inverse) { - XCopyArea(display, pix[font_pixmap], d, gc, - FONT_CHARS_PER_LINE * font_width, - 3 * font_height + font_start, - font_width, font_height, x, y); - - XSetClipOrigin(display, clip_gc[font_pixmap], - dest_x - src_x, dest_y - src_y); - XCopyArea(display, pix[font_pixmap], d, clip_gc[font_pixmap], - 0, 0, font_width, font_height, dest_x, dest_y); + 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 - XCopyArea(display, pix[font_pixmap], d, gc, - src_x, src_y, font_width, font_height, dest_x, dest_y); + BlitBitmap(pix[font_bitmap], d, + src_x, src_y, font_width, font_height, dest_x, dest_y); } x += font_width; @@ -567,6 +577,8 @@ void DrawPlayer(struct PlayerInfo *player) graphic = GFX_MURPHY_GO_LEFT; else if (player->MovDir & (MV_UP | MV_DOWN) && last_dir == MV_RIGHT) graphic = GFX_MURPHY_GO_RIGHT; + else + graphic = GFX_MURPHY_GO_LEFT; graphic += getGraphicAnimationPhase(3, 2, ANIM_OSCILLATE); } @@ -604,6 +616,15 @@ void DrawPlayer(struct PlayerInfo *player) DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic, NO_CUTTING); + if (SHIELD_ON(player)) + { + int graphic = (player->shield_active_time_left ? GFX2_SHIELD_ACTIVE : + GFX2_SHIELD_PASSIVE); + + DrawGraphicAnimationShiftedThruMask(sx, sy, sxx, syy, graphic, + 3, 8, ANIM_OSCILLATE); + } + if (player->Pushing && player->GfxPos) { int px = SCREENX(next_jx), py = SCREENY(next_jy); @@ -617,7 +638,9 @@ void DrawPlayer(struct PlayerInfo *player) int element = Feld[next_jx][next_jy]; int graphic = el2gfx(element); - if ((element == EL_FELSBROCKEN || element == EL_SP_ZONK) && sxx) + if ((element == EL_FELSBROCKEN || + element == EL_SP_ZONK || + element == EL_BD_ROCK) && sxx) { int phase = (player->GfxPos / (TILEX / 4)); @@ -679,8 +702,8 @@ void DrawPlayer(struct PlayerInfo *player) int x_size = TILEX * (1 + ABS(jx - last_jx)); int y_size = TILEY * (1 + ABS(jy - last_jy)); - XCopyArea(display, drawto_field, window, gc, - dest_x, dest_y, x_size, y_size, dest_x, dest_y); + BlitBitmap(drawto_field, window, + dest_x, dest_y, x_size, y_size, dest_x, dest_y); SetDrawtoField(DRAW_DIRECT); } @@ -732,47 +755,65 @@ void DrawGraphicAnimationThruMask(int x, int y, int graphic, DrawGraphicAnimationExt(x, y, graphic, frames, delay, mode, USE_MASKING); } -void getGraphicSource(int graphic, int *pixmap_nr, int *x, int *y) +static void DrawGraphicAnimationShiftedThruMask(int sx, int sy, + int sxx, int syy, + int graphic, + int frames, int delay, + int mode) +{ + int phase = getGraphicAnimationPhase(frames, delay, mode); + + DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic + phase, NO_CUTTING); +} + +void getGraphicSource(int graphic, int *bitmap_nr, int *x, int *y) { if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN) { graphic -= GFX_START_ROCKSSCREEN; - *pixmap_nr = PIX_BACK; + *bitmap_nr = PIX_BACK; *x = SX + (graphic % GFX_PER_LINE) * TILEX; *y = SY + (graphic / GFX_PER_LINE) * TILEY; } else if (graphic >= GFX_START_ROCKSHEROES && graphic <= GFX_END_ROCKSHEROES) { graphic -= GFX_START_ROCKSHEROES; - *pixmap_nr = PIX_HEROES; + *bitmap_nr = PIX_HEROES; *x = (graphic % HEROES_PER_LINE) * TILEX; *y = (graphic / HEROES_PER_LINE) * TILEY; } else if (graphic >= GFX_START_ROCKSSP && graphic <= GFX_END_ROCKSSP) { graphic -= GFX_START_ROCKSSP; - *pixmap_nr = PIX_SP; + *bitmap_nr = PIX_SP; *x = (graphic % SP_PER_LINE) * TILEX; *y = (graphic / SP_PER_LINE) * TILEY; } else if (graphic >= GFX_START_ROCKSDC && graphic <= GFX_END_ROCKSDC) { graphic -= GFX_START_ROCKSDC; - *pixmap_nr = PIX_DC; + *bitmap_nr = PIX_DC; *x = (graphic % DC_PER_LINE) * TILEX; *y = (graphic / DC_PER_LINE) * TILEY; } + else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE) + { + graphic -= GFX_START_ROCKSMORE; + *bitmap_nr = PIX_MORE; + *x = (graphic % MORE_PER_LINE) * TILEX; + *y = (graphic / MORE_PER_LINE) * TILEY; + } else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT) { graphic -= GFX_START_ROCKSFONT; - *pixmap_nr = PIX_BIGFONT; + *bitmap_nr = PIX_BIGFONT; *x = (graphic % FONT_CHARS_PER_LINE) * TILEX; *y = ((graphic / FONT_CHARS_PER_LINE) * TILEY + FC_SPECIAL1 * FONT_LINES_PER_FONT * TILEY); } else { - *pixmap_nr = PIX_SP; + *bitmap_nr = PIX_SP; *x = 0; *y = 0; } @@ -793,14 +834,13 @@ void DrawGraphic(int x, int y, int graphic) MarkTileDirty(x,y); } -void DrawGraphicExt(Drawable d, GC gc, int x, int y, int graphic) +void DrawGraphicExt(DrawBuffer d, GC gc, int x, int y, int graphic) { - int pixmap_nr; + int bitmap_nr; int src_x, src_y; - getGraphicSource(graphic, &pixmap_nr, &src_x, &src_y); - XCopyArea(display, pix[pixmap_nr], d, gc, - src_x, src_y, TILEX, TILEY, x, y); + getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y); + BlitBitmap(pix[bitmap_nr], d, src_x, src_y, TILEX, TILEY, x, y); } void DrawGraphicThruMask(int x, int y, int graphic) @@ -818,37 +858,39 @@ void DrawGraphicThruMask(int x, int y, int graphic) MarkTileDirty(x,y); } -void DrawGraphicThruMaskExt(Drawable d, int dest_x, int dest_y, int graphic) +void DrawGraphicThruMaskExt(DrawBuffer d, int dest_x, int dest_y, int graphic) { int tile = graphic; - int pixmap_nr; + int bitmap_nr; int src_x, src_y; - Pixmap src_pixmap; + Bitmap src_bitmap; GC drawing_gc; if (graphic == GFX_LEERRAUM) return; - getGraphicSource(graphic, &pixmap_nr, &src_x, &src_y); - src_pixmap = pix[pixmap_nr]; - drawing_gc = clip_gc[pixmap_nr]; + getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y); + src_bitmap = pix_masked[bitmap_nr]; + drawing_gc = clip_gc[bitmap_nr]; if (tile_clipmask[tile] != None) { - XSetClipMask(display, tile_clip_gc, tile_clipmask[tile]); - XSetClipOrigin(display, tile_clip_gc, dest_x, dest_y); - XCopyArea(display, src_pixmap, d, tile_clip_gc, - src_x, src_y, TILEX, TILEY, dest_x, dest_y); + SetClipMask(tile_clip_gc, tile_clipmask[tile]); + SetClipOrigin(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 printf("DrawGraphicThruMask(): tile '%d' needs clipping!\n", tile); +#endif #endif - XSetClipOrigin(display, drawing_gc, dest_x-src_x, dest_y-src_y); - XCopyArea(display, src_pixmap, d, drawing_gc, - src_x, src_y, TILEX, TILEY, dest_x, dest_y); + SetClipOrigin(drawing_gc, dest_x-src_x, dest_y-src_y); + BlitBitmapMasked(src_bitmap, d, + src_x, src_y, TILEX, TILEY, dest_x, dest_y); } } @@ -858,12 +900,12 @@ void DrawMiniGraphic(int x, int y, int graphic) MarkTileDirty(x/2, y/2); } -void getMiniGraphicSource(int graphic, Pixmap *pixmap, int *x, int *y) +void getMiniGraphicSource(int graphic, Bitmap *bitmap, int *x, int *y) { if (graphic >= GFX_START_ROCKSSCREEN && graphic <= GFX_END_ROCKSSCREEN) { graphic -= GFX_START_ROCKSSCREEN; - *pixmap = pix[PIX_BACK]; + *bitmap = pix[PIX_BACK]; *x = MINI_GFX_STARTX + (graphic % MINI_GFX_PER_LINE) * MINI_TILEX; *y = MINI_GFX_STARTY + (graphic / MINI_GFX_PER_LINE) * MINI_TILEY; } @@ -871,41 +913,47 @@ void getMiniGraphicSource(int graphic, Pixmap *pixmap, int *x, int *y) { graphic -= GFX_START_ROCKSSP; graphic -= ((graphic / SP_PER_LINE) * SP_PER_LINE) / 2; - *pixmap = pix[PIX_SP]; + *bitmap = pix[PIX_SP]; *x = MINI_SP_STARTX + (graphic % MINI_SP_PER_LINE) * MINI_TILEX; *y = MINI_SP_STARTY + (graphic / MINI_SP_PER_LINE) * MINI_TILEY; } else if (graphic >= GFX_START_ROCKSDC && graphic <= GFX_END_ROCKSDC) { graphic -= GFX_START_ROCKSDC; - *pixmap = pix[PIX_DC]; + *bitmap = pix[PIX_DC]; *x = MINI_DC_STARTX + (graphic % MINI_DC_PER_LINE) * MINI_TILEX; *y = MINI_DC_STARTY + (graphic / MINI_DC_PER_LINE) * MINI_TILEY; } + else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE) + { + graphic -= GFX_START_ROCKSMORE; + *bitmap = pix[PIX_MORE]; + *x = MINI_MORE_STARTX + (graphic % MINI_MORE_PER_LINE) * MINI_TILEX; + *y = MINI_MORE_STARTY + (graphic / MINI_MORE_PER_LINE) * MINI_TILEY; + } else if (graphic >= GFX_START_ROCKSFONT && graphic <= GFX_END_ROCKSFONT) { graphic -= GFX_START_ROCKSFONT; - *pixmap = pix[PIX_SMALLFONT]; + *bitmap = pix[PIX_SMALLFONT]; *x = (graphic % FONT_CHARS_PER_LINE) * FONT4_XSIZE; *y = ((graphic / FONT_CHARS_PER_LINE) * FONT4_YSIZE + FC_SPECIAL2 * FONT2_YSIZE * FONT_LINES_PER_FONT); } else { - *pixmap = pix[PIX_SP]; + *bitmap = pix[PIX_SP]; *x = MINI_SP_STARTX; *y = MINI_SP_STARTY; } } -void DrawMiniGraphicExt(Drawable d, GC gc, int x, int y, int graphic) +void DrawMiniGraphicExt(DrawBuffer d, GC gc, int x, int y, int graphic) { - Pixmap pixmap; + Bitmap bitmap; int src_x, src_y; - getMiniGraphicSource(graphic, &pixmap, &src_x, &src_y); - XCopyArea(display, pixmap, d, gc, - src_x, src_y, MINI_TILEX, MINI_TILEY, x, y); + getMiniGraphicSource(graphic, &bitmap, &src_x, &src_y); + BlitBitmap(bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y); } void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, @@ -915,8 +963,7 @@ void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, int cx = 0, cy = 0; int src_x, src_y, dest_x, dest_y; int tile = graphic; - int pixmap_nr; - Pixmap src_pixmap; + int bitmap_nr; GC drawing_gc; if (graphic < 0) @@ -989,9 +1036,8 @@ void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, MarkTileDirty(x, y + SIGN(dy)); } - getGraphicSource(graphic, &pixmap_nr, &src_x, &src_y); - src_pixmap = pix[pixmap_nr]; - drawing_gc = clip_gc[pixmap_nr]; + getGraphicSource(graphic, &bitmap_nr, &src_x, &src_y); + drawing_gc = clip_gc[bitmap_nr]; src_x += cx; src_y += cy; @@ -1012,25 +1058,27 @@ void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, { if (tile_clipmask[tile] != None) { - XSetClipMask(display, tile_clip_gc, tile_clipmask[tile]); - XSetClipOrigin(display, tile_clip_gc, dest_x, dest_y); - XCopyArea(display, src_pixmap, drawto_field, tile_clip_gc, - src_x, src_y, TILEX, TILEY, dest_x, dest_y); + SetClipMask(tile_clip_gc, tile_clipmask[tile]); + SetClipOrigin(tile_clip_gc, dest_x, dest_y); + BlitBitmapMasked(pix_masked[bitmap_nr], drawto_field, + src_x, src_y, TILEX, TILEY, dest_x, dest_y); } else { #if DEBUG +#ifndef USE_SDL_LIBRARY printf("DrawGraphicShifted(): tile '%d' needs clipping!\n", tile); +#endif #endif - XSetClipOrigin(display, drawing_gc, dest_x - src_x, dest_y - src_y); - XCopyArea(display, src_pixmap, drawto_field, drawing_gc, - src_x, src_y, width, height, dest_x, dest_y); + SetClipOrigin(drawing_gc, dest_x - src_x, dest_y - src_y); + BlitBitmapMasked(pix_masked[bitmap_nr], drawto_field, + src_x, src_y, width, height, dest_x, dest_y); } } else - XCopyArea(display, src_pixmap, drawto_field, gc, - src_x, src_y, width, height, dest_x, dest_y); + BlitBitmap(pix[bitmap_nr], drawto_field, + src_x, src_y, width, height, dest_x, dest_y); MarkTileDirty(x,y); } @@ -1079,23 +1127,23 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, { graphic = GFX2_SP_ELECTRON + getGraphicAnimationPhase(8, 2, ANIM_NORMAL); } - else if (element == EL_MAULWURF || element == EL_PINGUIN || + else if (element == EL_MOLE || element == EL_PINGUIN || element == EL_SCHWEIN || element == EL_DRACHE) { if (dir == MV_LEFT) - graphic = (element == EL_MAULWURF ? GFX_MAULWURF_LEFT : + graphic = (element == EL_MOLE ? GFX_MOLE_LEFT : element == EL_PINGUIN ? GFX_PINGUIN_LEFT : element == EL_SCHWEIN ? GFX_SCHWEIN_LEFT : GFX_DRACHE_LEFT); else if (dir == MV_RIGHT) - graphic = (element == EL_MAULWURF ? GFX_MAULWURF_RIGHT : + graphic = (element == EL_MOLE ? GFX_MOLE_RIGHT : element == EL_PINGUIN ? GFX_PINGUIN_RIGHT : element == EL_SCHWEIN ? GFX_SCHWEIN_RIGHT : GFX_DRACHE_RIGHT); else if (dir == MV_UP) - graphic = (element == EL_MAULWURF ? GFX_MAULWURF_UP : + graphic = (element == EL_MOLE ? GFX_MOLE_UP : element == EL_PINGUIN ? GFX_PINGUIN_UP : element == EL_SCHWEIN ? GFX_SCHWEIN_UP : GFX_DRACHE_UP); else - graphic = (element == EL_MAULWURF ? GFX_MAULWURF_DOWN : + graphic = (element == EL_MOLE ? GFX_MOLE_DOWN : element == EL_PINGUIN ? GFX_PINGUIN_DOWN : element == EL_SCHWEIN ? GFX_SCHWEIN_DOWN : GFX_DRACHE_DOWN); @@ -1113,12 +1161,20 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, { graphic += !phase2; } - else if ((element == EL_FELSBROCKEN || element == EL_SP_ZONK || + else if (element == EL_BALLOON) + { + graphic += phase4; + } + else if ((element == EL_FELSBROCKEN || + element == EL_SP_ZONK || + element == EL_BD_ROCK || IS_GEM(element)) && !cut_mode) { if (uy >= lev_fieldy-1 || !IS_BELT(Feld[ux][uy+1])) { - if (element == EL_FELSBROCKEN || element == EL_SP_ZONK) + if (element == EL_FELSBROCKEN || + element == EL_SP_ZONK || + element == EL_BD_ROCK) { if (dir == MV_LEFT) graphic += (4 - phase4) % 4; @@ -1131,8 +1187,10 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, graphic += phase2; } } - else if (element == EL_SIEB_LEER || element == EL_SIEB2_LEER || - element == EL_SIEB_VOLL || element == EL_SIEB2_VOLL) + else if (element == EL_MAGIC_WALL_EMPTY || + element == EL_MAGIC_WALL_BD_EMPTY || + element == EL_MAGIC_WALL_FULL || + element == EL_MAGIC_WALL_BD_FULL) { graphic += 3 + getGraphicAnimationPhase(4, 4, ANIM_REVERSE); } @@ -1228,7 +1286,10 @@ void ErdreichAnbroeckeln(int x, int y) element = Feld[ux][uy]; - if (element == EL_ERDREICH || element == EL_LANDMINE) + if (element == EL_ERDREICH || + element == EL_LANDMINE || + element == EL_TRAP_INACTIVE || + element == EL_TRAP_ACTIVE) { if (!IN_SCR_FIELD(x, y)) return; @@ -1246,7 +1307,10 @@ void ErdreichAnbroeckeln(int x, int y) else element = Feld[uxx][uyy]; - if (element == EL_ERDREICH || element == EL_LANDMINE) + if (element == EL_ERDREICH || + element == EL_LANDMINE || + element == EL_TRAP_INACTIVE || + element == EL_TRAP_ACTIVE) continue; if (i == 1 || i == 2) @@ -1264,10 +1328,10 @@ void ErdreichAnbroeckeln(int x, int y) cy = (i == 3 ? TILEY - snip : 0); } - XCopyArea(display, pix[PIX_BACK], drawto_field, gc, - SX + (graphic % GFX_PER_LINE) * TILEX + cx, - SY + (graphic / GFX_PER_LINE) * TILEY + cy, - width, height, FX + x * TILEX + cx, FY + y * TILEY + cy); + BlitBitmap(pix[PIX_BACK], drawto_field, + SX + (graphic % GFX_PER_LINE) * TILEX + cx, + SY + (graphic / GFX_PER_LINE) * TILEY + cy, + width, height, FX + x * TILEX + cx, FY + y * TILEY + cy); } MarkTileDirty(x, y); @@ -1286,7 +1350,10 @@ void ErdreichAnbroeckeln(int x, int y) uyy = uy + xy[i][1]; if (!IN_LEV_FIELD(uxx, uyy) || - (Feld[uxx][uyy] != EL_ERDREICH && Feld[uxx][uyy] != EL_LANDMINE) || + (Feld[uxx][uyy] != EL_ERDREICH && + Feld[uxx][uyy] != EL_LANDMINE && + Feld[uxx][uyy] != EL_TRAP_INACTIVE && + Feld[uxx][uyy] != EL_TRAP_ACTIVE) || !IN_SCR_FIELD(xx, yy)) continue; @@ -1305,10 +1372,10 @@ void ErdreichAnbroeckeln(int x, int y) cy = (i==0 ? TILEY-snip : 0); } - XCopyArea(display, pix[PIX_BACK], drawto_field, gc, - SX + (graphic % GFX_PER_LINE) * TILEX + cx, - SY + (graphic / GFX_PER_LINE) * TILEY + cy, - width, height, FX + xx * TILEX + cx, FY + yy * TILEY + cy); + BlitBitmap(pix[PIX_BACK], drawto_field, + SX + (graphic % GFX_PER_LINE) * TILEX + cx, + SY + (graphic / GFX_PER_LINE) * TILEY + cy, + width, height, FX + xx * TILEX + cx, FY + yy * TILEY + cy); MarkTileDirty(xx, yy); } @@ -1351,13 +1418,13 @@ void DrawScreenField(int x, int y) boolean cut_mode = NO_CUTTING; if (Store[ux][uy] == EL_MORAST_LEER || - Store[ux][uy] == EL_SIEB_LEER || - Store[ux][uy] == EL_SIEB2_LEER || + Store[ux][uy] == EL_MAGIC_WALL_EMPTY || + Store[ux][uy] == EL_MAGIC_WALL_BD_EMPTY || Store[ux][uy] == EL_AMOEBE_NASS) cut_mode = CUT_ABOVE; else if (Store[ux][uy] == EL_MORAST_VOLL || - Store[ux][uy] == EL_SIEB_VOLL || - Store[ux][uy] == EL_SIEB2_VOLL) + Store[ux][uy] == EL_MAGIC_WALL_FULL || + Store[ux][uy] == EL_MAGIC_WALL_BD_FULL) cut_mode = CUT_BELOW; if (cut_mode == CUT_ABOVE) @@ -1387,8 +1454,8 @@ void DrawScreenField(int x, int y) MovDir[oldx][oldy] == MV_RIGHT); if (Store[oldx][oldy] == EL_MORAST_LEER || - Store[oldx][oldy] == EL_SIEB_LEER || - Store[oldx][oldy] == EL_SIEB2_LEER || + Store[oldx][oldy] == EL_MAGIC_WALL_EMPTY || + Store[oldx][oldy] == EL_MAGIC_WALL_BD_EMPTY || Store[oldx][oldy] == EL_AMOEBE_NASS) cut_mode = CUT_ABOVE; @@ -1489,24 +1556,32 @@ void DrawMicroElement(int xpos, int ypos, int element) { graphic -= GFX_START_ROCKSSP; graphic -= ((graphic / SP_PER_LINE) * SP_PER_LINE) / 2; - XCopyArea(display, pix[PIX_SP], drawto, gc, - MICRO_SP_STARTX + (graphic % MICRO_SP_PER_LINE) * MICRO_TILEX, - MICRO_SP_STARTY + (graphic / MICRO_SP_PER_LINE) * MICRO_TILEY, - MICRO_TILEX, MICRO_TILEY, xpos, ypos); + BlitBitmap(pix[PIX_SP], drawto, + MICRO_SP_STARTX + (graphic % MICRO_SP_PER_LINE) * MICRO_TILEX, + MICRO_SP_STARTY + (graphic / MICRO_SP_PER_LINE) * MICRO_TILEY, + MICRO_TILEX, MICRO_TILEY, xpos, ypos); } else if (graphic >= GFX_START_ROCKSDC && graphic <= GFX_END_ROCKSDC) { graphic -= GFX_START_ROCKSDC; - XCopyArea(display, pix[PIX_DC], drawto, gc, - MICRO_DC_STARTX + (graphic % MICRO_DC_PER_LINE) * MICRO_TILEX, - MICRO_DC_STARTY + (graphic / MICRO_DC_PER_LINE) * MICRO_TILEY, - MICRO_TILEX, MICRO_TILEY, xpos, ypos); + BlitBitmap(pix[PIX_DC], drawto, + MICRO_DC_STARTX + (graphic % MICRO_DC_PER_LINE) * MICRO_TILEX, + MICRO_DC_STARTY + (graphic / MICRO_DC_PER_LINE) * MICRO_TILEY, + MICRO_TILEX, MICRO_TILEY, xpos, ypos); + } + else if (graphic >= GFX_START_ROCKSMORE && graphic <= GFX_END_ROCKSMORE) + { + graphic -= GFX_START_ROCKSMORE; + BlitBitmap(pix[PIX_MORE], drawto, + MICRO_MORE_STARTX + (graphic % MICRO_MORE_PER_LINE)*MICRO_TILEX, + MICRO_MORE_STARTY + (graphic / MICRO_MORE_PER_LINE)*MICRO_TILEY, + MICRO_TILEX, MICRO_TILEY, xpos, ypos); } else - XCopyArea(display, pix[PIX_BACK], drawto, gc, - MICRO_GFX_STARTX + (graphic % MICRO_GFX_PER_LINE) * MICRO_TILEX, - MICRO_GFX_STARTY + (graphic / MICRO_GFX_PER_LINE) * MICRO_TILEY, - MICRO_TILEX, MICRO_TILEY, xpos, ypos); + BlitBitmap(pix[PIX_BACK], drawto, + MICRO_GFX_STARTX + (graphic % MICRO_GFX_PER_LINE) * MICRO_TILEX, + MICRO_GFX_STARTY + (graphic / MICRO_GFX_PER_LINE) * MICRO_TILEY, + MICRO_TILEX, MICRO_TILEY, xpos, ypos); } void DrawLevel() @@ -1537,8 +1612,7 @@ static void DrawMicroLevelExt(int xpos, int ypos, int from_x, int from_y) { int x, y; - XFillRectangle(display, drawto, gc, - xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE); + ClearRectangle(drawto, xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE); if (lev_fieldx < STD_LEV_FIELDX) xpos += (STD_LEV_FIELDX - lev_fieldx) / 2 * MICRO_TILEX; @@ -1579,15 +1653,14 @@ static void DrawMicroLevelLabelExt(int mode) { char label_text[MAX_MICROLABEL_SIZE + 1]; - XFillRectangle(display, drawto,gc, - SX, MICROLABEL_YPOS, SXSIZE, FONT4_YSIZE); + ClearRectangle(drawto, SX, MICROLABEL_YPOS, SXSIZE, FONT4_YSIZE); strncpy(label_text, (mode == MICROLABEL_LEVEL_NAME ? level.name : mode == MICROLABEL_CREATED_BY ? "created by" : mode == MICROLABEL_LEVEL_AUTHOR ? level.author : mode == MICROLABEL_IMPORTED_FROM ? "imported from" : mode == MICROLABEL_LEVEL_IMPORT_INFO ? - leveldir[leveldir_nr].imported_from : ""), + leveldir_current->imported_from : ""), MAX_MICROLABEL_SIZE); label_text[MAX_MICROLABEL_SIZE] = '\0'; @@ -1670,12 +1743,12 @@ void DrawMicroLevel(int xpos, int ypos, boolean restart) /* redraw micro level label, if needed */ if (strcmp(level.name, NAMELESS_LEVEL_NAME) != 0 && strcmp(level.author, ANONYMOUS_NAME) != 0 && - strcmp(level.author, leveldir[leveldir_nr].name) != 0 && + strcmp(level.author, leveldir_current->name) != 0 && DelayReached(&label_delay, MICROLEVEL_LABEL_DELAY)) { int max_label_counter = 23; - if (leveldir[leveldir_nr].imported_from != NULL) + if (leveldir_current->imported_from != NULL) max_label_counter += 14; label_counter = (label_counter + 1) % max_label_counter; @@ -1725,12 +1798,12 @@ boolean Request(char *text, unsigned int req_state) CloseDoor(DOOR_CLOSE_1); /* save old door content */ - XCopyArea(display, pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], gc, - DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, - DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1); + BlitBitmap(pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], + DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, + DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1); /* clear door drawing field */ - XFillRectangle(display, drawto, gc, DX, DY, DXSIZE, DYSIZE); + ClearRectangle(drawto, DX, DY, DXSIZE, DYSIZE); /* write text for request */ for(ty=0; ty<13; ty++) @@ -1779,9 +1852,9 @@ boolean Request(char *text, unsigned int req_state) } /* copy request gadgets to door backbuffer */ - XCopyArea(display, drawto, pix[PIX_DB_DOOR], gc, - DX, DY, DXSIZE, DYSIZE, - DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1); + BlitBitmap(drawto, pix[PIX_DB_DOOR], + DX, DY, DXSIZE, DYSIZE, + DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1); OpenDoor(DOOR_OPEN_1); @@ -1801,43 +1874,39 @@ boolean Request(char *text, unsigned int req_state) while(result < 0) { - if (XPending(display)) + if (PendingEvent()) { - XEvent event; + Event event; - XNextEvent(display, &event); + NextEvent(&event); switch(event.type) { - case ButtonPress: - case ButtonRelease: - case MotionNotify: + case EVENT_BUTTONPRESS: + case EVENT_BUTTONRELEASE: + case EVENT_MOTIONNOTIFY: { - if (event.type == MotionNotify) + if (event.type == EVENT_MOTIONNOTIFY) { - Window root, child; - int root_x, root_y; int win_x, win_y; - unsigned int mask; - if (!XQueryPointer(display, window, &root, &child, - &root_x, &root_y, &win_x, &win_y, &mask)) - continue; + if (!QueryPointer(window, &win_x, &win_y)) + continue; /* window and pointer are on different screens */ if (!button_status) continue; motion_status = TRUE; - mx = ((XMotionEvent *) &event)->x; - my = ((XMotionEvent *) &event)->y; + mx = ((MotionEvent *) &event)->x; + my = ((MotionEvent *) &event)->y; } else { motion_status = FALSE; - mx = ((XButtonEvent *) &event)->x; - my = ((XButtonEvent *) &event)->y; - if (event.type==ButtonPress) - button_status = ((XButtonEvent *) &event)->button; + mx = ((ButtonEvent *) &event)->x; + my = ((ButtonEvent *) &event)->y; + if (event.type == EVENT_BUTTONPRESS) + button_status = ((ButtonEvent *) &event)->button; else button_status = MB_RELEASED; } @@ -1877,15 +1946,14 @@ boolean Request(char *text, unsigned int req_state) break; } - case KeyPress: - switch(XLookupKeysym((XKeyEvent *)&event, - ((XKeyEvent *)&event)->state)) + case EVENT_KEYPRESS: + switch(GetEventKey((KeyEvent *)&event, TRUE)) { - case XK_Return: + case KEY_Return: result = 1; break; - case XK_Escape: + case KEY_Escape: result = 0; break; @@ -1896,7 +1964,7 @@ boolean Request(char *text, unsigned int req_state) result = 0; break; - case KeyRelease: + case EVENT_KEYRELEASE: key_joystick_mapping = 0; break; @@ -1932,9 +2000,9 @@ boolean Request(char *text, unsigned int req_state) if (!(req_state & REQ_STAY_CLOSED) && (old_door_state & DOOR_OPEN_1)) { - XCopyArea(display,pix[PIX_DB_DOOR],pix[PIX_DB_DOOR],gc, - DOOR_GFX_PAGEX2,DOOR_GFX_PAGEY1, DXSIZE,DYSIZE, - DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY1); + BlitBitmap(pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], + DOOR_GFX_PAGEX2,DOOR_GFX_PAGEY1, DXSIZE,DYSIZE, + DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY1); OpenDoor(DOOR_OPEN_1); } } @@ -1958,9 +2026,9 @@ unsigned int OpenDoor(unsigned int door_state) if (door_state & DOOR_COPY_BACK) { - XCopyArea(display, pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], gc, - DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE + VYSIZE, - DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1); + BlitBitmap(pix[PIX_DB_DOOR], pix[PIX_DB_DOOR], + DOOR_GFX_PAGEX2, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE + VYSIZE, + DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1); door_state &= ~DOOR_COPY_BACK; } @@ -1973,10 +2041,10 @@ unsigned int CloseDoor(unsigned int door_state) { unsigned int new_door_state; - XCopyArea(display, backbuffer, pix[PIX_DB_DOOR], gc, - DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1); - XCopyArea(display, backbuffer, pix[PIX_DB_DOOR], gc, - VX, VY, VXSIZE, VYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2); + BlitBitmap(backbuffer, pix[PIX_DB_DOOR], + DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1); + BlitBitmap(backbuffer, pix[PIX_DB_DOOR], + VX, VY, VXSIZE, VYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2); new_door_state = MoveDoor(door_state); @@ -2031,40 +2099,41 @@ unsigned int MoveDoor(unsigned int door_state) int i = (door_state & DOOR_OPEN_1 ? DXSIZE-x : x); int j = (DXSIZE - i) / 3; - XCopyArea(display, pix[PIX_DB_DOOR], drawto, gc, - DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1 + i/2, - DXSIZE,DYSIZE - i/2, DX, DY); - - XFillRectangle(display, drawto, gc, DX, DY + DYSIZE - i/2, DXSIZE,i/2); - - XSetClipOrigin(display, clip_gc[PIX_DOOR], - DX - i, (DY + j) - DOOR_GFX_PAGEY1); - XCopyArea(display, pix[PIX_DOOR], drawto,clip_gc[PIX_DOOR], - DXSIZE, DOOR_GFX_PAGEY1, i, 77, DX + DXSIZE - i, DY + j); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - DXSIZE, DOOR_GFX_PAGEY1 + 140, i, 63, DX + DXSIZE - i, - DY + 140 + j); - XSetClipOrigin(display, clip_gc[PIX_DOOR], - DX - DXSIZE + i, DY - (DOOR_GFX_PAGEY1 + j)); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - DXSIZE - i, DOOR_GFX_PAGEY1 + j, i, 77 - j, DX, DY); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - DXSIZE-i, DOOR_GFX_PAGEY1 + 140, i, 63, DX, DY + 140 - j); - - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - DXSIZE - i, DOOR_GFX_PAGEY1 + 77, i, 63, - DX, DY + 77 - j); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - DXSIZE - i, DOOR_GFX_PAGEY1 + 203, i, 77, - DX, DY + 203 - j); - XSetClipOrigin(display, clip_gc[PIX_DOOR], - DX - i, (DY + j) - DOOR_GFX_PAGEY1); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - DXSIZE, DOOR_GFX_PAGEY1 + 77, i, 63, - DX + DXSIZE - i, DY + 77 + j); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j, - DX + DXSIZE - i, DY + 203 + j); + BlitBitmap(pix[PIX_DB_DOOR], drawto, + DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1 + i/2, + DXSIZE,DYSIZE - i/2, DX, DY); + + 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, + DXSIZE, DOOR_GFX_PAGEY1, i, 77, + DX + DXSIZE - i, DY + j); + BlitBitmapMasked(pix_masked[PIX_DOOR], 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, + DXSIZE - i, DOOR_GFX_PAGEY1 + j, i, 77 - j, + DX, DY); + BlitBitmapMasked(pix_masked[PIX_DOOR], drawto, + DXSIZE-i, DOOR_GFX_PAGEY1 + 140, i, 63, + DX, DY + 140 - j); + + BlitBitmapMasked(pix_masked[PIX_DOOR], drawto, + DXSIZE - i, DOOR_GFX_PAGEY1 + 77, i, 63, + DX, DY + 77 - j); + BlitBitmapMasked(pix_masked[PIX_DOOR], 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, + DXSIZE, DOOR_GFX_PAGEY1 + 77, i, 63, + DX + DXSIZE - i, DY + 77 + j); + BlitBitmapMasked(pix_masked[PIX_DOOR], drawto, + DXSIZE, DOOR_GFX_PAGEY1 + 203, i, 77 - j, + DX + DXSIZE - i, DY + 203 + j); redraw_mask |= REDRAW_DOOR_1; } @@ -2074,29 +2143,30 @@ unsigned int MoveDoor(unsigned int door_state) int i = (door_state & DOOR_OPEN_2 ? VXSIZE - x : x); int j = (VXSIZE - i) / 3; - XCopyArea(display, pix[PIX_DB_DOOR], drawto, gc, - DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2 + i/2, - VXSIZE, VYSIZE - i/2, VX, VY); - - XFillRectangle(display, drawto, gc, VX, VY + VYSIZE-i/2, VXSIZE, i/2); - - XSetClipOrigin(display, clip_gc[PIX_DOOR], - VX - i, (VY + j) - DOOR_GFX_PAGEY2); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2, VX + VXSIZE-i, VY+j); - XSetClipOrigin(display, clip_gc[PIX_DOOR], - VX - VXSIZE + i, VY - (DOOR_GFX_PAGEY2 + j)); - XCopyArea(display, pix[PIX_DOOR], drawto,clip_gc[PIX_DOOR], - VXSIZE - i, DOOR_GFX_PAGEY2 + j, i, VYSIZE / 2 - j, VX, VY); - - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - VXSIZE - i, DOOR_GFX_PAGEY2 + VYSIZE / 2, i, VYSIZE / 2, - VX, VY + VYSIZE / 2 - j); - XSetClipOrigin(display, clip_gc[PIX_DOOR], - VX - i, (VY + j) - DOOR_GFX_PAGEY2); - XCopyArea(display, pix[PIX_DOOR], drawto, clip_gc[PIX_DOOR], - VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2, i, VYSIZE / 2 - j, - VX + VXSIZE - i, VY + VYSIZE / 2 + j); + BlitBitmap(pix[PIX_DB_DOOR], drawto, + DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2 + i/2, + VXSIZE, VYSIZE - i/2, VX, VY); + + 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, + VXSIZE, DOOR_GFX_PAGEY2, i, VYSIZE / 2, + VX + VXSIZE-i, VY+j); + SetClipOrigin(clip_gc[PIX_DOOR], + VX - VXSIZE + i, VY - (DOOR_GFX_PAGEY2 + j)); + BlitBitmapMasked(pix_masked[PIX_DOOR], drawto, + VXSIZE - i, DOOR_GFX_PAGEY2 + j, i, VYSIZE / 2 - j, + VX, VY); + + BlitBitmapMasked(pix_masked[PIX_DOOR], 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, + VXSIZE, DOOR_GFX_PAGEY2 + VYSIZE / 2, + i, VYSIZE / 2 - j, + VX + VXSIZE - i, VY + VYSIZE / 2 + j); redraw_mask |= REDRAW_DOOR_2; } @@ -2122,8 +2192,8 @@ unsigned int MoveDoor(unsigned int door_state) void DrawSpecialEditorDoor() { /* draw bigger toolbox window */ - XCopyArea(display, pix[PIX_DOOR], drawto, gc, - DOOR_GFX_PAGEX7, 0, 108, 56, EX - 4, EY - 12); + BlitBitmap(pix[PIX_DOOR], drawto, + DOOR_GFX_PAGEX7, 0, 108, 56, EX - 4, EY - 12); redraw_mask |= REDRAW_ALL; } @@ -2131,13 +2201,14 @@ void DrawSpecialEditorDoor() void UndrawSpecialEditorDoor() { /* draw normal tape recorder window */ - XCopyArea(display, pix[PIX_BACK], drawto, gc, - 562, 344, 108, 56, EX - 4, EY - 12); + BlitBitmap(pix[PIX_BACK], drawto, + 562, 344, 108, 56, EX - 4, EY - 12); redraw_mask |= REDRAW_ALL; } -int ReadPixel(Drawable d, int x, int y) +#ifndef USE_SDL_LIBRARY +int ReadPixel(DrawBuffer d, int x, int y) { XImage *pixel_image; unsigned long pixel_value; @@ -2149,6 +2220,7 @@ int ReadPixel(Drawable d, int x, int y) return pixel_value; } +#endif /* ---------- new tool button stuff ---------------------------------------- */ @@ -2262,8 +2334,8 @@ void CreateToolButtons() for (i=0; i= TOOL_CTRL_ID_PLAYER_1 && id <= TOOL_CTRL_ID_PLAYER_4) { getMiniGraphicSource(GFX_SPIELER1 + id - TOOL_CTRL_ID_PLAYER_1, - &deco_pixmap, &deco_x, &deco_y); + &deco_bitmap, &deco_x, &deco_y); deco_xpos = (toolbutton_info[i].width - MINI_TILEX) / 2; deco_ypos = (toolbutton_info[i].height - MINI_TILEY) / 2; } @@ -2295,9 +2367,9 @@ void CreateToolButtons() GDI_HEIGHT, toolbutton_info[i].height, GDI_TYPE, GD_TYPE_NORMAL_BUTTON, GDI_STATE, GD_BUTTON_UNPRESSED, - GDI_DESIGN_UNPRESSED, gd_pixmap, gd_x1, gd_y, - GDI_DESIGN_PRESSED, gd_pixmap, gd_x2, gd_y, - GDI_DECORATION_DESIGN, deco_pixmap, deco_x, deco_y, + GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y, + GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y, + GDI_DECORATION_DESIGN, deco_bitmap, deco_x, deco_y, GDI_DECORATION_POSITION, deco_xpos, deco_ypos, GDI_DECORATION_SIZE, MINI_TILEX, MINI_TILEY, GDI_DECORATION_SHIFTING, 1, 1, @@ -2346,25 +2418,25 @@ int el2gfx(int element) case EL_SPIELER3: return GFX_SPIELER3; case EL_SPIELER4: return GFX_SPIELER4; case EL_KAEFER: return GFX_KAEFER; - case EL_KAEFER_R: return GFX_KAEFER_R; - case EL_KAEFER_O: return GFX_KAEFER_O; - case EL_KAEFER_L: return GFX_KAEFER_L; - case EL_KAEFER_U: return GFX_KAEFER_U; + case EL_KAEFER_RIGHT: return GFX_KAEFER_RIGHT; + case EL_KAEFER_UP: return GFX_KAEFER_UP; + case EL_KAEFER_LEFT: return GFX_KAEFER_LEFT; + case EL_KAEFER_DOWN: return GFX_KAEFER_DOWN; case EL_FLIEGER: return GFX_FLIEGER; - case EL_FLIEGER_R: return GFX_FLIEGER_R; - case EL_FLIEGER_O: return GFX_FLIEGER_O; - case EL_FLIEGER_L: return GFX_FLIEGER_L; - case EL_FLIEGER_U: return GFX_FLIEGER_U; + case EL_FLIEGER_RIGHT: return GFX_FLIEGER_RIGHT; + case EL_FLIEGER_UP: return GFX_FLIEGER_UP; + case EL_FLIEGER_LEFT: return GFX_FLIEGER_LEFT; + case EL_FLIEGER_DOWN: return GFX_FLIEGER_DOWN; case EL_BUTTERFLY: return GFX_BUTTERFLY; - case EL_BUTTERFLY_R: return GFX_BUTTERFLY_R; - case EL_BUTTERFLY_O: return GFX_BUTTERFLY_O; - case EL_BUTTERFLY_L: return GFX_BUTTERFLY_L; - case EL_BUTTERFLY_U: return GFX_BUTTERFLY_U; + case EL_BUTTERFLY_RIGHT: return GFX_BUTTERFLY_RIGHT; + case EL_BUTTERFLY_UP: return GFX_BUTTERFLY_UP; + case EL_BUTTERFLY_LEFT: return GFX_BUTTERFLY_LEFT; + case EL_BUTTERFLY_DOWN: return GFX_BUTTERFLY_DOWN; case EL_FIREFLY: return GFX_FIREFLY; - case EL_FIREFLY_R: return GFX_FIREFLY_R; - case EL_FIREFLY_O: return GFX_FIREFLY_O; - case EL_FIREFLY_L: return GFX_FIREFLY_L; - case EL_FIREFLY_U: return GFX_FIREFLY_U; + case EL_FIREFLY_RIGHT: return GFX_FIREFLY_RIGHT; + case EL_FIREFLY_UP: return GFX_FIREFLY_UP; + case EL_FIREFLY_LEFT: return GFX_FIREFLY_LEFT; + case EL_FIREFLY_DOWN: return GFX_FIREFLY_DOWN; case EL_MAMPFER: return GFX_MAMPFER; case EL_ROBOT: return GFX_ROBOT; case EL_BETON: return GFX_BETON; @@ -2373,10 +2445,10 @@ int el2gfx(int element) case EL_MORAST_VOLL: return GFX_MORAST_VOLL; case EL_TROPFEN: return GFX_TROPFEN; case EL_BOMBE: return GFX_BOMBE; - case EL_SIEB_INAKTIV: return GFX_SIEB_INAKTIV; - case EL_SIEB_LEER: return GFX_SIEB_LEER; - case EL_SIEB_VOLL: return GFX_SIEB_VOLL; - case EL_SIEB_TOT: return GFX_SIEB_TOT; + case EL_MAGIC_WALL_OFF: return GFX_MAGIC_WALL_OFF; + case EL_MAGIC_WALL_EMPTY: return GFX_MAGIC_WALL_EMPTY; + case EL_MAGIC_WALL_FULL: return GFX_MAGIC_WALL_FULL; + case EL_MAGIC_WALL_DEAD: return GFX_MAGIC_WALL_DEAD; case EL_SALZSAEURE: return GFX_SALZSAEURE; case EL_AMOEBE_TOT: return GFX_AMOEBE_TOT; case EL_AMOEBE_NASS: return GFX_AMOEBE_NASS; @@ -2410,10 +2482,10 @@ int el2gfx(int element) case EL_PFORTE4X: return GFX_PFORTE4X; case EL_DYNAMITE_INACTIVE: return GFX_DYNAMIT_AUS; case EL_PACMAN: return GFX_PACMAN; - case EL_PACMAN_R: return GFX_PACMAN_R; - case EL_PACMAN_O: return GFX_PACMAN_O; - case EL_PACMAN_L: return GFX_PACMAN_L; - case EL_PACMAN_U: return GFX_PACMAN_U; + case EL_PACMAN_RIGHT: return GFX_PACMAN_RIGHT; + case EL_PACMAN_UP: return GFX_PACMAN_UP; + case EL_PACMAN_LEFT: return GFX_PACMAN_LEFT; + case EL_PACMAN_DOWN: return GFX_PACMAN_DOWN; case EL_UNSICHTBAR: return GFX_UNSICHTBAR; case EL_ERZ_EDEL: return GFX_ERZ_EDEL; case EL_ERZ_DIAM: return GFX_ERZ_DIAM; @@ -2434,10 +2506,10 @@ int el2gfx(int element) case EL_ERZ_EDEL_ROT: return GFX_ERZ_EDEL_ROT; case EL_ERZ_EDEL_LILA: return GFX_ERZ_EDEL_LILA; case EL_MAMPFER2: return GFX_MAMPFER2; - case EL_SIEB2_INAKTIV: return GFX_SIEB2_INAKTIV; - case EL_SIEB2_LEER: return GFX_SIEB2_LEER; - case EL_SIEB2_VOLL: return GFX_SIEB2_VOLL; - case EL_SIEB2_TOT: return GFX_SIEB2_TOT; + case EL_MAGIC_WALL_BD_OFF: return GFX_MAGIC_WALL_BD_OFF; + case EL_MAGIC_WALL_BD_EMPTY:return GFX_MAGIC_WALL_BD_EMPTY; + case EL_MAGIC_WALL_BD_FULL: return GFX_MAGIC_WALL_BD_FULL; + case EL_MAGIC_WALL_BD_DEAD: return GFX_MAGIC_WALL_BD_DEAD; case EL_DYNABOMB_ACTIVE_1: return GFX_DYNABOMB; case EL_DYNABOMB_ACTIVE_2: return GFX_DYNABOMB; case EL_DYNABOMB_ACTIVE_3: return GFX_DYNABOMB; @@ -2448,15 +2520,15 @@ int el2gfx(int element) case EL_SOKOBAN_OBJEKT: return GFX_SOKOBAN_OBJEKT; case EL_SOKOBAN_FELD_LEER: return GFX_SOKOBAN_FELD_LEER; case EL_SOKOBAN_FELD_VOLL: return GFX_SOKOBAN_FELD_VOLL; - case EL_MAULWURF: return GFX_MAULWURF; + case EL_MOLE: return GFX_MOLE; case EL_PINGUIN: return GFX_PINGUIN; case EL_SCHWEIN: return GFX_SCHWEIN; case EL_DRACHE: return GFX_DRACHE; case EL_SONDE: return GFX_SONDE; - case EL_PFEIL_L: return GFX_PFEIL_L; - case EL_PFEIL_R: return GFX_PFEIL_R; - case EL_PFEIL_O: return GFX_PFEIL_O; - case EL_PFEIL_U: return GFX_PFEIL_U; + case EL_PFEIL_LEFT: return GFX_PFEIL_LEFT; + case EL_PFEIL_RIGHT: return GFX_PFEIL_RIGHT; + case EL_PFEIL_UP: return GFX_PFEIL_UP; + case EL_PFEIL_DOWN: return GFX_PFEIL_DOWN; case EL_SPEED_PILL: return GFX_SPEED_PILL; case EL_SP_TERMINAL_ACTIVE: return GFX_SP_TERMINAL; case EL_SP_BUG_ACTIVE: return GFX_SP_BUG_ACTIVE; @@ -2487,38 +2559,37 @@ int el2gfx(int element) case EL_DOOR_WHITE: return GFX_DOOR_WHITE; case EL_DOOR_WHITE_GRAY: return GFX_DOOR_WHITE_GRAY; case EL_KEY_WHITE: return GFX_KEY_WHITE; - case EL_FORCE_FIELD: return GFX_FORCE_FIELD; + case EL_SHIELD_PASSIVE: return GFX_SHIELD_PASSIVE; + case EL_SHIELD_ACTIVE: return GFX_SHIELD_ACTIVE; case EL_EXTRA_TIME: return GFX_EXTRA_TIME; case EL_SWITCHGATE_OPEN: return GFX_SWITCHGATE_OPEN; case EL_SWITCHGATE_CLOSED: return GFX_SWITCHGATE_CLOSED; case EL_SWITCHGATE_SWITCH_1:return GFX_SWITCHGATE_SWITCH_1; case EL_SWITCHGATE_SWITCH_2:return GFX_SWITCHGATE_SWITCH_2; - case EL_TIME_GATE: return GFX_TIME_GATE; - case EL_TIME_GATE_WHEEL: return GFX_TIME_GATE_WHEEL; case EL_BELT1_LEFT: return GFX_BELT1_LEFT; case EL_BELT1_MIDDLE: return GFX_BELT1_MIDDLE; case EL_BELT1_RIGHT: return GFX_BELT1_RIGHT; - case EL_BELT1_SWITCH_L: return GFX_BELT1_SWITCH_L; - case EL_BELT1_SWITCH_M: return GFX_BELT1_SWITCH_M; - case EL_BELT1_SWITCH_R: return GFX_BELT1_SWITCH_R; + case EL_BELT1_SWITCH_LEFT: return GFX_BELT1_SWITCH_LEFT; + case EL_BELT1_SWITCH_MIDDLE:return GFX_BELT1_SWITCH_MIDDLE; + case EL_BELT1_SWITCH_RIGHT: return GFX_BELT1_SWITCH_RIGHT; case EL_BELT2_LEFT: return GFX_BELT2_LEFT; case EL_BELT2_MIDDLE: return GFX_BELT2_MIDDLE; case EL_BELT2_RIGHT: return GFX_BELT2_RIGHT; - case EL_BELT2_SWITCH_L: return GFX_BELT2_SWITCH_L; - case EL_BELT2_SWITCH_M: return GFX_BELT2_SWITCH_M; - case EL_BELT2_SWITCH_R: return GFX_BELT2_SWITCH_R; + case EL_BELT2_SWITCH_LEFT: return GFX_BELT2_SWITCH_LEFT; + case EL_BELT2_SWITCH_MIDDLE:return GFX_BELT2_SWITCH_MIDDLE; + case EL_BELT2_SWITCH_RIGHT: return GFX_BELT2_SWITCH_RIGHT; case EL_BELT3_LEFT: return GFX_BELT3_LEFT; case EL_BELT3_MIDDLE: return GFX_BELT3_MIDDLE; case EL_BELT3_RIGHT: return GFX_BELT3_RIGHT; - case EL_BELT3_SWITCH_L: return GFX_BELT3_SWITCH_L; - case EL_BELT3_SWITCH_M: return GFX_BELT3_SWITCH_M; - case EL_BELT3_SWITCH_R: return GFX_BELT3_SWITCH_R; + case EL_BELT3_SWITCH_LEFT: return GFX_BELT3_SWITCH_LEFT; + case EL_BELT3_SWITCH_MIDDLE:return GFX_BELT3_SWITCH_MIDDLE; + case EL_BELT3_SWITCH_RIGHT: return GFX_BELT3_SWITCH_RIGHT; case EL_BELT4_LEFT: return GFX_BELT4_LEFT; case EL_BELT4_MIDDLE: return GFX_BELT4_MIDDLE; case EL_BELT4_RIGHT: return GFX_BELT4_RIGHT; - case EL_BELT4_SWITCH_L: return GFX_BELT4_SWITCH_L; - case EL_BELT4_SWITCH_M: return GFX_BELT4_SWITCH_M; - case EL_BELT4_SWITCH_R: return GFX_BELT4_SWITCH_R; + case EL_BELT4_SWITCH_LEFT: return GFX_BELT4_SWITCH_LEFT; + case EL_BELT4_SWITCH_MIDDLE:return GFX_BELT4_SWITCH_MIDDLE; + case EL_BELT4_SWITCH_RIGHT: return GFX_BELT4_SWITCH_RIGHT; case EL_LANDMINE: return GFX_LANDMINE; case EL_ENVELOPE: return GFX_ENVELOPE; case EL_LIGHT_SWITCH_OFF: return GFX_LIGHT_SWITCH_OFF; @@ -2541,6 +2612,49 @@ int el2gfx(int element) case EL_MOLE_DOWN: return GFX_MOLE_DOWN; case EL_STEEL_SLANTED: return GFX_STEEL_SLANTED; case EL_SAND_INVISIBLE: return GFX_SAND_INVISIBLE; + case EL_DX_UNKNOWN_15: return GFX_DX_UNKNOWN_15; + case EL_DX_UNKNOWN_42: return GFX_DX_UNKNOWN_42; + case EL_TIMEGATE_OPEN: return GFX_TIMEGATE_OPEN; + case EL_TIMEGATE_CLOSED: return GFX_TIMEGATE_CLOSED; + case EL_TIMEGATE_SWITCH_ON: return GFX_TIMEGATE_SWITCH; + case EL_TIMEGATE_SWITCH_OFF:return GFX_TIMEGATE_SWITCH; + case EL_BALLOON: return GFX_BALLOON; + case EL_BALLOON_SEND_LEFT: return GFX_BALLOON_SEND_LEFT; + case EL_BALLOON_SEND_RIGHT: return GFX_BALLOON_SEND_RIGHT; + case EL_BALLOON_SEND_UP: return GFX_BALLOON_SEND_UP; + case EL_BALLOON_SEND_DOWN: return GFX_BALLOON_SEND_DOWN; + case EL_BALLOON_SEND_ANY: return GFX_BALLOON_SEND_ANY; + case EL_EMC_STEEL_WALL_1: return GFX_EMC_STEEL_WALL_1; + case EL_EMC_STEEL_WALL_2: return GFX_EMC_STEEL_WALL_2; + case EL_EMC_STEEL_WALL_3: return GFX_EMC_STEEL_WALL_3; + case EL_EMC_STEEL_WALL_4: return GFX_EMC_STEEL_WALL_4; + case EL_EMC_WALL_1: return GFX_EMC_WALL_1; + case EL_EMC_WALL_2: return GFX_EMC_WALL_2; + case EL_EMC_WALL_3: return GFX_EMC_WALL_3; + case EL_EMC_WALL_4: return GFX_EMC_WALL_4; + case EL_EMC_WALL_5: return GFX_EMC_WALL_5; + case EL_EMC_WALL_6: return GFX_EMC_WALL_6; + case EL_EMC_WALL_7: return GFX_EMC_WALL_7; + case EL_EMC_WALL_8: return GFX_EMC_WALL_8; + case EL_TUBE_CROSS: return GFX_TUBE_CROSS; + case EL_TUBE_VERTICAL: return GFX_TUBE_VERTICAL; + case EL_TUBE_HORIZONTAL: return GFX_TUBE_HORIZONTAL; + case EL_TUBE_VERT_LEFT: return GFX_TUBE_VERT_LEFT; + case EL_TUBE_VERT_RIGHT: return GFX_TUBE_VERT_RIGHT; + case EL_TUBE_HORIZ_UP: return GFX_TUBE_HORIZ_UP; + case EL_TUBE_HORIZ_DOWN: return GFX_TUBE_HORIZ_DOWN; + case EL_TUBE_LEFT_UP: return GFX_TUBE_LEFT_UP; + case EL_TUBE_LEFT_DOWN: return GFX_TUBE_LEFT_DOWN; + case EL_TUBE_RIGHT_UP: return GFX_TUBE_RIGHT_UP; + case EL_TUBE_RIGHT_DOWN: return GFX_TUBE_RIGHT_DOWN; + case EL_SPRING: return GFX_SPRING; + case EL_SPRING_MOVING: return GFX_SPRING; + case EL_TRAP_INACTIVE: return GFX_TRAP_INACTIVE; + case EL_TRAP_ACTIVE: return GFX_TRAP_ACTIVE; + case EL_BD_WALL: return GFX_BD_WALL; + case EL_BD_ROCK: return GFX_BD_ROCK; + case EL_DX_SUPABOMB: return GFX_DX_SUPABOMB; + case EL_SP_MURPHY_CLONE: return GFX_SP_MURPHY_CLONE; default: {