X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=eba90f7076c043aca03039fa62c779e27f932728;hb=88a46f726da49d5ae03e736b1388a4b854221685;hp=0552e4af67d70ebf2d041e2ad1e83b5cbf98fd30;hpb=8afc6199767a6fcb7451efd2b3d5b070f6c99efb;p=rocksndiamonds.git diff --git a/src/tools.c b/src/tools.c index 0552e4af..eba90f70 100644 --- a/src/tools.c +++ b/src/tools.c @@ -402,14 +402,14 @@ void SetBorderElement() { int x, y; - BorderElement = EL_LEERRAUM; + BorderElement = EL_EMPTY; - for(y=0; yGfxPos) { - if (Feld[next_jx][next_jy] == EL_SOKOBAN_FELD_VOLL) - DrawLevelElement(next_jx, next_jy, EL_SOKOBAN_FELD_LEER); + if (Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL) + DrawLevelElement(next_jx, next_jy, EL_SOKOBAN_FIELD_EMPTY); else - DrawLevelElement(next_jx, next_jy, EL_LEERRAUM); + DrawLevelElement(next_jx, next_jy, EL_EMPTY); } else DrawLevelField(next_jx, next_jy); @@ -505,7 +505,7 @@ void DrawPlayer(struct PlayerInfo *player) else if (!IS_ACTIVE_BOMB(element)) DrawLevelField(jx, jy); else - DrawLevelElement(jx, jy, EL_LEERRAUM); + DrawLevelElement(jx, jy, EL_EMPTY); /* draw player himself */ @@ -605,8 +605,8 @@ void DrawPlayer(struct PlayerInfo *player) { int px = SCREENX(next_jx), py = SCREENY(next_jy); - if (element == EL_SOKOBAN_FELD_LEER || - Feld[next_jx][next_jy] == EL_SOKOBAN_FELD_VOLL) + if (element == EL_SOKOBAN_FIELD_EMPTY || + Feld[next_jx][next_jy] == EL_SOKOBAN_FIELD_FULL) DrawGraphicShiftedThruMask(px, py, sxx, syy, GFX_SOKOBAN_OBJEKT, NO_CUTTING); else @@ -614,7 +614,7 @@ void DrawPlayer(struct PlayerInfo *player) int element = Feld[next_jx][next_jy]; int graphic = el2gfx(element); - if ((element == EL_FELSBROCKEN || + if ((element == EL_ROCK || element == EL_SP_ZONK || element == EL_BD_ROCK) && sxx) { @@ -653,7 +653,7 @@ void DrawPlayer(struct PlayerInfo *player) DrawGraphicThruMask(sx, sy, graphic + phase); } - if (player_is_moving && last_element == EL_EXPLODING) + if (player_is_moving && last_element == EL_EXPLOSION) { int phase = Frame[last_jx][last_jy]; int delay = 2; @@ -690,7 +690,7 @@ static int getGraphicAnimationPhase(int frames, int delay, int mode) { int phase; - if (mode == ANIM_PINGPONG) + if (mode & ANIM_PINGPONG) { int max_anim_frames = 2 * frames - 2; @@ -700,33 +700,53 @@ static int getGraphicAnimationPhase(int frames, int delay, int mode) else phase = (FrameCounter % (delay * frames)) / delay; - if (mode == ANIM_REVERSE) + if (mode & ANIM_REVERSE) phase = -phase; return phase; } -static int getNewGraphicAnimationFrame(int graphic) +int getNewGraphicAnimationFrame(int graphic, int sync_frame) { - int frames = new_graphic_info[graphic].anim_frames; + int num_frames = new_graphic_info[graphic].anim_frames; int delay = new_graphic_info[graphic].anim_delay; int mode = new_graphic_info[graphic].anim_mode; - int phase; + int frame = 0; + + /* animation synchronized with global frame counter, not move position */ + if (new_graphic_info[graphic].anim_global_sync || sync_frame < 0) + sync_frame = FrameCounter; - if (mode == ANIM_PINGPONG) + if (mode & ANIM_LOOP) /* normal, looping animation */ { - int max_anim_frames = 2 * frames - 2; + frame = (sync_frame % (delay * num_frames)) / delay; + } + else if (mode & ANIM_LINEAR) /* normal, non-looping animation */ + { + frame = sync_frame / delay; - phase = (FrameCounter % (delay * max_anim_frames)) / delay; - phase = (phase < frames ? phase : max_anim_frames - phase); + if (frame > num_frames - 1) + frame = num_frames - 1; } - else - phase = (FrameCounter % (delay * frames)) / delay; + else if (mode & ANIM_PINGPONG) /* use border frames once */ + { + int max_anim_frames = 2 * num_frames - 2; - if (mode == ANIM_REVERSE) - phase = (frames - 1) - phase; + frame = (sync_frame % (delay * max_anim_frames)) / delay; + frame = (frame < num_frames ? frame : max_anim_frames - frame); + } + else if (mode & ANIM_PINGPONG2) /* use border frames twice */ + { + int max_anim_frames = 2 * num_frames; - return phase; + frame = (sync_frame % (delay * max_anim_frames)) / delay; + frame = (frame < num_frames ? frame : max_anim_frames - frame - 1); + } + + if (mode & ANIM_REVERSE) /* use reverse animation direction */ + frame = num_frames - frame - 1; + + return frame; } void DrawGraphicAnimationExt(int x, int y, int graphic, @@ -745,11 +765,15 @@ void DrawGraphicAnimationExt(int x, int y, int graphic, void DrawNewGraphicAnimationExt(int x, int y, int graphic, int mask_mode) { +#if 0 int delay = new_graphic_info[graphic].anim_delay; if (!(FrameCounter % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y))) +#else + if (IN_SCR_FIELD(SCREENX(x), SCREENY(y))) +#endif { - int frame = getNewGraphicAnimationFrame(graphic); + int frame = getNewGraphicAnimationFrame(graphic, -1); if (mask_mode == USE_MASKING) DrawNewGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame); @@ -891,11 +915,11 @@ void DrawNewGraphicExt(DrawBuffer *dst_bitmap, int x, int y, int graphic, Bitmap *src_bitmap = new_graphic_info[graphic].bitmap; int src_x = new_graphic_info[graphic].src_x; int src_y = new_graphic_info[graphic].src_y; + int offset_x = new_graphic_info[graphic].offset_x; + int offset_y = new_graphic_info[graphic].offset_y; - if (new_graphic_info[graphic].anim_vertical) - src_y += frame * TILEY; - else - src_x += frame * TILEX; + src_x += frame * offset_x; + src_y += frame * offset_y; BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, TILEX, TILEY, x, y); } @@ -972,11 +996,11 @@ void DrawNewGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y, GC drawing_gc = src_bitmap->stored_clip_gc; int src_x = new_graphic_info[graphic].src_x; int src_y = new_graphic_info[graphic].src_y; + int offset_x = new_graphic_info[graphic].offset_x; + int offset_y = new_graphic_info[graphic].offset_y; - if (new_graphic_info[graphic].anim_vertical) - src_y += frame * TILEY; - else - src_x += frame * TILEX; + src_x += frame * offset_x; + src_y += frame * offset_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); @@ -984,8 +1008,16 @@ void DrawNewGraphicThruMaskExt(DrawBuffer *d, int dest_x, int dest_y, void DrawMiniGraphic(int x, int y, int graphic) { - DrawMiniGraphicExt(drawto, SX + x*MINI_TILEX, SY + y*MINI_TILEY, graphic); - MarkTileDirty(x/2, y/2); + DrawMiniGraphicExt(drawto, + SX + x * MINI_TILEX, SY + y * MINI_TILEY, graphic); + MarkTileDirty(x / 2, y / 2); +} + +void DrawNewMiniGraphic(int x, int y, int graphic) +{ + DrawNewMiniGraphicExt(drawto, + SX + x * MINI_TILEX, SY + y * MINI_TILEY, graphic); + MarkTileDirty(x / 2, y / 2); } void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y) @@ -1033,6 +1065,19 @@ void getMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y) } } +void getNewMiniGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y) +{ + Bitmap *src_bitmap = new_graphic_info[graphic].bitmap; + int mini_startx = 0; + int mini_starty = src_bitmap->height * 2 / 3; + int src_x = mini_startx + new_graphic_info[graphic].src_x / 2; + int src_y = mini_starty + new_graphic_info[graphic].src_y / 2; + + *bitmap = src_bitmap; + *x = src_x; + *y = src_y; +} + void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic) { Bitmap *bitmap; @@ -1042,6 +1087,24 @@ void DrawMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic) BlitBitmap(bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y); } +void DrawNewMiniGraphicExt(DrawBuffer *d, int x, int y, int graphic) +{ +#if 1 + Bitmap *src_bitmap; + int src_x, src_y; + + getNewMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y); +#else + Bitmap *src_bitmap = new_graphic_info[graphic].bitmap; + int mini_startx = src_bitmap->width * 2 / 3; + int mini_starty = src_bitmap->height * 2 / 3; + int src_x = mini_startx + new_graphic_info[graphic].src_x / 2; + int src_y = mini_starty + new_graphic_info[graphic].src_y / 2; +#endif + + BlitBitmap(src_bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y); +} + void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, int cut_mode, int mask_mode) { @@ -1169,12 +1232,136 @@ void DrawGraphicShifted(int x,int y, int dx,int dy, int graphic, MarkTileDirty(x,y); } +void DrawNewGraphicShifted(int x,int y, int dx,int dy, int graphic, int frame, + int cut_mode, int mask_mode) +{ + Bitmap *src_bitmap; + GC drawing_gc; + int src_x; + int src_y; + int offset_x; + int offset_y; + + int width = TILEX, height = TILEY; + int cx = 0, cy = 0; + int dest_x, dest_y; + + if (graphic < 0) + { + DrawNewGraphic(x, y, graphic, frame); + return; + } + + if (dx || dy) /* Verschiebung der Grafik? */ + { + if (x < BX1) /* Element kommt von links ins Bild */ + { + x = BX1; + width = dx; + cx = TILEX - dx; + dx = 0; + } + else if (x > BX2) /* Element kommt von rechts ins Bild */ + { + x = BX2; + width = -dx; + dx = TILEX + dx; + } + else if (x==BX1 && dx < 0) /* Element verläßt links das Bild */ + { + width += dx; + cx = -dx; + dx = 0; + } + else if (x==BX2 && dx > 0) /* Element verläßt rechts das Bild */ + width -= dx; + else if (dx) /* allg. Bewegung in x-Richtung */ + MarkTileDirty(x + SIGN(dx), y); + + if (y < BY1) /* Element kommt von oben ins Bild */ + { + if (cut_mode==CUT_BELOW) /* Element oberhalb des Bildes */ + return; + + y = BY1; + height = dy; + cy = TILEY - dy; + dy = 0; + } + else if (y > BY2) /* Element kommt von unten ins Bild */ + { + y = BY2; + height = -dy; + dy = TILEY + dy; + } + else if (y==BY1 && dy < 0) /* Element verläßt oben das Bild */ + { + height += dy; + cy = -dy; + dy = 0; + } + else if (dy > 0 && cut_mode == CUT_ABOVE) + { + if (y == BY2) /* Element unterhalb des Bildes */ + return; + + height = dy; + cy = TILEY - dy; + dy = TILEY; + MarkTileDirty(x, y + 1); + } /* Element verläßt unten das Bild */ + else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW)) + height -= dy; + else if (dy) /* allg. Bewegung in y-Richtung */ + MarkTileDirty(x, y + SIGN(dy)); + } + + src_bitmap = new_graphic_info[graphic].bitmap; + drawing_gc = src_bitmap->stored_clip_gc; + src_x = new_graphic_info[graphic].src_x; + src_y = new_graphic_info[graphic].src_y; + offset_x = new_graphic_info[graphic].offset_x; + offset_y = new_graphic_info[graphic].offset_y; + + src_x += frame * offset_x; + src_y += frame * offset_y; + + src_x += cx; + src_y += cy; + + dest_x = FX + x * TILEX + dx; + dest_y = FY + y * TILEY + dy; + +#if DEBUG + if (!IN_SCR_FIELD(x,y)) + { + printf("DrawGraphicShifted(): x = %d, y = %d, graphic = %d\n",x,y,graphic); + printf("DrawGraphicShifted(): This should never happen!\n"); + return; + } +#endif + + if (mask_mode == USE_MASKING) + SetClipOrigin(src_bitmap, drawing_gc, dest_x - src_x, dest_y - src_y); + + BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height, + dest_x, dest_y); + + MarkTileDirty(x,y); +} + void DrawGraphicShiftedThruMask(int x,int y, int dx,int dy, int graphic, int cut_mode) { DrawGraphicShifted(x,y, dx,dy, graphic, cut_mode, USE_MASKING); } +void DrawNewGraphicShiftedThruMask(int x,int y, int dx,int dy, int graphic, + int frame, int cut_mode) +{ + DrawNewGraphicShifted(x,y, dx,dy, graphic, frame, cut_mode, USE_MASKING); +} + void DrawScreenElementExt(int x, int y, int dx, int dy, int element, int cut_mode, int mask_mode) { @@ -1185,7 +1372,7 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, int phase2 = phase8 / 4; int dir = MovDir[ux][uy]; - if (element == EL_PACMAN || element == EL_KAEFER || element == EL_FLIEGER) + if (element == EL_PACMAN || element == EL_BUG || element == EL_SPACESHIP) { graphic += 1 * !phase2; @@ -1211,39 +1398,39 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, } else if (element == EL_SP_ELECTRON) { - graphic = GFX2_SP_ELECTRON + getGraphicAnimationPhase(8, 2, ANIM_NORMAL); + graphic = GFX2_SP_ELECTRON + getGraphicAnimationPhase(8, 2, ANIM_LOOP); } - else if (element == EL_MOLE || element == EL_PINGUIN || - element == EL_SCHWEIN || element == EL_DRACHE) + else if (element == EL_MOLE || element == EL_PENGUIN || + element == EL_PIG || element == EL_DRAGON) { if (dir == MV_LEFT) graphic = (element == EL_MOLE ? GFX_MOLE_LEFT : - element == EL_PINGUIN ? GFX_PINGUIN_LEFT : - element == EL_SCHWEIN ? GFX_SCHWEIN_LEFT : GFX_DRACHE_LEFT); + element == EL_PENGUIN ? GFX_PINGUIN_LEFT : + element == EL_PIG ? GFX_SCHWEIN_LEFT : GFX_DRACHE_LEFT); else if (dir == MV_RIGHT) graphic = (element == EL_MOLE ? GFX_MOLE_RIGHT : - element == EL_PINGUIN ? GFX_PINGUIN_RIGHT : - element == EL_SCHWEIN ? GFX_SCHWEIN_RIGHT : GFX_DRACHE_RIGHT); + element == EL_PENGUIN ? GFX_PINGUIN_RIGHT : + element == EL_PIG ? GFX_SCHWEIN_RIGHT : GFX_DRACHE_RIGHT); else if (dir == MV_UP) graphic = (element == EL_MOLE ? GFX_MOLE_UP : - element == EL_PINGUIN ? GFX_PINGUIN_UP : - element == EL_SCHWEIN ? GFX_SCHWEIN_UP : GFX_DRACHE_UP); + element == EL_PENGUIN ? GFX_PINGUIN_UP : + element == EL_PIG ? GFX_SCHWEIN_UP : GFX_DRACHE_UP); else graphic = (element == EL_MOLE ? GFX_MOLE_DOWN : - element == EL_PINGUIN ? GFX_PINGUIN_DOWN : - element == EL_SCHWEIN ? GFX_SCHWEIN_DOWN : GFX_DRACHE_DOWN); + element == EL_PENGUIN ? GFX_PINGUIN_DOWN : + element == EL_PIG ? GFX_SCHWEIN_DOWN : GFX_DRACHE_DOWN); graphic += phase4; } - else if (element == EL_SONDE) + else if (element == EL_SATELLITE) { - graphic = GFX_SONDE_START + getGraphicAnimationPhase(8, 2, ANIM_NORMAL); + graphic = GFX_SONDE_START + getGraphicAnimationPhase(8, 2, ANIM_LOOP); } - else if (element == EL_SALZSAEURE) + else if (element == EL_ACID) { - graphic = GFX_GEBLUBBER + getGraphicAnimationPhase(4, 10, ANIM_NORMAL); + graphic = GFX_GEBLUBBER + getGraphicAnimationPhase(4, 10, ANIM_LOOP); } - else if (element == EL_BUTTERFLY || element == EL_FIREFLY) + else if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY) { graphic += !phase2; } @@ -1251,7 +1438,7 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, { graphic += phase4; } - else if ((element == EL_FELSBROCKEN || + else if ((element == EL_ROCK || element == EL_SP_ZONK || element == EL_BD_ROCK || element == EL_SP_INFOTRON || @@ -1260,7 +1447,7 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, { if (uy >= lev_fieldy-1 || !IS_BELT(Feld[ux][uy+1])) { - if (element == EL_FELSBROCKEN || + if (element == EL_ROCK || element == EL_SP_ZONK || element == EL_BD_ROCK) { @@ -1275,21 +1462,21 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, graphic += phase2; } } - else if (element == EL_MAGIC_WALL_EMPTY || + else if (element == EL_MAGIC_WALL_ACTIVE || element == EL_MAGIC_WALL_EMPTYING || - element == EL_MAGIC_WALL_BD_EMPTY || - element == EL_MAGIC_WALL_BD_EMPTYING || + element == EL_BD_MAGIC_WALL_ACTIVE || + element == EL_BD_MAGIC_WALL_EMPTYING || element == EL_MAGIC_WALL_FULL || - element == EL_MAGIC_WALL_BD_FULL) + element == EL_BD_MAGIC_WALL_FULL) { graphic += 3 + getGraphicAnimationPhase(4, 4, ANIM_REVERSE); } else if (IS_AMOEBOID(element) || element == EL_AMOEBA_DRIPPING) { - graphic = (element == EL_AMOEBE_TOT ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT); + graphic = (element == EL_AMOEBA_DEAD ? GFX_AMOEBE_TOT : GFX_AMOEBE_LEBT); graphic += (x + 2 * y + 4) % 4; } - else if (element == EL_MAUER_LEBT) + else if (element == EL_WALL_GROWING) { boolean links_massiv = FALSE, rechts_massiv = FALSE; @@ -1305,14 +1492,16 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, else if (rechts_massiv) graphic = GFX_MAUER_L; } - else if ((element == EL_INVISIBLE_STEEL || - element == EL_UNSICHTBAR || - element == EL_SAND_INVISIBLE) && game.light_time_left) +#if 0 + else if ((element == EL_INVISIBLE_STEELWALL || + element == EL_INVISIBLE_WALL || + element == EL_INVISIBLE_SAND) && game.light_time_left) { - graphic = (element == EL_INVISIBLE_STEEL ? GFX_INVISIBLE_STEEL_ON : - element == EL_UNSICHTBAR ? GFX_UNSICHTBAR_ON : + graphic = (element == EL_INVISIBLE_STEELWALL ? GFX_INVISIBLE_STEEL_ON : + element == EL_INVISIBLE_WALL ? GFX_UNSICHTBAR_ON : GFX_SAND_INVISIBLE_ON); } +#endif if (dx || dy) DrawGraphicShifted(x, y, dx, dy, graphic, cut_mode, mask_mode); @@ -1322,6 +1511,110 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element, DrawGraphic(x, y, graphic); } +inline static int getFramePosition(int x, int y) +{ + int element = Feld[x][y]; + int frame_pos = -1; + + if (element == EL_QUICKSAND_FULL || + element == EL_MAGIC_WALL_FULL || + element == EL_BD_MAGIC_WALL_FULL) + frame_pos = -1; + else if (IS_MOVING(x, y) || CAN_MOVE(element) || CAN_FALL(element)) + frame_pos = ABS(MovPos[x][y]) / (TILEX / 8); + + return frame_pos; +} + +inline static int getGfxAction(int x, int y) +{ + int gfx_action = GFX_ACTION_DEFAULT; + + if (GfxAction[x][y] != GFX_ACTION_DEFAULT) + gfx_action = GfxAction[x][y]; + else if (IS_MOVING(x, y)) + gfx_action = GFX_ACTION_MOVING; + + return gfx_action; +} + +void DrawNewScreenElementExt(int x, int y, int dx, int dy, int element, + int cut_mode, int mask_mode) +{ + int ux = LEVELX(x), uy = LEVELY(y); + int move_dir = MovDir[ux][uy]; + int move_pos = getFramePosition(ux, uy); + int gfx_action = getGfxAction(ux, uy); + int graphic = el_dir_act2img(element, move_dir, gfx_action); + int frame = getNewGraphicAnimationFrame(graphic, move_pos); + + if (element == EL_WALL_GROWING) + { + boolean left_stopped = FALSE, right_stopped = FALSE; + + if (!IN_LEV_FIELD(ux - 1, uy) || IS_MAUER(Feld[ux - 1][uy])) + left_stopped = TRUE; + if (!IN_LEV_FIELD(ux + 1, uy) || IS_MAUER(Feld[ux + 1][uy])) + right_stopped = TRUE; + + if (left_stopped && right_stopped) + graphic = IMG_WALL; + else if (left_stopped) + { + graphic = IMG_WALL_GROWING_ACTIVE_RIGHT; + frame = new_graphic_info[graphic].anim_frames - 1; + } + else if (right_stopped) + { + graphic = IMG_WALL_GROWING_ACTIVE_LEFT; + frame = new_graphic_info[graphic].anim_frames - 1; + } + } +#if 0 + else if ((element == EL_ROCK || + element == EL_SP_ZONK || + element == EL_BD_ROCK || + element == EL_SP_INFOTRON || + IS_GEM(element)) + && !cut_mode) + { + if (uy >= lev_fieldy-1 || !IS_BELT(Feld[ux][uy+1])) + { + if (element == EL_ROCK || + element == EL_SP_ZONK || + element == EL_BD_ROCK) + { + if (move_dir == MV_LEFT) + graphic += (4 - phase4) % 4; + else if (move_dir == MV_RIGHT) + graphic += phase4; + else + graphic += phase2 * 2; + } + else if (element != EL_SP_INFOTRON) + graphic += phase2; + } + } +#endif + else if (IS_AMOEBOID(element) || element == EL_AMOEBA_DRIPPING) + { + graphic = (element == EL_BD_AMOEBA ? IMG_BD_AMOEBA_PART1 : + element == EL_AMOEBA_WET ? IMG_AMOEBA_WET_PART1 : + element == EL_AMOEBA_DRY ? IMG_AMOEBA_DRY_PART1 : + element == EL_AMOEBA_FULL ? IMG_AMOEBA_FULL_PART1 : + IMG_AMOEBA_DEAD_PART1); + + graphic += (x + 2 * y + 4) % 4; + } + + if (dx || dy) + DrawNewGraphicShifted(x, y, dx, dy, graphic, frame, cut_mode, mask_mode); + else if (mask_mode == USE_MASKING) + DrawNewGraphicThruMask(x, y, graphic, frame); + else + DrawNewGraphic(x, y, graphic, frame); +} + void DrawLevelElementExt(int x, int y, int dx, int dy, int element, int cut_mode, int mask_mode) { @@ -1330,33 +1623,68 @@ void DrawLevelElementExt(int x, int y, int dx, int dy, int element, cut_mode, mask_mode); } +void DrawNewLevelElementExt(int x, int y, int dx, int dy, int element, + int cut_mode, int mask_mode) +{ + if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y))) + DrawNewScreenElementExt(SCREENX(x), SCREENY(y), dx, dy, element, + cut_mode, mask_mode); +} + void DrawScreenElementShifted(int x, int y, int dx, int dy, int element, int cut_mode) { DrawScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING); } +void DrawNewScreenElementShifted(int x, int y, int dx, int dy, int element, + int cut_mode) +{ + DrawNewScreenElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING); +} + void DrawLevelElementShifted(int x, int y, int dx, int dy, int element, int cut_mode) { DrawLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING); } +void DrawNewLevelElementShifted(int x, int y, int dx, int dy, int element, + int cut_mode) +{ + DrawNewLevelElementExt(x, y, dx, dy, element, cut_mode, NO_MASKING); +} + void DrawScreenElementThruMask(int x, int y, int element) { DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING); } +void DrawNewScreenElementThruMask(int x, int y, int element) +{ + DrawNewScreenElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING); +} + void DrawLevelElementThruMask(int x, int y, int element) { DrawLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING); } +void DrawNewLevelElementThruMask(int x, int y, int element) +{ + DrawNewLevelElementExt(x, y, 0, 0, element, NO_CUTTING, USE_MASKING); +} + void DrawLevelFieldThruMask(int x, int y) { DrawLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING); } +void DrawNewLevelFieldThruMask(int x, int y) +{ + DrawNewLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING); +} + void ErdreichAnbroeckeln(int x, int y) { Bitmap *src_bitmap; @@ -1378,9 +1706,9 @@ void ErdreichAnbroeckeln(int x, int y) element = Feld[ux][uy]; - if (element == EL_ERDREICH || + if (element == EL_SAND || element == EL_LANDMINE || - element == EL_TRAP_INACTIVE || + element == EL_TRAP || element == EL_TRAP_ACTIVE) { if (!IN_SCR_FIELD(x, y)) @@ -1397,13 +1725,13 @@ void ErdreichAnbroeckeln(int x, int y) uxx = ux + xy[i][0]; uyy = uy + xy[i][1]; if (!IN_LEV_FIELD(uxx, uyy)) - element = EL_BETON; + element = EL_STEELWALL; else element = Feld[uxx][uyy]; - if (element == EL_ERDREICH || + if (element == EL_SAND || element == EL_LANDMINE || - element == EL_TRAP_INACTIVE || + element == EL_TRAP || element == EL_TRAP_ACTIVE) continue; @@ -1444,9 +1772,9 @@ 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_SAND && Feld[uxx][uyy] != EL_LANDMINE && - Feld[uxx][uyy] != EL_TRAP_INACTIVE && + Feld[uxx][uyy] != EL_TRAP && Feld[uxx][uyy] != EL_TRAP_ACTIVE) || !IN_SCR_FIELD(xx, yy)) continue; @@ -1480,12 +1808,24 @@ void DrawScreenElement(int x, int y, int element) ErdreichAnbroeckeln(x, y); } +void DrawNewScreenElement(int x, int y, int element) +{ + DrawNewScreenElementExt(x, y, 0, 0, element, NO_CUTTING, NO_MASKING); + ErdreichAnbroeckeln(x, y); +} + void DrawLevelElement(int x, int y, int element) { if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y))) DrawScreenElement(SCREENX(x), SCREENY(y), element); } +void DrawNewLevelElement(int x, int y, int element) +{ + if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y))) + DrawNewScreenElement(SCREENX(x), SCREENY(y), element); +} + void DrawScreenField(int x, int y) { int ux = LEVELX(x), uy = LEVELY(y); @@ -1494,7 +1834,7 @@ void DrawScreenField(int x, int y) if (!IN_LEV_FIELD(ux, uy)) { if (ux < -1 || ux > lev_fieldx || uy < -1 || uy > lev_fieldy) - element = EL_LEERRAUM; + element = EL_EMPTY; else element = BorderElement; @@ -1512,18 +1852,18 @@ void DrawScreenField(int x, int y) if (element == EL_QUICKSAND_EMPTYING || element == EL_MAGIC_WALL_EMPTYING || - element == EL_MAGIC_WALL_BD_EMPTYING || + element == EL_BD_MAGIC_WALL_EMPTYING || element == EL_AMOEBA_DRIPPING) cut_mode = CUT_ABOVE; else if (element == EL_QUICKSAND_FILLING || element == EL_MAGIC_WALL_FILLING || - element == EL_MAGIC_WALL_BD_FILLING) + element == EL_BD_MAGIC_WALL_FILLING) cut_mode = CUT_BELOW; if (cut_mode == CUT_ABOVE) DrawScreenElementShifted(x, y, 0, 0, element, NO_CUTTING); else - DrawScreenElement(x, y, EL_LEERRAUM); + DrawScreenElement(x, y, EL_EMPTY); if (horiz_move) DrawScreenElementShifted(x, y, MovPos[ux][uy], 0, element, NO_CUTTING); @@ -1532,8 +1872,8 @@ void DrawScreenField(int x, int y) else DrawScreenElementShifted(x, y, 0, MovPos[ux][uy], content, cut_mode); - if (content == EL_SALZSAEURE) - DrawLevelElementThruMask(ux, uy + 1, EL_SALZSAEURE); + if (content == EL_ACID) + DrawLevelElementThruMask(ux, uy + 1, EL_ACID); } else if (IS_BLOCKED(ux, uy)) { @@ -1554,11 +1894,11 @@ void DrawScreenField(int x, int y) if (element_old == EL_QUICKSAND_EMPTYING || element_old == EL_MAGIC_WALL_EMPTYING || - element_old == EL_MAGIC_WALL_BD_EMPTYING || + element_old == EL_BD_MAGIC_WALL_EMPTYING || element_old == EL_AMOEBA_DRIPPING) cut_mode = CUT_ABOVE; - DrawScreenElement(x, y, EL_LEERRAUM); + DrawScreenElement(x, y, EL_EMPTY); if (horiz_move) DrawScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old, @@ -1573,7 +1913,97 @@ void DrawScreenField(int x, int y) else if (IS_DRAWABLE(element)) DrawScreenElement(x, y, element); else - DrawScreenElement(x, y, EL_LEERRAUM); + DrawScreenElement(x, y, EL_EMPTY); +} + +void DrawNewScreenField(int x, int y) +{ + int ux = LEVELX(x), uy = LEVELY(y); + int element, content; + + if (!IN_LEV_FIELD(ux, uy)) + { + if (ux < -1 || ux > lev_fieldx || uy < -1 || uy > lev_fieldy) + element = EL_EMPTY; + else + element = BorderElement; + + DrawNewScreenElement(x, y, element); + return; + } + + element = Feld[ux][uy]; + content = Store[ux][uy]; + + if (IS_MOVING(ux, uy)) + { + int horiz_move = (MovDir[ux][uy] == MV_LEFT || MovDir[ux][uy] == MV_RIGHT); + boolean cut_mode = NO_CUTTING; + + if (element == EL_QUICKSAND_EMPTYING || + element == EL_MAGIC_WALL_EMPTYING || + element == EL_BD_MAGIC_WALL_EMPTYING || + element == EL_AMOEBA_DRIPPING) + cut_mode = CUT_ABOVE; + else if (element == EL_QUICKSAND_FILLING || + element == EL_MAGIC_WALL_FILLING || + element == EL_BD_MAGIC_WALL_FILLING) + cut_mode = CUT_BELOW; + + if (cut_mode == CUT_ABOVE) + DrawNewScreenElementShifted(x, y, 0, 0, element, NO_CUTTING); + else + DrawNewScreenElement(x, y, EL_EMPTY); + + if (horiz_move) + DrawNewScreenElementShifted(x, y, MovPos[ux][uy], 0, element, NO_CUTTING); + else if (cut_mode == NO_CUTTING) + DrawNewScreenElementShifted(x, y, 0, MovPos[ux][uy], element, cut_mode); + else + DrawNewScreenElementShifted(x, y, 0, MovPos[ux][uy], content, cut_mode); + + if (content == EL_ACID) + DrawNewLevelElementThruMask(ux, uy + 1, EL_ACID); + } + else if (IS_BLOCKED(ux, uy)) + { + int oldx, oldy; + int sx, sy; + int horiz_move; + boolean cut_mode = NO_CUTTING; + int element_old, content_old; + + Blocked2Moving(ux, uy, &oldx, &oldy); + sx = SCREENX(oldx); + sy = SCREENY(oldy); + horiz_move = (MovDir[oldx][oldy] == MV_LEFT || + MovDir[oldx][oldy] == MV_RIGHT); + + element_old = Feld[oldx][oldy]; + content_old = Store[oldx][oldy]; + + if (element_old == EL_QUICKSAND_EMPTYING || + element_old == EL_MAGIC_WALL_EMPTYING || + element_old == EL_BD_MAGIC_WALL_EMPTYING || + element_old == EL_AMOEBA_DRIPPING) + cut_mode = CUT_ABOVE; + + DrawNewScreenElement(x, y, EL_EMPTY); + + if (horiz_move) + DrawNewScreenElementShifted(sx, sy, MovPos[oldx][oldy], 0, element_old, + NO_CUTTING); + else if (cut_mode == NO_CUTTING) + DrawNewScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], element_old, + cut_mode); + else + DrawNewScreenElementShifted(sx, sy, 0, MovPos[oldx][oldy], content_old, + cut_mode); + } + else if (IS_DRAWABLE(element)) + DrawNewScreenElement(x, y, element); + else + DrawNewScreenElement(x, y, EL_EMPTY); } void DrawLevelField(int x, int y) @@ -1598,6 +2028,28 @@ void DrawLevelField(int x, int y) } } +void DrawNewLevelField(int x, int y) +{ + if (IN_SCR_FIELD(SCREENX(x), SCREENY(y))) + DrawNewScreenField(SCREENX(x), SCREENY(y)); + else if (IS_MOVING(x, y)) + { + int newx,newy; + + Moving2Blocked(x, y, &newx, &newy); + if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy))) + DrawNewScreenField(SCREENX(newx), SCREENY(newy)); + } + else if (IS_BLOCKED(x, y)) + { + int oldx, oldy; + + Blocked2Moving(x, y, &oldx, &oldy); + if (IN_SCR_FIELD(SCREENX(oldx), SCREENY(oldy))) + DrawNewScreenField(SCREENX(oldx), SCREENY(oldy)); + } +} + void DrawMiniElement(int x, int y, int element) { int graphic; @@ -1612,12 +2064,28 @@ void DrawMiniElement(int x, int y, int element) DrawMiniGraphic(x, y, graphic); } +void DrawNewMiniElement(int x, int y, int element) +{ + int graphic; + +#if 0 + if (!element) + { + DrawNewMiniGraphic(x, y, -1); + return; + } +#endif + + graphic = el2img(element); + DrawNewMiniGraphic(x, y, graphic); +} + void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y) { int x = sx + scroll_x, y = sy + scroll_y; if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy) - DrawMiniElement(sx, sy, EL_LEERRAUM); + DrawMiniElement(sx, sy, EL_EMPTY); else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy) DrawMiniElement(sx, sy, Feld[x][y]); else @@ -1633,7 +2101,7 @@ void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y) { GFX_VSTEEL_HORIZONTAL, GFX_ISTEEL_HORIZONTAL } }; - steel_type = (BorderElement == EL_BETON ? 0 : 1); + steel_type = (BorderElement == EL_STEELWALL ? 0 : 1); steel_position = (x == -1 && y == -1 ? 0 : x == lev_fieldx && y == -1 ? 1 : x == -1 && y == lev_fieldy ? 2 : @@ -1646,11 +2114,45 @@ void DrawMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y) } } +void DrawNewMiniElementOrWall(int sx, int sy, int scroll_x, int scroll_y) +{ + int x = sx + scroll_x, y = sy + scroll_y; + + if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy) + DrawNewMiniElement(sx, sy, EL_EMPTY); + else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy) + DrawNewMiniElement(sx, sy, Feld[x][y]); + else + { + int steel_type, steel_position; + int border[6][2] = + { + { IMG_STEELWALL_TOPLEFT, IMG_INVISIBLE_STEELWALL_TOPLEFT }, + { IMG_STEELWALL_TOPRIGHT, IMG_INVISIBLE_STEELWALL_TOPRIGHT }, + { IMG_STEELWALL_BOTTOMLEFT, IMG_INVISIBLE_STEELWALL_BOTTOMLEFT }, + { IMG_STEELWALL_BOTTOMRIGHT, IMG_INVISIBLE_STEELWALL_BOTTOMRIGHT }, + { IMG_STEELWALL_VERTICAL, IMG_INVISIBLE_STEELWALL_VERTICAL }, + { IMG_STEELWALL_HORIZONTAL, IMG_INVISIBLE_STEELWALL_HORIZONTAL } + }; + + steel_type = (BorderElement == EL_STEELWALL ? 0 : 1); + steel_position = (x == -1 && y == -1 ? 0 : + x == lev_fieldx && y == -1 ? 1 : + x == -1 && y == lev_fieldy ? 2 : + x == lev_fieldx && y == lev_fieldy ? 3 : + x == -1 || x == lev_fieldx ? 4 : + y == -1 || y == lev_fieldy ? 5 : -1); + + if (steel_position != -1) + DrawNewMiniGraphic(sx, sy, border[steel_position][steel_type]); + } +} + void DrawMicroElement(int xpos, int ypos, int element) { int graphic; - if (element == EL_LEERRAUM) + if (element == EL_EMPTY) return; graphic = el2gfx(element); @@ -1702,7 +2204,7 @@ void DrawLevel() for(x=BX1; x<=BX2; x++) for(y=BY1; y<=BY2; y++) - DrawScreenField(x, y); + DrawNewScreenField(x, y); redraw_mask |= REDRAW_FIELD; } @@ -1718,6 +2220,17 @@ void DrawMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y) redraw_mask |= REDRAW_FIELD; } +void DrawNewMiniLevel(int size_x, int size_y, int scroll_x, int scroll_y) +{ + int x,y; + + for(x=0; x graphic %d -- probably crashing now...", + element, graphic_NEW); +#endif + + return graphic_NEW; +#else + + switch(element) + { + case EL_BD_BUTTERFLY: return IMG_BD_BUTTERFLY; + case EL_BD_FIREFLY: return IMG_BD_FIREFLY; + case EL_SP_ELECTRON: return IMG_SP_ELECTRON; + + default: + break; + } + + return IMG_EMPTY; +#endif +} + +int el_dir2img(int element, int direction) +{ + return el_dir_act2img(element, direction, GFX_ACTION_DEFAULT); +} + +int el_dir_act2img(int element, int direction, int action) +{ + action = graphics_action_mapping[action]; + direction = MV_DIR_BIT(direction); + + return element_info[element].direction_graphic[action][direction]; }