X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Fgame_mm%2Fmm_tools.c;h=12ca83cee8e22041ee608e659ad1f106c5d1ac3a;hp=9f52eb735e5039bc60e157b0bd78d224b7909139;hb=HEAD;hpb=a601eb5bd800d544e8a5154a7b4d2457d020cd3f diff --git a/src/game_mm/mm_tools.c b/src/game_mm/mm_tools.c index 9f52eb73..12ca83ce 100644 --- a/src/game_mm/mm_tools.c +++ b/src/game_mm/mm_tools.c @@ -1,15 +1,15 @@ -/*********************************************************** -* Mirror Magic -- McDuffin's Revenge * -*----------------------------------------------------------* -* (c) 1994-2001 Artsoft Entertainment * -* Holger Schemel * -* Detmolder Strasse 189 * -* 33604 Bielefeld * -* Germany * -* e-mail: info@artsoft.org * -*----------------------------------------------------------* -* tools.c * -***********************************************************/ +// ============================================================================ +// Mirror Magic -- McDuffin's Revenge +// ---------------------------------------------------------------------------- +// (c) 1994-2017 by Artsoft Entertainment +// Holger Schemel +// info@artsoft.org +// https://www.artsoft.org/ +// ---------------------------------------------------------------------------- +// mm_tools.c +// ============================================================================ + +#include #include "main_mm.h" @@ -17,11 +17,43 @@ #include "mm_tools.h" -void ClearWindow() +void SetDrawtoField_MM(int mode) { - ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE); + int full_xsize = lev_fieldx * TILESIZE_VAR; + int full_ysize = lev_fieldy * TILESIZE_VAR; - SetDrawtoField(DRAW_BACKBUFFER); + // distance (delta) from screen border (SX/SY) to centered level playfield + dSX = (full_xsize < SXSIZE ? (SXSIZE - full_xsize) / 2 : 0); + dSY = (full_ysize < SYSIZE ? (SYSIZE - full_ysize) / 2 : 0); + + // for convenience, absolute screen position to centered level playfield + cSX = SX + dSX; + cSY = SY + dSY; + cSX2 = SX + dSX + 2; // including half laser line size + cSY2 = SY + dSY + 2; // including half laser line size + + if (mode == DRAW_TO_BACKBUFFER) + { + cFX = FX + dSX; + cFY = FY + dSY; + } + + SetTileCursorSXSY(cSX, cSY); +} + +void BackToFront_MM(void) +{ + BlitScreenToBitmap_MM(backbuffer); + + BackToFront(); +} + +void ClearWindow(void) +{ + ClearRectangle(drawto_mm, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE); + + SetDrawtoField(DRAW_TO_BACKBUFFER); + SetDrawtoField_MM(DRAW_TO_BACKBUFFER); redraw_mask |= REDRAW_FIELD; } @@ -33,22 +65,27 @@ void DrawGraphicAnimation_MM(int x, int y, int graphic, int frame) getGraphicSource(graphic, frame, &bitmap, &src_x, &src_y); - BlitBitmap(bitmap, drawto_field, src_x, src_y, TILEX, TILEY, - FX + x * TILEX, FY + y * TILEY); + BlitBitmap(bitmap, drawto_mm, src_x, src_y, TILEX, TILEY, + cFX + x * TILEX, cFY + y * TILEY); } void DrawGraphic_MM(int x, int y, int graphic) { #if DEBUG - if (!IN_SCR_FIELD(x,y)) + if (!IN_SCR_FIELD(x, y)) { - printf("DrawGraphic_MM(): x = %d, y = %d, graphic = %d\n",x,y,graphic); - printf("DrawGraphic_MM(): This should never happen!\n"); + Debug("game:mm:DrawGraphic_MM", "x = %d, y = %d, graphic = %d", + x, y, graphic); + Debug("game:mm:DrawGraphic_MM", "This should never happen!"); + return; } #endif - DrawGraphicExt_MM(drawto_field, FX + x*TILEX, FY + y*TILEY, graphic); + int frame = getGraphicAnimationFrameXY(graphic, x, y); + + DrawGraphicAnimation_MM(x, y, graphic, frame); + MarkTileDirty(x, y); } @@ -58,26 +95,31 @@ void DrawGraphicExt_MM(DrawBuffer *d, int x, int y, int graphic) int src_x, src_y; getGraphicSource(graphic, 0, &bitmap, &src_x, &src_y); + BlitBitmap(bitmap, d, src_x, src_y, TILEX, TILEY, x, y); } -void DrawGraphicThruMask_MM(int x, int y, int graphic) +void DrawGraphicThruMask_MM(int x, int y, int graphic, int frame) { #if DEBUG - if (!IN_SCR_FIELD(x,y)) + if (!IN_SCR_FIELD(x, y)) { - printf("DrawGraphicThruMask_MM(): x = %d,y = %d, graphic = %d\n",x,y,graphic); - printf("DrawGraphicThruMask_MM(): This should never happen!\n"); + Debug("game:mm:DrawGraphicThruMask_MM", "x = %d, y = %d, graphic = %d", + x, y, graphic); + Debug("game:mm:DrawGraphicThruMask_MM", "This should never happen!"); + return; } #endif - DrawGraphicThruMaskExt_MM(drawto_field, FX + x*TILEX, FY + y*TILEY, graphic); - MarkTileDirty(x,y); + DrawGraphicThruMaskExt_MM(drawto_mm, cFX + x * TILEX, cFY + y * TILEY, + graphic, frame); + + MarkTileDirty(x, y); } void DrawGraphicThruMaskExt_MM(DrawBuffer *d, int dest_x, int dest_y, - int graphic) + int graphic, int frame) { int src_x, src_y; Bitmap *src_bitmap; @@ -85,20 +127,17 @@ void DrawGraphicThruMaskExt_MM(DrawBuffer *d, int dest_x, int dest_y, if (graphic == IMG_EMPTY) return; - getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y); + getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y); BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dest_x, dest_y); } void DrawMiniGraphic_MM(int x, int y, int graphic) { - DrawMiniGraphicExt_MM(drawto, SX + x*MINI_TILEX, SY + y*MINI_TILEY, graphic); - MarkTileDirty(x/2, y/2); -} + DrawMiniGraphicExt_MM(drawto_mm, cSX + x * MINI_TILEX, cSY + y * MINI_TILEY, + graphic); -void getMicroGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y) -{ - getSizedGraphicSource(graphic, 0, TILESIZE / 4, bitmap, x, y); + MarkTileDirty(x / 2, y / 2); } void DrawMiniGraphicExt_MM(DrawBuffer *d, int x, int y, int graphic) @@ -107,11 +146,12 @@ void DrawMiniGraphicExt_MM(DrawBuffer *d, int x, int y, int graphic) int src_x, src_y; getMiniGraphicSource(graphic, &bitmap, &src_x, &src_y); + BlitBitmap(bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y); } -void DrawGraphicShifted_MM(int x,int y, int dx,int dy, int graphic, - int cut_mode, int mask_mode) +void DrawGraphicShifted_MM(int x, int y, int dx, int dy, int graphic, + int cut_mode, int mask_mode) { int width = TILEX, height = TILEY; int cx = 0, cy = 0; @@ -121,38 +161,39 @@ void DrawGraphicShifted_MM(int x,int y, int dx,int dy, int graphic, if (graphic < 0) { DrawGraphic_MM(x, y, graphic); + return; } - if (dx || dy) /* Verschiebung der Grafik? */ + if (dx || dy) // Verschiebung der Grafik? { - if (x < BX1) /* Element kommt von links ins Bild */ + 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 */ + 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 */ + 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 */ + else if (x==BX2 && dx > 0) // Element verläßt rechts das Bild width -= dx; - else if (dx) /* allg. Bewegung in x-Richtung */ + else if (dx) // allg. Bewegung in x-Richtung MarkTileDirty(x + SIGN(dx), y); - if (y < BY1) /* Element kommt von oben ins Bild */ + if (y < BY1) // Element kommt von oben ins Bild { - if (cut_mode==CUT_BELOW) /* Element oberhalb des Bildes */ + if (cut_mode==CUT_BELOW) // Element oberhalb des Bildes return; y = BY1; @@ -160,13 +201,13 @@ void DrawGraphicShifted_MM(int x,int y, int dx,int dy, int graphic, cy = TILEY - dy; dy = 0; } - else if (y > BY2) /* Element kommt von unten ins Bild */ + 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 */ + else if (y==BY1 && dy < 0) // Element verläßt oben das Bild { height += dy; cy = -dy; @@ -174,18 +215,22 @@ void DrawGraphicShifted_MM(int x,int y, int dx,int dy, int graphic, } else if (dy > 0 && cut_mode == CUT_ABOVE) { - if (y == BY2) /* Element unterhalb des Bildes */ + 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 */ + } // 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 */ + } + else if (dy) // allg. Bewegung in y-Richtung + { MarkTileDirty(x, y + SIGN(dy)); + } } getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y); @@ -193,34 +238,28 @@ void DrawGraphicShifted_MM(int x,int y, int dx,int dy, int graphic, src_x += cx; src_y += cy; - dest_x = FX + x * TILEX + dx; - dest_y = FY + y * TILEY + dy; + dest_x = cFX + x * TILEX + dx; + dest_y = cFY + y * TILEY + dy; #if DEBUG - if (!IN_SCR_FIELD(x,y)) + if (!IN_SCR_FIELD(x, y)) { - printf("DrawGraphicShifted_MM(): x = %d, y = %d, graphic = %d\n",x,y,graphic); - printf("DrawGraphicShifted_MM(): This should never happen!\n"); + Debug("game:mm:DrawGraphicShifted_MM", "x = %d, y = %d, graphic = %d", + x, y, graphic); + Debug("game:mm:DrawGraphicShifted_MM", "This should never happen!"); + return; } #endif if (mask_mode == USE_MASKING) - { - BlitBitmapMasked(src_bitmap, drawto_field, + BlitBitmapMasked(src_bitmap, drawto_mm, src_x, src_y, TILEX, TILEY, dest_x, dest_y); - } else - BlitBitmap(src_bitmap, drawto_field, + BlitBitmap(src_bitmap, drawto_mm, src_x, src_y, width, height, dest_x, dest_y); - MarkTileDirty(x,y); -} - -void DrawGraphicShiftedThruMask_MM(int x,int y, int dx,int dy, int graphic, - int cut_mode) -{ - DrawGraphicShifted_MM(x,y, dx,dy, graphic, cut_mode, USE_MASKING); + MarkTileDirty(x, y); } void DrawScreenElementExt_MM(int x, int y, int dx, int dy, int element, @@ -247,7 +286,7 @@ void DrawScreenElementExt_MM(int x, int y, int dx, int dy, int element, if (dx || dy) DrawGraphicShifted_MM(x, y, dx, dy, graphic, cut_mode, mask_mode); else if (mask_mode == USE_MASKING) - DrawGraphicThruMask_MM(x, y, graphic); + DrawGraphicThruMask_MM(x, y, graphic, 0); else DrawGraphic_MM(x, y, graphic); } @@ -266,41 +305,14 @@ void DrawScreenElementShifted_MM(int x, int y, int dx, int dy, int element, DrawScreenElementExt_MM(x, y, dx, dy, element, cut_mode, NO_MASKING); } -void DrawLevelElementShifted_MM(int x, int y, int dx, int dy, int element, - int cut_mode) -{ - DrawLevelElementExt_MM(x, y, dx, dy, element, cut_mode, NO_MASKING); -} - -void DrawScreenElementThruMask_MM(int x, int y, int element) -{ - DrawScreenElementExt_MM(x, y, 0, 0, element, NO_CUTTING, USE_MASKING); -} - -void DrawLevelElementThruMask_MM(int x, int y, int element) -{ - DrawLevelElementExt_MM(x, y, 0, 0, element, NO_CUTTING, USE_MASKING); -} - -void DrawLevelFieldThruMask_MM(int x, int y) -{ - DrawLevelElementExt_MM(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING); -} - void DrawScreenElement_MM(int x, int y, int element) { DrawScreenElementExt_MM(x, y, 0, 0, element, NO_CUTTING, NO_MASKING); } -void DrawLevelElement_MM(int x, int y, int element) -{ - if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y))) - DrawScreenElement_MM(SCREENX(x), SCREENY(y), element); -} - void DrawScreenField_MM(int x, int y) { - int element = Feld[x][y]; + int element = Tile[x][y]; if (!IN_LEV_FIELD(x, y)) return; @@ -323,28 +335,53 @@ void DrawScreenField_MM(int x, int y) int horiz_move; Blocked2Moving(x, y, &oldx, &oldy); + sx = SCREENX(oldx); sy = SCREENY(oldy); horiz_move = (MovDir[oldx][oldy] == MV_LEFT || MovDir[oldx][oldy] == MV_RIGHT); DrawScreenElement_MM(x, y, EL_EMPTY); - element = Feld[oldx][oldy]; + + element = Tile[oldx][oldy]; if (horiz_move) - DrawScreenElementShifted_MM(sx,sy, MovPos[oldx][oldy],0,element,NO_CUTTING); + DrawScreenElementShifted_MM(sx, sy, MovPos[oldx][oldy], 0, element, + NO_CUTTING); else - DrawScreenElementShifted_MM(sx,sy, 0,MovPos[oldx][oldy],element,NO_CUTTING); + DrawScreenElementShifted_MM(sx, sy, 0, MovPos[oldx][oldy], element, + NO_CUTTING); } else if (IS_DRAWABLE(element)) + { DrawScreenElement_MM(x, y, element); + } else + { DrawScreenElement_MM(x, y, EL_EMPTY); + } } void DrawLevelField_MM(int x, int y) { - DrawScreenField_MM(x, y); + if (IN_SCR_FIELD(SCREENX(x), SCREENY(y))) + DrawScreenField_MM(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))) + DrawScreenField_MM(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))) + DrawScreenField_MM(SCREENX(oldx), SCREENY(oldy)); + } } void DrawMiniElement_MM(int x, int y, int element) @@ -354,10 +391,12 @@ void DrawMiniElement_MM(int x, int y, int element) if (!element) { DrawMiniGraphic_MM(x, y, IMG_EMPTY); + return; } graphic = el2gfx(element); + DrawMiniGraphic_MM(x, y, graphic); } @@ -368,24 +407,24 @@ void DrawMiniElementOrWall_MM(int sx, int sy, int scroll_x, int scroll_y) if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy) DrawMiniElement_MM(sx, sy, EL_EMPTY); else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy) - DrawMiniElement_MM(sx, sy, Feld[x][y]); + DrawMiniElement_MM(sx, sy, Tile[x][y]); } void DrawField_MM(int x, int y) { - int element = Feld[x][y]; + int element = Tile[x][y]; DrawElement_MM(x, y, element); } -void DrawLevel_MM() +void DrawLevel_MM(void) { - int x,y; + int x, y; ClearWindow(); - for (x=0; xtm_year, 0,0,-1 }; + time_t xsn_e1 = mktime(&xsn_t1); + int xsn_c0 = (25 * xsn_m3) << xsn_m1; + int xsn_c1 = (xsn_t1.tm_wday - xsn_m1) * !!xsn_t1.tm_wday; + + for (xsn_m0 = 5; xsn_m0 > 0; xsn_m0--) { - int xpos = MICROLEV_XPOS + x * MICRO_TILEX + MICRO_WALLX * (i % 2); - int ypos = MICROLEV_YPOS + y * MICRO_TILEY + MICRO_WALLY * (i / 2); + int xsn_c2 = (xsn_m0 > 4 ? 0 : xsn_c1) - xsn_m1 * xsn_m0; + int xsn_off = (xsn_m0 > 4 ? xsn_c0 : 0); + time_t xsn_e3 = xsn_e1 - xsn_c2 * xsn_c0; - if (element & (1 << i)) - BlitBitmap(bitmap, drawto, gx, gy, MICRO_WALLX, MICRO_WALLY, xpos, ypos); - else - ClearRectangle(drawto, xpos, ypos, MICRO_WALLX, MICRO_WALLY); + if (xsn_e0 > xsn_e3 - xsn_off && + xsn_e0 < xsn_e3 + xsn_off + xsn_c0) + return xsn_m0 * (xsn_m3 - xsn_m1); } + + return xsn_m0; } -void DrawMicroElement_MM(int x, int y, int element) +static void xsn_init_item(int nr) { - Bitmap *bitmap; - int graphic = el2gfx(element); - int gx, gy; + struct XsnItem *item = &xsn.items[nr]; - if (element == EL_EMPTY) - return; + item->type = XSN_RND(num_xsn_data); - if (IS_WALL(element)) + if (xsn.change_type != 0) { - DrawMicroWalls_MM(x, y, element); - return; + int new_x = XSN_RND(xsn.area_xsize / 3); + + item->x = (xsn.change_dir == 1 ? new_x : xsn.area_xsize - new_x); + item->y = XSN_RND(xsn.area_ysize); + } + else + { + item->x = XSN_RND(xsn.area_xsize - xsn_data[item->type].size); + item->y = XSN_RND(xsn.area_ysize / 10); } - getMicroGraphicSource(graphic, &bitmap, &gx, &gy); + item->dy = XSN_RND(xsn.max_dy + 1) + 1; + item->dx = XSN_RND(item->dy / 4 + 1) * (XSN_RND(1000) > 500 ? -1 : 1); - BlitBitmap(bitmap, drawto, gx, gy, MICRO_TILEX, MICRO_TILEY, - MICROLEV_XPOS + x * MICRO_TILEX, MICROLEV_YPOS + y * MICRO_TILEY); + item->active = 1; } -void DrawMicroLevelExt_MM(int xpos, int ypos) +static void xsn_update_item(int nr) { - int x,y; + struct XsnItem *item = &xsn.items[nr]; - ClearRectangle(drawto, xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE); + if (!item->active) + xsn_init_item(nr); - for (x=0; xdx) + + (xsn.change_type == 1 ? + XSN_RND(XSN_CHANGE_FACTOR + 1) - XSN_CHANGE_FACTOR / 2 : + XSN_RND(20)); - redraw_mask |= REDRAW_FIELD; + item->dx = MIN(MAX(-50, dx_new * xsn.change_dir), 50); + } + + int new_x = item->x + item->dx; + int new_y = item->y + item->dy; + + item->active = (new_y < xsn.area_ysize); + + if (xsn.change_type != 0) + item->active = (item->active && new_x > 0 && new_x < xsn.area_xsize); + + int item_size = xsn_data[item->type].size; + int half_item_size = item_size / 2; + int mid_x = new_x + half_item_size; + int mid_y = new_y + half_item_size; + int upper_border = xsn.area_ysize - xsn.max_height; + + if (item->active && + new_y >= upper_border && + new_x >= 0 && + new_x <= xsn.area_xsize - item_size && + mid_y >= xsn.height[mid_x] && + mid_y < xsn.area_ysize) + { + Bitmap *item_bitmap = xsn_data[item->type].bitmap; + SDL_Surface *surface = xsn.bitmap->surface; + SDL_Surface *surface_masked = xsn.bitmap->surface_masked; + int item_alpha = XSN_ALPHA_VALUE(81 + XSN_RND(20)); + int shrink = 1; + int i; + + xsn.bitmap->surface = surface_masked; + + SDLSetAlpha(item_bitmap->surface_masked, TRUE, item_alpha); + + // blit to masked surface instead of opaque surface + BlitBitmapMasked(item_bitmap, xsn.bitmap, 0, 0, item_size, item_size, + new_x, new_y - upper_border); + + SDLSetAlpha(item_bitmap->surface_masked, TRUE, XSN_ALPHA_DEFAULT); + + for (i = -half_item_size; i <= half_item_size; i++) + { + int xpos = mid_x + i; + + if (xpos >= 0 && xpos < xsn.area_xsize) + xsn.height[xpos] = MIN(new_y + ABS(i), xsn.height[xpos]); + } + + if (xsn.height[mid_x] <= upper_border + shrink) + { + int xpos1 = MAX(0, new_x - half_item_size); + int xpos2 = MIN(new_x + 3 * half_item_size, xsn.area_xsize); + int xsize = xpos2 - xpos1; + int ysize1 = XSN_RND(xsn.max_height - shrink); + int ysize2 = xsn.max_height - ysize1; + + SDLSetAlpha(surface_masked, FALSE, 0); + + FillRectangle(xsn.bitmap, xpos1, xsn.max_height, xsize, xsn.max_height, + BLACK_PIXEL); + BlitBitmapMasked(xsn.bitmap, xsn.bitmap, xpos1, 0, xsize, ysize1, + xpos1, xsn.max_height + shrink); + BlitBitmapMasked(xsn.bitmap, xsn.bitmap, xpos1, ysize1, xsize, ysize2, + xpos1, xsn.max_height + ysize1); + FillRectangle(xsn.bitmap, xpos1, 0, xsize, xsn.max_height, + BLACK_PIXEL); + BlitBitmapMasked(xsn.bitmap, xsn.bitmap, xpos1, xsn.max_height, + xsize, xsn.max_height, xpos1, 0); + + SDLSetAlpha(surface_masked, TRUE, xsn.alpha); + + for (i = xpos1; i < xpos2; i++) + xsn.height[i] = MIN(xsn.height[i] + shrink, xsn.area_ysize - 1); + } + + SDLFreeBitmapTextures(xsn.bitmap); + SDLCreateBitmapTextures(xsn.bitmap); + + xsn.bitmap->surface = surface; + + item->active = 0; + } + + item->dx += XSN_RND(XSN_CHANGE_FACTOR) * (XSN_RND(1000) > 500 ? -1 : 1); + + if (xsn.change_type == 0) + item->dx = MIN(MAX(-xsn.max_dx, item->dx), xsn.max_dx); + + item->x = new_x; + item->y = new_y; } -void DrawMiniLevel_MM(int size_x, int size_y, int scroll_x, int scroll_y) +static void xsn_update_change(void) { - int x,y; + if (XSN_RND(100) > 65) + { + xsn.change_dir = (XSN_RND(10) > 4 ? 1 : -1); + xsn.change_delay = XSN_RND(5) + 1; + xsn.change_type = 2; + } + else if (xsn.change_type == 2) + { + xsn.change_delay = XSN_RND(3) + 1; + xsn.change_type = 1; + } + else + { + xsn.change_delay = XSN_CHANGE_DELAY; + xsn.change_type = 0; + } +} + +static void DrawTileCursor_Xsn(int draw_target) +{ + static boolean initialized = FALSE; + static boolean started = FALSE; + static boolean active = FALSE; + static boolean debug = FALSE; + static DelayCounter check_delay = { XSN_CHECK_DELAY * 1000 }; + static DelayCounter start_delay = { 0 }; + static DelayCounter growth_delay = { 0 }; + static DelayCounter update_delay = { 0 }; + static DelayCounter change_delay = { 0 }; + static int percent = 0; + static int debug_value = 0; + boolean reinitialize = FALSE; + boolean active_last = active; + int i, x, y; + + if (draw_target != DRAW_TO_SCREEN) + return; - for(x=0; x 0); + + if ((active && !active_last) || setup.debug.xsn_mode != AUTO) + removeHideSetupEntry(&setup.debug.xsn_mode); + else if (!active && active_last) + setHideSetupEntry(&setup.debug.xsn_mode); + + if (setup.debug.xsn_mode == FALSE) + active = FALSE; + } + else if (tile_cursor.xsn_debug) + { + debug_value = (active ? 0 : MIN(debug_value + 1, XSN_DEBUG_STEPS)); + debug = TRUE; + active = FALSE; + + ResetDelayCounter(&check_delay); + + setup.debug.xsn_mode = (debug_value > 0); + tile_cursor.xsn_debug = FALSE; + } + + if (!active) + return; + + if (!initialized) + { + xsn.area_xsize = gfx.win_xsize; + xsn.area_ysize = gfx.win_ysize; + + for (i = 0; i < num_xsn_data; i++) + { + int size = xsn_data[i].size; + byte *bits = xsn_data[i].bits; + Bitmap *bitmap = CreateBitmap(size, size, DEFAULT_DEPTH); + + FillRectangle(bitmap, 0, 0, size, size, BLACK_PIXEL); + + for (y = 0; y < size; y++) + for (x = 0; x < size; x++) + if ((bits[y] >> x) & 0x01) + SDLPutPixel(bitmap, x, y, WHITE_PIXEL); + + SDL_Surface *surface = bitmap->surface; + + if ((bitmap->surface_masked = SDLGetNativeSurface(surface)) == NULL) + Fail("SDLGetNativeSurface() failed"); + + SDL_Surface *surface_masked = bitmap->surface_masked; + + SDL_SetColorKey(surface_masked, SET_TRANSPARENT_PIXEL, + SDL_MapRGB(surface_masked->format, 0x00, 0x00, 0x00)); + + SDLSetAlpha(surface, TRUE, XSN_ALPHA_DEFAULT); + SDLSetAlpha(surface_masked, TRUE, XSN_ALPHA_DEFAULT); + + xsn_data[i].bitmap = bitmap; + } + + srand((unsigned int)time(NULL)); + + initialized = TRUE; + } + + if (!active_last) + { + start_delay.value = (debug || setup.debug.xsn_mode == TRUE ? 0 : + (XSN_START_DELAY + XSN_RND(XSN_START_DELAY)) * 1000); + started = FALSE; + + ResetDelayCounter(&start_delay); + + reinitialize = TRUE; + } + + if (reinitialize) + { + xsn.num_items = 0; + xsn.max_items = percent * XSN_MAX_ITEMS / 100; + xsn.max_height = percent * XSN_MAX_HEIGHT / 100; + + xsn.max_dx = XSN_MAX_DX; + xsn.max_dy = XSN_MAX_DY; + + xsn.change_delay = XSN_CHANGE_DELAY; + xsn.change_type = 0; + xsn.change_dir = 0; + + xsn.alpha = XSN_ALPHA_DEFAULT; + + for (i = 0; i < xsn.max_items; i++) + xsn_init_item(i); + } + + if (xsn.area_xsize != gfx.win_xsize || + xsn.area_ysize != gfx.win_ysize || + reinitialize) + { + xsn.area_xsize = gfx.win_xsize; + xsn.area_ysize = gfx.win_ysize; + + if (xsn.bitmap != NULL) + FreeBitmap(xsn.bitmap); + + xsn.bitmap = CreateBitmap(xsn.area_xsize, xsn.max_height * 2, + DEFAULT_DEPTH); + + FillRectangle(xsn.bitmap, 0, 0, xsn.area_xsize, xsn.max_height, + BLACK_PIXEL); + + SDL_Surface *surface = xsn.bitmap->surface; + + if ((xsn.bitmap->surface_masked = SDLGetNativeSurface(surface)) == NULL) + Fail("SDLGetNativeSurface() failed"); + + SDL_Surface *surface_masked = xsn.bitmap->surface_masked; + + SDL_SetColorKey(surface_masked, SET_TRANSPARENT_PIXEL, + SDL_MapRGB(surface_masked->format, 0x00, 0x00, 0x00)); + + SDLSetAlpha(surface, TRUE, xsn.alpha); + SDLSetAlpha(surface_masked, TRUE, xsn.alpha); + + SDLCreateBitmapTextures(xsn.bitmap); + + for (i = 0; i < num_xsn_data; i++) + { + SDLFreeBitmapTextures(xsn_data[i].bitmap); + SDLCreateBitmapTextures(xsn_data[i].bitmap); + } + + if (xsn.height != NULL) + checked_free(xsn.height); + + xsn.height = checked_calloc(xsn.area_xsize * sizeof(int)); + + for (i = 0; i < xsn.area_xsize; i++) + xsn.height[i] = xsn.area_ysize - 1; + } + + if (!started) + { + if (!DelayReached(&start_delay)) + return; + + update_delay.value = XSN_UPDATE_DELAY; + growth_delay.value = XSN_GROWTH_DELAY * 1000; + change_delay.value = XSN_CHANGE_DELAY * 1000; + + ResetDelayCounter(&growth_delay); + ResetDelayCounter(&update_delay); + ResetDelayCounter(&change_delay); + + started = TRUE; + } + + if (xsn.num_items < xsn.max_items) + { + if (DelayReached(&growth_delay)) + { + xsn.num_items += XSN_RND(XSN_GROWTH_RATE * 2); + xsn.num_items = MIN(xsn.num_items, xsn.max_items); + } + } + + if (DelayReached(&update_delay)) + { + for (i = 0; i < xsn.num_items; i++) + xsn_update_item(i); + } + + if (DelayReached(&change_delay)) + { + xsn_update_change(); + + change_delay.value = xsn.change_delay * 1000; + } + + int xsn_alpha_dx = (gfx.mouse_y > xsn.area_ysize - xsn.max_height ? + (xsn.alpha > XSN_ALPHA_VISIBLE ? -1 : 0) : + (xsn.alpha < XSN_ALPHA_DEFAULT ? +1 : 0)); + + if (xsn_alpha_dx != 0) + { + xsn.alpha += xsn_alpha_dx; + + SDLSetAlpha(xsn.bitmap->surface_masked, TRUE, xsn.alpha); + + SDLFreeBitmapTextures(xsn.bitmap); + SDLCreateBitmapTextures(xsn.bitmap); + } + + BlitToScreenMasked(xsn.bitmap, 0, 0, xsn.area_xsize, xsn.max_height, + 0, xsn.area_ysize - xsn.max_height); + + for (i = 0; i < xsn.num_items; i++) + { + int dst_x = xsn.items[i].x; + int dst_y = xsn.items[i].y; + int type = xsn.items[i].type; + int size = xsn_data[type].size; + Bitmap *bitmap = xsn_data[type].bitmap; + + BlitToScreenMasked(bitmap, 0, 0, size, size, dst_x, dst_y); + } } -int REQ_in_range(int x, int y) +void DrawTileCursor_MM(int draw_target, int drawing_stage, + boolean tile_cursor_active) { - if (y > DY+249 && y < DY+278) + if (program.headless) + return; + + Bitmap *fade_bitmap; + Bitmap *src_bitmap; + int src_x, src_y; + int dst_x, dst_y; + int graphic = IMG_GLOBAL_TILE_CURSOR; + int frame = 0; + int tilesize = TILESIZE_VAR; + int width = tilesize; + int height = tilesize; + + if (!drawing_stage) + { + DrawTileCursor_Xsn(draw_target); + + return; + } + + if (!tile_cursor.enabled || + !tile_cursor.active || + !tile_cursor_active) + return; + + if (tile_cursor.moving) { - if (x > DX+1 && x < DX+48) - return 1; - else if (x > DX+51 && x < DX+98) - return 2; + int step = TILESIZE_VAR / 4; + int dx = tile_cursor.target_x - tile_cursor.x; + int dy = tile_cursor.target_y - tile_cursor.y; + + if (ABS(dx) < step) + tile_cursor.x = tile_cursor.target_x; + else + tile_cursor.x += SIGN(dx) * step; + + if (ABS(dy) < step) + tile_cursor.y = tile_cursor.target_y; + else + tile_cursor.y += SIGN(dy) * step; + + if (tile_cursor.x == tile_cursor.target_x && + tile_cursor.y == tile_cursor.target_y) + tile_cursor.moving = FALSE; } - return 0; + + dst_x = tile_cursor.x; + dst_y = tile_cursor.y; + + frame = getGraphicAnimationFrame(graphic, -1); + + getSizedGraphicSource(graphic, frame, tilesize, &src_bitmap, &src_x, &src_y); + + fade_bitmap = + (draw_target == DRAW_TO_FADE_SOURCE ? gfx.fade_bitmap_source : + draw_target == DRAW_TO_FADE_TARGET ? gfx.fade_bitmap_target : NULL); + + if (draw_target == DRAW_TO_SCREEN) + BlitToScreenMasked(src_bitmap, src_x, src_y, width, height, dst_x, dst_y); + else + BlitBitmapMasked(src_bitmap, fade_bitmap, src_x, src_y, width, height, + dst_x, dst_y); } Pixel ReadPixel(DrawBuffer *bitmap, int x, int y) @@ -585,11 +1129,6 @@ Pixel ReadPixel(DrawBuffer *bitmap, int x, int y) return GetPixel(bitmap, x, y); } -void SetRGB(unsigned int pixel, - unsigned short red, unsigned short green, unsigned short blue) -{ -} - int get_base_element(int element) { if (IS_MIRROR(element)) @@ -614,6 +1153,10 @@ int get_base_element(int element) return EL_DF_MIRROR_START; else if (IS_DF_MIRROR_AUTO(element)) return EL_DF_MIRROR_AUTO_START; + else if (IS_DF_MIRROR_FIXED(element)) + return EL_DF_MIRROR_FIXED_START; + else if (IS_DF_SLOPE(element)) + return EL_DF_SLOPE_START; else if (IS_PACMAN(element)) return EL_PACMAN_START; else if (IS_GRID_STEEL(element)) @@ -657,7 +1200,8 @@ int get_num_elements(int element) IS_POLAR(element) || IS_BEAMER(element) || IS_DF_MIRROR(element) || - IS_DF_MIRROR_AUTO(element)) + IS_DF_MIRROR_AUTO(element) || + IS_DF_MIRROR_FIXED(element)) return 16; else if (IS_GRID_STEEL_FIXED(element) || IS_GRID_WOOD_FIXED(element) || @@ -671,7 +1215,8 @@ int get_num_elements(int element) IS_RECEIVER(element) || IS_PACMAN(element) || IS_GRID_STEEL(element) || - IS_GRID_WOOD(element)) + IS_GRID_WOOD(element) || + IS_DF_SLOPE(element)) return 4; else return 1; @@ -686,42 +1231,158 @@ int get_rotated_element(int element, int step) return base_element + (element_phase + step + num_elements) % num_elements; } -static int map_element(int element) +static boolean has_full_rotation(int element) +{ + return (IS_BEAMER(element) || + IS_MCDUFFIN(element) || + IS_LASER(element) || + IS_RECEIVER(element) || + IS_PACMAN(element)); +} + +#define MM_FLIP_X 0 +#define MM_FLIP_Y 1 +#define MM_FLIP_XY 2 + +static int getFlippedTileExt_MM(int element, int mode) +{ + if (IS_WALL(element)) + { + int base = WALL_BASE(element); + int bits = WALL_BITS(element); + + if (mode == MM_FLIP_X) + { + bits = ((bits & 1) << 1 | + (bits & 2) >> 1 | + (bits & 4) << 1 | + (bits & 8) >> 1); + } + else if (mode == MM_FLIP_Y) + { + bits = ((bits & 1) << 2 | + (bits & 2) << 2 | + (bits & 4) >> 2 | + (bits & 8) >> 2); + } + else if (mode == MM_FLIP_XY) + { + bits = ((bits & 1) << 0 | + (bits & 2) << 1 | + (bits & 4) >> 1 | + (bits & 8) >> 0); + } + + element = base | bits; + } + else + { + int base_element = get_base_element(element); + int num_elements = get_num_elements(element); + int element_phase = element - base_element; + + if (IS_GRID_STEEL(element) || IS_GRID_WOOD(element)) + { + if ((mode == MM_FLIP_XY && element_phase < 2) || + (mode != MM_FLIP_XY && element_phase > 1)) + element_phase ^= 1; + } + else if (IS_DF_SLOPE(element)) + { + element_phase = (mode == MM_FLIP_X ? 5 - element_phase : + mode == MM_FLIP_Y ? 3 - element_phase : + mode == MM_FLIP_XY ? 4 - element_phase : + element_phase); + } + else + { + int num_elements_flip = num_elements; + + if (has_full_rotation(element)) + { + if (mode == MM_FLIP_X) + num_elements_flip = num_elements / 2; + else if (mode == MM_FLIP_XY) + num_elements_flip = num_elements * 3 / 4; + } + else + { + if (mode == MM_FLIP_XY) + num_elements_flip = num_elements / 2; + } + + element_phase = num_elements_flip - element_phase; + } + + element = base_element + (element_phase + num_elements) % num_elements; + } + + return element; +} + +int getFlippedTileX_MM(int element) +{ + return getFlippedTileExt_MM(element, MM_FLIP_X); +} + +int getFlippedTileY_MM(int element) +{ + return getFlippedTileExt_MM(element, MM_FLIP_Y); +} + +int getFlippedTileXY_MM(int element) +{ + return getFlippedTileExt_MM(element, MM_FLIP_XY); +} + +int map_wall_from_base_element(int element) { switch (element) { - case EL_WALL_STEEL: return EL_STEEL_WALL; - case EL_WALL_WOOD: return EL_WOODEN_WALL; - case EL_WALL_ICE: return EL_ICE_WALL; - case EL_WALL_AMOEBA: return EL_AMOEBA_WALL; - case EL_DF_WALL_STEEL: return EL_DF_STEEL_WALL; - case EL_DF_WALL_WOOD: return EL_DF_WOODEN_WALL; + case EL_WALL_STEEL_BASE: return EL_WALL_STEEL; + case EL_WALL_WOOD_BASE: return EL_WALL_WOOD; + case EL_WALL_ICE_BASE: return EL_WALL_ICE; + case EL_WALL_AMOEBA_BASE: return EL_WALL_AMOEBA; + case EL_DF_WALL_STEEL_BASE: return EL_DF_WALL_STEEL; + case EL_DF_WALL_WOOD_BASE: return EL_DF_WALL_WOOD; default: return element; } } -int el2gfx(int element) +int map_wall_to_base_element(int element) { - element = map_element(element); - switch (element) { - case EL_LIGHTBALL: - return IMG_MM_LIGHTBALL_RED + RND(3); + case EL_WALL_STEEL: return EL_WALL_STEEL_BASE; + case EL_WALL_WOOD: return EL_WALL_WOOD_BASE; + case EL_WALL_ICE: return EL_WALL_ICE_BASE; + case EL_WALL_AMOEBA: return EL_WALL_AMOEBA_BASE; + case EL_DF_WALL_STEEL: return EL_DF_WALL_STEEL_BASE; + case EL_DF_WALL_WOOD: return EL_DF_WALL_WOOD_BASE; - default: - return el2img_mm(element); + default: return element; } } -void RedrawPlayfield_MM() +int el2gfx(int element) +{ + return el2img_mm(map_wall_from_base_element(element)); +} + +int el_act2gfx(int element, int action) +{ + return el_act2img_mm(map_wall_from_base_element(element), action); +} + +void RedrawPlayfield_MM(void) { DrawLevel_MM(); + DrawLaser_MM(); } void BlitScreenToBitmap_MM(Bitmap *target_bitmap) { - BlitBitmap(drawto_field, target_bitmap, + BlitBitmap(drawto_mm, target_bitmap, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY); }