X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Fgame_mm%2Fmm_tools.c;h=d7f4326e19ed2fd6ed5f4351701ba83c042ce3f5;hp=9f52eb735e5039bc60e157b0bd78d224b7909139;hb=9844da8056347b71669ce3b5bccb4cd01caa71b3;hpb=a601eb5bd800d544e8a5154a7b4d2457d020cd3f diff --git a/src/game_mm/mm_tools.c b/src/game_mm/mm_tools.c index 9f52eb73..d7f4326e 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,36 @@ #include "mm_tools.h" -void ClearWindow() +void SetDrawtoField_MM(int mode) +{ + int full_xsize = lev_fieldx * TILESIZE_VAR; + int full_ysize = lev_fieldy * TILESIZE_VAR; + + // 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 playfield border + cSY2 = SY + dSY + 2; // including playfield border + + if (mode == DRAW_TO_BACKBUFFER) + { + cFX = FX + dSX; + cFY = FY + dSY; + } + + SetTileCursorSXSY(cSX, cSY); +} + +void ClearWindow(void) { ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE); - SetDrawtoField(DRAW_BACKBUFFER); + SetDrawtoField(DRAW_TO_BACKBUFFER); + SetDrawtoField_MM(DRAW_TO_BACKBUFFER); redraw_mask |= REDRAW_FIELD; } @@ -34,7 +59,7 @@ 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); + cFX + x * TILEX, cFY + y * TILEY); } void DrawGraphic_MM(int x, int y, int graphic) @@ -42,13 +67,16 @@ void DrawGraphic_MM(int x, int y, int graphic) #if DEBUG 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); + DrawGraphicExt_MM(drawto_field, cFX + x * TILEX, cFY + y * TILEY, graphic); + MarkTileDirty(x, y); } @@ -58,6 +86,7 @@ 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); } @@ -66,13 +95,17 @@ void DrawGraphicThruMask_MM(int x, int y, int graphic) #if DEBUG 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); + DrawGraphicThruMaskExt_MM(drawto_field, cFX + x * TILEX, cFY + y * TILEY, + graphic); + MarkTileDirty(x,y); } @@ -92,14 +125,18 @@ void DrawGraphicThruMaskExt_MM(DrawBuffer *d, int dest_x, int 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, cSX + x * MINI_TILEX, cSY + y * MINI_TILEY, + graphic); + + MarkTileDirty(x / 2, y / 2); } -void getMicroGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y) +#if 0 +static void getMicroGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y) { getSizedGraphicSource(graphic, 0, TILESIZE / 4, bitmap, x, y); } +#endif void DrawMiniGraphicExt_MM(DrawBuffer *d, int x, int y, int graphic) { @@ -107,6 +144,7 @@ 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); } @@ -121,38 +159,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 +199,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 +213,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,23 +236,23 @@ 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)) { - 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, src_x, src_y, TILEX, TILEY, dest_x, dest_y); - } else BlitBitmap(src_bitmap, drawto_field, src_x, src_y, width, height, dest_x, dest_y); @@ -220,7 +263,7 @@ void DrawGraphicShifted_MM(int x,int y, int dx,int dy, int graphic, 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); + DrawGraphicShifted_MM(x, y, dx, dy, graphic, cut_mode, USE_MASKING); } void DrawScreenElementExt_MM(int x, int y, int dx, int dy, int element, @@ -284,7 +327,7 @@ void DrawLevelElementThruMask_MM(int x, int y, int element) void DrawLevelFieldThruMask_MM(int x, int y) { - DrawLevelElementExt_MM(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING); + DrawLevelElementExt_MM(x, y, 0, 0, Tile[x][y], NO_CUTTING, USE_MASKING); } void DrawScreenElement_MM(int x, int y, int element) @@ -300,7 +343,7 @@ void DrawLevelElement_MM(int x, int y, int 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,23 +366,31 @@ 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) @@ -354,10 +405,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 +421,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; 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 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 (xsn_e0 > xsn_e3 - xsn_off && + xsn_e0 < xsn_e3 + xsn_off + xsn_c0) + return xsn_m0 * (xsn_m3 - xsn_m1); + } + + return xsn_m0; +} + +static void xsn_init_item(int nr) +{ + struct XsnItem *item = &xsn.items[nr]; + + item->type = XSN_RND(num_xsn_data); + + if (xsn.change_type != 0) + { + 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); + } + + item->dy = XSN_RND(xsn.max_dy + 1) + 1; + item->dx = XSN_RND(item->dy / 4 + 1) * (XSN_RND(1000) > 500 ? -1 : 1); + + item->active = 1; +} + +static void xsn_update_item(int nr) +{ + struct XsnItem *item = &xsn.items[nr]; + + if (!item->active) + xsn_init_item(nr); + + if (xsn.change_type != 0) + { + int dx_new = ABS(item->dx) + + (xsn.change_type == 1 ? + XSN_RND(XSN_CHANGE_FACTOR + 1) - XSN_CHANGE_FACTOR / 2 : + XSN_RND(20)); + + 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_DEFAULT); + + 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; +} + +static void xsn_update_change(void) +{ + 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) { - if (y > DY+249 && y < DY+278) + static boolean initialized = FALSE; + static boolean started = FALSE; + static boolean active = FALSE; + static boolean debug = FALSE; + static unsigned int check_delay = 0; + static unsigned int start_delay = 0; + static unsigned int growth_delay = 0; + static unsigned int update_delay = 0; + static unsigned int change_delay = 0; + static unsigned int check_delay_value = XSN_CHECK_DELAY * 1000; + static unsigned int start_delay_value = 0; + static unsigned int growth_delay_value = 0; + static unsigned int update_delay_value = 0; + static unsigned int change_delay_value = 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; + + if (DelayReached(&check_delay, check_delay_value)) + { + percent = (debug ? debug_value * 100 / XSN_DEBUG_STEPS : xsn_percent()); + active = (percent > 0); + } + else if (tile_cursor.xsn_debug) { - if (x > DX+1 && x < DX+48) + debug_value = (active ? 0 : MIN(debug_value + 1, XSN_DEBUG_STEPS)); + debug = TRUE; + active = FALSE; + + DelayReached(&check_delay, 0); + + tile_cursor.xsn_debug = FALSE; + } + + if (!active) + return; + + if (!active_last) + { + start_delay_value = (debug ? 0 : XSN_RND(XSN_START_DELAY * 2) * 1000); + started = FALSE; + + DelayReached(&start_delay, 0); + + reinitialize = TRUE; + } + + 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 (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; + + 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_DEFAULT); + SDLSetAlpha(surface_masked, TRUE, XSN_ALPHA_DEFAULT); + + 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, start_delay_value)) + return; + + update_delay_value = XSN_UPDATE_DELAY; + growth_delay_value = XSN_GROWTH_DELAY * 1000; + change_delay_value = XSN_CHANGE_DELAY * 1000; + + DelayReached(&growth_delay, 0); + DelayReached(&update_delay, 0); + DelayReached(&change_delay, 0); + + started = TRUE; + } + + if (xsn.num_items < xsn.max_items) + { + if (DelayReached(&growth_delay, growth_delay_value)) + { + xsn.num_items += XSN_RND(XSN_GROWTH_RATE * 2); + xsn.num_items = MIN(xsn.num_items, xsn.max_items); + } + } + + if (DelayReached(&update_delay, update_delay_value)) + { + for (i = 0; i < xsn.num_items; i++) + xsn_update_item(i); + } + + if (DelayReached(&change_delay, change_delay_value)) + { + xsn_update_change(); + + change_delay_value = xsn.change_delay * 1000; + } + + 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); + } +} + +void DrawTileCursor_MM(int draw_target, boolean tile_cursor_active) +{ + 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; + + DrawTileCursor_Xsn(draw_target); + + if (!tile_cursor.enabled || + !tile_cursor.active || + !tile_cursor_active) + return; + + if (tile_cursor.moving) + { + 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; + } + + 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); +} + +#if 0 +static int REQ_in_range(int x, int y) +{ + if (y > DY + 249 && y < DY + 278) + { + if (x > DX + 1 && x < DX + 48) return 1; - else if (x > DX+51 && x < DX+98) + else if (x > DX + 51 && x < DX + 98) return 2; } + return 0; } +#endif Pixel ReadPixel(DrawBuffer *bitmap, int x, int y) { @@ -715,9 +1305,10 @@ int el2gfx(int element) } } -void RedrawPlayfield_MM() +void RedrawPlayfield_MM(void) { DrawLevel_MM(); + DrawLaser_MM(); } void BlitScreenToBitmap_MM(Bitmap *target_bitmap)