X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Fgame_mm%2Fmm_game.c;h=b258e374b7f0bbeb868be9b873e831e331394af0;hp=b0743369f8acf99bff6ce4a9600e33ed88e1510d;hb=HEAD;hpb=f00dbcf8e990eabe51b7b92cc7fb320ef10e4b6e diff --git a/src/game_mm/mm_game.c b/src/game_mm/mm_game.c index b0743369..b258e374 100644 --- a/src/game_mm/mm_game.c +++ b/src/game_mm/mm_game.c @@ -139,11 +139,14 @@ static DelayCounter overload_delay = { 0 }; #define MM_MASK_GRID_2 5 #define MM_MASK_GRID_3 6 #define MM_MASK_GRID_4 7 -#define MM_MASK_GRID_CLOSED 8 -#define MM_MASK_RECTANGLE 9 -#define MM_MASK_CIRCLE 10 +#define MM_MASK_SLOPE_1 8 +#define MM_MASK_SLOPE_2 9 +#define MM_MASK_SLOPE_3 10 +#define MM_MASK_SLOPE_4 11 +#define MM_MASK_RECTANGLE 12 +#define MM_MASK_CIRCLE 13 -#define NUM_MM_MASKS 11 +#define NUM_MM_MASKS 14 // element masks for scanning pixels of MM elements static const char mm_masks[NUM_MM_MASKS][16][16 + 1] = @@ -293,22 +296,76 @@ static const char mm_masks[NUM_MM_MASKS][16][16 + 1] = " XX XXXXX ", }, { - " XXXXXX XXXXXX ", - "XXXXXXXXXXXXXXXX", - "XXXXXXXXXXXXXXXX", - "XXXXXXXXXXXXXXXX", - "XXXXXXXXXXXXXXXX", - "XXXXXXXXXXXXXXXX", - "XXXXXXXXXXXXXXXX", - " XXXXXXXXXXXXXX ", - " XXXXXXXXXXXXXX ", - "XXXXXXXXXXXXXXXX", - "XXXXXXXXXXXXXXXX", + " X", + " XX", + " XXX", + " XXXX", + " XXXXX", + " XXXXXX", + " XXXXXXX", + " XXXXXXXX", + " XXXXXXXXX", + " XXXXXXXXXX", + " XXXXXXXXXXX", + " XXXXXXXXXXXX", + " XXXXXXXXXXXXX", + " XXXXXXXXXXXXXX", + " XXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXX", + }, + { + "X ", + "XX ", + "XXX ", + "XXXX ", + "XXXXX ", + "XXXXXX ", + "XXXXXXX ", + "XXXXXXXX ", + "XXXXXXXXX ", + "XXXXXXXXXX ", + "XXXXXXXXXXX ", + "XXXXXXXXXXXX ", + "XXXXXXXXXXXXX ", + "XXXXXXXXXXXXXX ", + "XXXXXXXXXXXXXXX ", "XXXXXXXXXXXXXXXX", + }, + { "XXXXXXXXXXXXXXXX", + "XXXXXXXXXXXXXXX ", + "XXXXXXXXXXXXXX ", + "XXXXXXXXXXXXX ", + "XXXXXXXXXXXX ", + "XXXXXXXXXXX ", + "XXXXXXXXXX ", + "XXXXXXXXX ", + "XXXXXXXX ", + "XXXXXXX ", + "XXXXXX ", + "XXXXX ", + "XXXX ", + "XXX ", + "XX ", + "X ", + }, + { "XXXXXXXXXXXXXXXX", - " XXXXXX XXXXXX ", + " XXXXXXXXXXXXXXX", + " XXXXXXXXXXXXXX", + " XXXXXXXXXXXXX", + " XXXXXXXXXXXX", + " XXXXXXXXXXX", + " XXXXXXXXXX", + " XXXXXXXXX", + " XXXXXXXX", + " XXXXXXX", + " XXXXXX", + " XXXXX", + " XXXX", + " XXX", + " XX", + " X", }, { "XXXXXXXXXXXXXXXX", @@ -357,6 +414,8 @@ static int get_element_angle(int element) IS_LASER(element) || IS_RECEIVER(element)) return 4 * element_phase; + else if (IS_DF_SLOPE(element)) + return 4 + (element_phase % 2) * 8; else return element_phase; } @@ -778,16 +837,24 @@ void InitGameActions_MM(void) AdvanceFrameCounter(); AdvanceGfxFrame(); - DrawLevel_MM(); - - BackToFront_MM(); + if (PendingEscapeKeyEvent()) + continue; #ifdef DEBUG if (setup.quick_doors) continue; #endif + + DrawLevel_MM(); + + BackToFront_MM(); } +#ifdef DEBUG + if (setup.quick_doors) + DrawLevel_MM(); +#endif + ScanLaser(); if (game_mm.kettles_still_needed == 0) @@ -847,12 +914,12 @@ static void GameOver_MM(int game_over_cause) static void AddLaserEdge(int lx, int ly) { - int clx = dSX + lx; - int cly = dSY + ly; - int sxsize = MAX(SXSIZE, lev_fieldx * TILEX); - int sysize = MAX(SYSIZE, lev_fieldy * TILEY); + int full_sxsize = MAX(FULL_SXSIZE, lev_fieldx * TILEX); + int full_sysize = MAX(FULL_SYSIZE, lev_fieldy * TILEY); - if (clx < -2 || cly < -2 || clx >= sxsize + 2 || cly >= sysize + 2) + // check if laser is still inside visible playfield area (or inside level) + if (cSX + lx < REAL_SX || cSX + lx >= REAL_SX + full_sxsize || + cSY + ly < REAL_SY || cSY + ly >= REAL_SY + full_sysize) { Warn("AddLaserEdge: out of bounds: %d, %d", lx, ly); @@ -905,13 +972,30 @@ static int getMaskFromElement(int element) else if (IS_GRID(element)) return MM_MASK_GRID_1 + get_element_phase(element); else if (IS_DF_GRID(element)) - return MM_MASK_GRID_CLOSED; + return MM_MASK_RECTANGLE; + else if (IS_DF_SLOPE(element)) + return MM_MASK_SLOPE_1 + get_element_phase(element); else if (IS_RECTANGLE(element)) return MM_MASK_RECTANGLE; else return MM_MASK_CIRCLE; } +static int getPixelFromMask(int pos, int dx, int dy) +{ + return (mm_masks[pos][dy / 2][dx / 2] == 'X' ? 1 : 0); +} + +static int getLevelFromLaserX(int x) +{ + return x / TILEX - (x < 0 ? 1 : 0); // correct negative values +} + +static int getLevelFromLaserY(int y) +{ + return y / TILEY - (y < 0 ? 1 : 0); // correct negative values +} + static int ScanPixel(void) { int hit_mask = 0; @@ -963,8 +1047,8 @@ static int ScanPixel(void) int py = LY + (i / 2) * 2; int dx = px % TILEX; int dy = py % TILEY; - int lx = (px + TILEX) / TILEX - 1; // ...+TILEX...-1 to get correct - int ly = (py + TILEY) / TILEY - 1; // negative values! + int lx = getLevelFromLaserX(px); + int ly = getLevelFromLaserY(py); Pixel pixel; if (IN_LEV_FIELD(lx, ly)) @@ -985,11 +1069,12 @@ static int ScanPixel(void) { int pos = getMaskFromElement(element); - pixel = (mm_masks[pos][dy / 2][dx / 2] == 'X' ? 1 : 0); + pixel = getPixelFromMask(pos, dx, dy); } } else { + // check if laser is still inside visible playfield area pixel = (cSX + px < REAL_SX || cSX + px >= REAL_SX + FULL_SXSIZE || cSY + py < REAL_SY || cSY + py >= REAL_SY + FULL_SYSIZE); } @@ -1080,9 +1165,26 @@ static void ScanLaser(void) LX, LY, XS, YS); #endif - // hit something -- check out what it was - ELX = (LX + XS + TILEX) / TILEX - 1; // ...+TILEX...-1 to get correct - ELY = (LY + YS + TILEY) / TILEY - 1; // negative values! + // check if laser scan has hit two diagonally adjacent element corners + boolean diag_1 = ((hit_mask & HIT_MASK_DIAGONAL_1) == HIT_MASK_DIAGONAL_1); + boolean diag_2 = ((hit_mask & HIT_MASK_DIAGONAL_2) == HIT_MASK_DIAGONAL_2); + + // check if laser scan has crossed element boundaries (not just mini tiles) + boolean cross_x = (getLevelFromLaserX(LX) != getLevelFromLaserX(LX + 2)); + boolean cross_y = (getLevelFromLaserY(LY) != getLevelFromLaserY(LY + 2)); + + if (cross_x || cross_y) + { + // hit something at next tile -- check out what it was + ELX = getLevelFromLaserX(LX + XS); + ELY = getLevelFromLaserY(LY + YS); + } + else + { + // hit something at same tile -- check out what it was + ELX = getLevelFromLaserX(LX); + ELY = getLevelFromLaserY(LY); + } #if 0 Debug("game:mm:ScanLaser", "hit_mask (1) == '%x' (%d, %d) (%d, %d)", @@ -1091,20 +1193,27 @@ static void ScanLaser(void) if (!IN_LEV_FIELD(ELX, ELY)) { + // laser next step position + int x = cSX + LX + XS; + int y = cSY + LY + YS; + + // check if next step of laser is still inside visible playfield area + if (x >= REAL_SX && x < REAL_SX + FULL_SXSIZE && + y >= REAL_SY && y < REAL_SY + FULL_SYSIZE) + { + // go on with another step + LX += XS; + LY += YS; + + continue; + } + element = EL_EMPTY; laser.dest_element = element; break; } - // check if laser scan has hit two diagonally adjacent element corners - boolean diag_1 = ((hit_mask & HIT_MASK_DIAGONAL_1) == HIT_MASK_DIAGONAL_1); - boolean diag_2 = ((hit_mask & HIT_MASK_DIAGONAL_2) == HIT_MASK_DIAGONAL_2); - - // check if laser scan has crossed element boundaries (not just mini tiles) - boolean cross_x = (LX / TILEX != (LX + 2) / TILEX); - boolean cross_y = (LY / TILEY != (LY + 2) / TILEY); - // handle special case of laser hitting two diagonally adjacent elements // (with or without a third corner element behind these two elements) if ((diag_1 || diag_2) && cross_x && cross_y) @@ -1578,8 +1687,78 @@ void DrawLaser_MM(void) static boolean HitElement(int element, int hit_mask) { - if (HitOnlyAnEdge(hit_mask)) - return FALSE; + if (IS_DF_SLOPE(element)) + { + // check if laser scan has crossed element boundaries (not just mini tiles) + boolean cross_x = (getLevelFromLaserX(LX) != getLevelFromLaserX(LX + 2)); + boolean cross_y = (getLevelFromLaserY(LY) != getLevelFromLaserY(LY + 2)); + int element_angle = get_element_angle(element); + int mirrored_angle = get_mirrored_angle(laser.current_angle, element_angle); + int opposite_angle = get_opposite_angle(laser.current_angle); + + // check if wall (horizontal or vertical) side of slope was hit + if (hit_mask == HIT_MASK_LEFT || + hit_mask == HIT_MASK_RIGHT || + hit_mask == HIT_MASK_TOP || + hit_mask == HIT_MASK_BOTTOM) + { + boolean hit_slope_corner_in_laser_direction = + ((hit_mask == HIT_MASK_LEFT && (element == EL_DF_SLOPE_01 || + element == EL_DF_SLOPE_02)) || + (hit_mask == HIT_MASK_RIGHT && (element == EL_DF_SLOPE_00 || + element == EL_DF_SLOPE_03)) || + (hit_mask == HIT_MASK_TOP && (element == EL_DF_SLOPE_02 || + element == EL_DF_SLOPE_03)) || + (hit_mask == HIT_MASK_BOTTOM && (element == EL_DF_SLOPE_00 || + element == EL_DF_SLOPE_01))); + + boolean hit_slope_corner_in_laser_direction_double_checked = + (cross_x && cross_y && + laser.current_angle == mirrored_angle && + hit_slope_corner_in_laser_direction); + + // check special case of laser hitting the corner of a slope and another + // element (either wall or another slope), following the diagonal side + // of the slope which has the same angle as the direction of the laser + if (!hit_slope_corner_in_laser_direction_double_checked) + return HitReflectingWalls(element, hit_mask); + } + + // check if an edge was hit while crossing element borders + if (cross_x && cross_y && get_number_of_bits(hit_mask) == 1) + { + // check both sides of potentially diagonal side of slope + int dx1 = (LX + XS) % TILEX; + int dy1 = (LY + YS) % TILEY; + int dx2 = (LX + XS + 2) % TILEX; + int dy2 = (LY + YS + 2) % TILEY; + int pos = getMaskFromElement(element); + + // check if we are entering empty space area after hitting edge + if (!getPixelFromMask(pos, dx1, dy1) && + !getPixelFromMask(pos, dx2, dy2)) + { + // we already know that we hit an edge, but use this function to go on + if (HitOnlyAnEdge(hit_mask)) + return FALSE; + } + } + + // check if laser is reflected by slope by 180° + if (mirrored_angle == opposite_angle) + { + AddDamagedField(LX / TILEX, LY / TILEY); + + laser.overloaded = TRUE; + + return TRUE; + } + } + else + { + if (HitOnlyAnEdge(hit_mask)) + return FALSE; + } if (IS_MOVING(ELX, ELY) || IS_BLOCKED(ELX, ELY)) element = MovingOrBlocked2Element_MM(ELX, ELY); @@ -1599,8 +1778,11 @@ static boolean HitElement(int element, int hit_mask) AddDamagedField(ELX, ELY); + boolean through_center = ((ELX * TILEX + 14 - LX) * YS == + (ELY * TILEY + 14 - LY) * XS); + // this is more precise: check if laser would go through the center - if ((ELX * TILEX + 14 - LX) * YS != (ELY * TILEY + 14 - LY) * XS) + if (!IS_DF_SLOPE(element) && !through_center) { int skip_count = 0; @@ -1671,10 +1853,28 @@ static boolean HitElement(int element, int hit_mask) return TRUE; } - if (!IS_BEAMER(element) && - !IS_FIBRE_OPTIC(element) && - !IS_GRID_WOOD(element) && - element != EL_FUEL_EMPTY) + if (IS_DF_SLOPE(element) && !through_center) + { + int correction = 2; + + if (hit_mask == HIT_MASK_ALL) + { + // laser already inside slope -- go back half step + LX -= XS / 2; + LY -= YS / 2; + + correction = 1; + } + + AddLaserEdge(LX, LY); + + LX -= (ABS(XS) < ABS(YS) ? correction * SIGN(XS) : 0); + LY -= (ABS(YS) < ABS(XS) ? correction * SIGN(YS) : 0); + } + else if (!IS_BEAMER(element) && + !IS_FIBRE_OPTIC(element) && + !IS_GRID_WOOD(element) && + element != EL_FUEL_EMPTY) { #if 0 if ((ELX * TILEX + 14 - LX) * YS == (ELY * TILEY + 14 - LY) * XS) @@ -1695,6 +1895,8 @@ static boolean HitElement(int element, int hit_mask) IS_POLAR_CROSS(element) || IS_DF_MIRROR(element) || IS_DF_MIRROR_AUTO(element) || + IS_DF_MIRROR_FIXED(element) || + IS_DF_SLOPE(element) || element == EL_PRISM || element == EL_REFRACTOR) { @@ -1713,7 +1915,9 @@ static boolean HitElement(int element, int hit_mask) if (IS_MIRROR(element) || IS_MIRROR_FIXED(element) || IS_DF_MIRROR(element) || - IS_DF_MIRROR_AUTO(element)) + IS_DF_MIRROR_AUTO(element) || + IS_DF_MIRROR_FIXED(element) || + IS_DF_SLOPE(element)) laser.current_angle = get_mirrored_angle(laser.current_angle, get_element_angle(element)); @@ -1723,13 +1927,27 @@ static boolean HitElement(int element, int hit_mask) XS = 2 * Step[laser.current_angle].x; YS = 2 * Step[laser.current_angle].y; - if (!IS_22_5_ANGLE(laser.current_angle)) // 90° or 45° angle - step_size = 8; - else - step_size = 4; + if (through_center) + { + // start from center position for all game elements but slope + if (!IS_22_5_ANGLE(laser.current_angle)) // 90° or 45° angle + step_size = 8; + else + step_size = 4; - LX += step_size * XS; - LY += step_size * YS; + LX += step_size * XS; + LY += step_size * YS; + } + else + { + // advance laser position until reaching the next tile (slopes) + while (LX / TILEX == ELX && (LX + 2) / TILEX == ELX && + LY / TILEY == ELY && (LY + 2) / TILEY == ELY) + { + LX += XS; + LY += YS; + } + } // draw sparkles on mirror if ((IS_MIRROR(element) || @@ -1748,6 +1966,68 @@ static boolean HitElement(int element, int hit_mask) (get_opposite_angle(laser.current_angle) == laser.damage[laser.num_damages - 1].angle ? TRUE : FALSE); + if (IS_DF_SLOPE(element)) + { + // handle special cases for slope element + + if (IS_45_ANGLE(laser.current_angle)) + { + int elx, ely; + + elx = getLevelFromLaserX(LX + XS); + ely = getLevelFromLaserY(LY + YS); + + if (IN_LEV_FIELD(elx, ely)) + { + int element_next = Tile[elx][ely]; + + // check if slope is followed by slope with opposite orientation + if (IS_DF_SLOPE(element_next) && ABS(element - element_next) == 2) + laser.overloaded = TRUE; + } + + int nr = element - EL_DF_SLOPE_START; + int dx = (nr == 0 ? (XS > 0 ? TILEX - 1 : -1) : + nr == 1 ? (XS > 0 ? TILEX : 0) : + nr == 2 ? (XS > 0 ? TILEX : 0) : + nr == 3 ? (XS > 0 ? TILEX - 1 : -1) : 0); + int dy = (nr == 0 ? (YS > 0 ? TILEY - 1 : -1) : + nr == 1 ? (YS > 0 ? TILEY - 1 : -1) : + nr == 2 ? (YS > 0 ? TILEY : 0) : + nr == 3 ? (YS > 0 ? TILEY : 0) : 0); + + int px = ELX * TILEX + dx; + int py = ELY * TILEY + dy; + + dx = px % TILEX; + dy = py % TILEY; + + elx = getLevelFromLaserX(px); + ely = getLevelFromLaserY(py); + + if (IN_LEV_FIELD(elx, ely)) + { + int element_side = Tile[elx][ely]; + + // check if end of slope is blocked by other element + if (IS_WALL(element_side) || IS_WALL_CHANGING(element_side)) + { + int pos = dy / MINI_TILEY * 2 + dx / MINI_TILEX; + + if (element & (1 << pos)) + laser.overloaded = TRUE; + } + else + { + int pos = getMaskFromElement(element_side); + + if (getPixelFromMask(pos, dx, dy)) + laser.overloaded = TRUE; + } + } + } + } + return (laser.overloaded ? TRUE : FALSE); }