X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=3bf2c5a5ad9644c6587e4a4b1655528ff763a7e9;hb=b9c7e4a42762c8526702726f1404d3e75dbc29f5;hp=69203cf9fa7e7c893656c80fed670f505effcbc7;hpb=a35852e106072656e444202e672d050ebff03abb;p=rocksndiamonds.git diff --git a/src/tools.c b/src/tools.c index 69203cf9..3bf2c5a5 100644 --- a/src/tools.c +++ b/src/tools.c @@ -85,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; @@ -104,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; } @@ -118,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 { @@ -137,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 @@ -160,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; } @@ -211,12 +202,12 @@ void BackToFront() for(x=0; xMovDir & (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); } @@ -645,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)); @@ -707,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); } @@ -771,54 +766,54 @@ static void DrawGraphicAnimationShiftedThruMask(int sx, int sy, DrawGraphicShiftedThruMask(sx, sy, sxx, syy, graphic + phase, NO_CUTTING); } -void getGraphicSource(int graphic, int *pixmap_nr, int *x, int *y) +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; - *pixmap_nr = PIX_MORE; + *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; } @@ -839,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) @@ -864,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); } } @@ -904,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; } @@ -917,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, @@ -961,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) @@ -1035,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; @@ -1058,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); } @@ -1163,12 +1165,16 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, { graphic += phase4; } - else if ((element == EL_FELSBROCKEN || element == EL_SP_ZONK || + 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; @@ -1181,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); } @@ -1278,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; @@ -1296,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) @@ -1314,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); @@ -1336,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; @@ -1355,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); } @@ -1401,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) @@ -1437,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; @@ -1539,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() @@ -1587,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; @@ -1629,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'; @@ -1720,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; @@ -1775,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++) @@ -1829,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); @@ -1851,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; } @@ -1927,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; @@ -1946,7 +1964,7 @@ boolean Request(char *text, unsigned int req_state) result = 0; break; - case KeyRelease: + case EVENT_KEYRELEASE: key_joystick_mapping = 0; break; @@ -1982,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); } } @@ -2008,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; } @@ -2023,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); @@ -2081,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; } @@ -2124,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; } @@ -2172,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; } @@ -2181,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; @@ -2199,6 +2220,7 @@ int ReadPixel(Drawable d, int x, int y) return pixel_value; } +#endif /* ---------- new tool button stuff ---------------------------------------- */ @@ -2312,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; } @@ -2345,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, @@ -2423,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; @@ -2484,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; @@ -2614,6 +2636,25 @@ int el2gfx(int element) 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: {