X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=0e84aa846bfd0dcc5fb94defd73f147919012f1b;hb=a047db7b385f7523ca97deb21fdc504f34a80c7e;hp=bffde89cb0b6f69f790264f74a299cfeab42de01;hpb=f7eeeedb1a0bb21cbd8366cf241faffc76aafc16;p=rocksndiamonds.git diff --git a/src/game.c b/src/game.c index bffde89c..0e84aa84 100644 --- a/src/game.c +++ b/src/game.c @@ -103,96 +103,135 @@ #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \ (element_info[e].move_delay_random)) -#define ELEMENT_CAN_ENTER_FIELD_BASE(e, x, y, condition) \ +#define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \ + (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ + (condition))) + +#define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID) || \ (condition))) -#if 0 -#define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition) \ +#define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \ + (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \ + (CAN_MOVE_INTO_ACID(e) && \ + Feld[x][y] == EL_ACID) || \ + (condition))) + +#define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ (condition) || \ + (CAN_MOVE_INTO_ACID(e) && \ + Feld[x][y] == EL_ACID) || \ (DONT_COLLIDE_WITH(e) && \ IS_PLAYER(x, y) && \ !PLAYER_ENEMY_PROTECTED(x, y)))) -#else + +#if 0 #define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ (condition) || \ - (CAN_MOVE_INTO_ACID(e) && \ - Feld[x][y] == EL_ACID) || \ (DONT_COLLIDE_WITH(e) && \ IS_PLAYER(x, y) && \ !PLAYER_ENEMY_PROTECTED(x, y)))) #endif -#define ELEMENT_CAN_ENTER_FIELD_GENERIC_2(x, y, condition) \ - (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ - (condition))) - #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \ - ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, 0) - -#define ELEMENT_CAN_ENTER_FIELD_OR_ACID(e, x, y) \ - ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, (Feld[x][y] == EL_ACID)) + ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0) -#define ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(x, y) \ - ELEMENT_CAN_ENTER_FIELD_GENERIC_2(x, y, (Feld[x][y] == EL_ACID)) +#if 1 +#define SATELLITE_CAN_ENTER_FIELD(x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0) +#else +#define SATELLITE_CAN_ENTER_FIELD(x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, Feld[x][y] == EL_ACID) +#endif #if 0 #define ENEMY_CAN_ENTER_FIELD(e, x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y)) -#else -#define ENEMY_CAN_ENTER_FIELD(e, x, y) ELEMENT_CAN_ENTER_FIELD_BASE(e, x, y, 0) #endif -#define YAMYAM_CAN_ENTER_FIELD(x, y) \ +#define ENEMY_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0) + +#if 1 + +#define YAMYAM_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Feld[x][y] == EL_DIAMOND) + +#define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Feld[x][y])) + +#define PACMAN_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Feld[x][y])) + +#define PIG_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Feld[x][y])) + +#define PENGUIN_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Feld[x][y] == EL_EXIT_OPEN ||\ + IS_FOOD_PENGUIN(Feld[x][y]))) +#define DRAGON_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0) + +#define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition)) + +#define SPRING_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0) + +#else + +#define YAMYAM_CAN_ENTER_FIELD(e, x, y) \ (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_YAMYAM) && \ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID) || \ Feld[x][y] == EL_DIAMOND)) -#define DARK_YAMYAM_CAN_ENTER_FIELD(x, y) \ +#define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \ (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_DARK_YAMYAM) &&\ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID) || \ IS_FOOD_DARK_YAMYAM(Feld[x][y]))) -#define PACMAN_CAN_ENTER_FIELD(x, y) \ +#define PACMAN_CAN_ENTER_FIELD(e, x, y) \ (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_PACMAN) && \ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID) || \ IS_AMOEBOID(Feld[x][y]))) -#define PIG_CAN_ENTER_FIELD(x, y) \ +#define PIG_CAN_ENTER_FIELD(e, x, y) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_PIG) && \ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID) || \ IS_FOOD_PIG(Feld[x][y]))) -#define PENGUIN_CAN_ENTER_FIELD(x, y) \ +#define PENGUIN_CAN_ENTER_FIELD(e, x, y) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_PENGUIN) && \ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID) || \ IS_FOOD_PENGUIN(Feld[x][y]) || \ Feld[x][y] == EL_EXIT_OPEN)) -#define DRAGON_CAN_ENTER_FIELD(x, y) \ +#define DRAGON_CAN_ENTER_FIELD(e, x, y) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_DRAGON) && \ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID))) -#define MOLE_CAN_ENTER_FIELD(x, y, condition) \ +#define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_MOLE) && \ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID) || \ (condition))) -#define SPRING_CAN_ENTER_FIELD(x, y) \ +#define SPRING_CAN_ENTER_FIELD(e, x, y) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ - (CAN_MOVE_INTO_ACID(EL_SPRING) && \ + (CAN_MOVE_INTO_ACID(e) && \ Feld[x][y] == EL_ACID))) +#endif + #define GROUP_NR(e) ((e) - EL_GROUP_START) #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element) #define IS_IN_GROUP(e, nr) (element_info[e].in_group[nr] == TRUE) @@ -213,7 +252,7 @@ #endif #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \ - ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, CE_ENTER_FIELD_COND(e, x, y)) + ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y)) #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y)) #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y)) @@ -248,6 +287,9 @@ static void KillHeroUnlessExplosionProtected(int, int); static void TestIfPlayerTouchesCustomElement(int, int); static void TestIfElementTouchesCustomElement(int, int); static void TestIfElementHitsCustomElement(int, int, int); +#if 0 +static void TestIfElementSmashesCustomElement(int, int, int); +#endif static void ChangeElement(int, int, int); @@ -907,7 +949,7 @@ static inline void InitField_WithBug1(int x, int y, boolean init_game) InitField(x, y, init_game); /* not needed to call InitMovDir() -- already done by InitField()! */ - if (game.engine_version < VERSION_IDENT(3,0,9,0) && + if (game.engine_version < VERSION_IDENT(3,1,0,0) && CAN_MOVE(Feld[x][y])) InitMovDir(x, y); } @@ -919,7 +961,7 @@ static inline void InitField_WithBug2(int x, int y, boolean init_game) InitField(x, y, init_game); /* not needed to call InitMovDir() -- already done by InitField()! */ - if (game.engine_version < VERSION_IDENT(3,0,9,0) && + if (game.engine_version < VERSION_IDENT(3,1,0,0) && CAN_MOVE(old_element) && (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN)) InitMovDir(x, y); @@ -1257,14 +1299,14 @@ static void InitGameEngine() } /* set push delay value for Supaplex elements for newer engine versions */ - if (game.engine_version >= VERSION_IDENT(3,0,9,0)) + if (game.engine_version >= VERSION_IDENT(3,1,0,0)) { for (i = 0; i < MAX_NUM_ELEMENTS; i++) { if (IS_SP_ELEMENT(i)) { - element_info[i].push_delay_fixed = 6; - element_info[i].push_delay_random = 0; + element_info[i].push_delay_fixed = 6; /* just enough to escape ... */ + element_info[i].push_delay_random = 0; /* ... from falling zonk */ } } } @@ -1388,6 +1430,7 @@ void InitGame() player->use_murphy_graphic = FALSE; player->block_last_field = FALSE; + player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr); player->actual_frame_counter = 0; @@ -1586,23 +1629,32 @@ void InitGame() { if (!IS_CUSTOM_ELEMENT(i)) { - int num_phase = 9; - int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2); - int last_phase = num_phase * delay; + int num_phase = 8; + int delay = ((IS_SP_ELEMENT(i) && + game.engine_version >= VERSION_IDENT(3,1,0,0)) || + game.emulation == EMU_SUPAPLEX ? 3 : 2); + int last_phase = (num_phase + 1) * delay; int half_phase = (num_phase / 2) * delay; - element_info[i].explosion_delay = last_phase; + element_info[i].explosion_delay = last_phase - 1; element_info[i].ignition_delay = half_phase; +#if 0 + if (i == EL_BLACK_ORB) + element_info[i].ignition_delay = 0; +#else if (i == EL_BLACK_ORB) element_info[i].ignition_delay = 1; +#endif } - if (element_info[i].explosion_delay < 2) /* !!! check again !!! */ - element_info[i].explosion_delay = 2; +#if 0 + if (element_info[i].explosion_delay < 1) /* !!! check again !!! */ + element_info[i].explosion_delay = 1; if (element_info[i].ignition_delay < 1) /* !!! check again !!! */ element_info[i].ignition_delay = 1; +#endif } /* correct non-moving belts to start moving left */ @@ -1631,6 +1683,10 @@ void InitGame() some_player->present = FALSE; some_player->active = FALSE; +#if 0 + player->element_nr = some_player->element_nr; +#endif + StorePlayer[jx][jy] = player->element_nr; player->jx = player->last_jx = jx; player->jy = player->last_jy = jy; @@ -2538,6 +2594,9 @@ void RelocatePlayer(int x, int y, int element_raw) boolean no_delay = (tape.index_search); int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay); int wait_delay_value = (no_delay ? 0 : frame_delay_value); +#if 1 + int old_jx, old_jy; +#endif if (player->GameOver) /* do not reanimate dead player */ return; @@ -2567,9 +2626,49 @@ void RelocatePlayer(int x, int y, int element_raw) player->is_moving = FALSE; } +#if 1 + old_jx = player->jx; + old_jy = player->jy; +#endif + Feld[x][y] = element; InitPlayerField(x, y, element, TRUE); +#if 0 + if (player == local_player) + { +#if 1 + + scroll_x += (local_player->jx - old_jx); + scroll_y += (local_player->jy - old_jy); + + /* don't scroll over playfield boundaries */ + if (scroll_x < SBX_Left || scroll_x > SBX_Right) + scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right); + + /* don't scroll over playfield boundaries */ + if (scroll_y < SBY_Upper || scroll_y > SBY_Lower) + scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower); + +#else + scroll_x = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left : + local_player->jx > SBX_Right + MIDPOSX ? SBX_Right : + local_player->jx - MIDPOSX); + + scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper : + local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower : + local_player->jy - MIDPOSY); +#endif + + RedrawPlayfield(TRUE, 0,0,0,0); +#if 0 + DrawAllPlayers(); + BackToFront(); +#endif + } + +#else + if (player == local_player) { int scroll_xx = -999, scroll_yy = -999; @@ -2609,6 +2708,7 @@ void RelocatePlayer(int x, int y, int element_raw) Delay(wait_delay_value); } } +#endif } void Explode(int ex, int ey, int phase, int mode) @@ -2640,6 +2740,10 @@ void Explode(int ex, int ey, int phase, int mode) { int center_element = Feld[ex][ey]; +#if 0 + printf("::: start explosion %d,%d [%d]\n", ex, ey, FrameCounter); +#endif + #if 0 /* --- This is only really needed (and now handled) in "Impact()". --- */ /* do not explode moving elements that left the explode field in time */ @@ -2664,9 +2768,18 @@ void Explode(int ex, int ey, int phase, int mode) } #if 1 + +#if 1 + last_phase = element_info[center_element].explosion_delay + 1; +#else last_phase = element_info[center_element].explosion_delay; #endif +#if 0 + printf("::: %d -> %d\n", center_element, last_phase); +#endif +#endif + for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++) { int xx = x - ex + 1; @@ -2770,8 +2883,13 @@ void Explode(int ex, int ey, int phase, int mode) break; } +#if 1 + if (PLAYERINFO(ex, ey)->use_murphy_graphic) + Store[x][y] = EL_EMPTY; +#else if (game.emulation == EMU_SUPAPLEX) Store[x][y] = EL_EMPTY; +#endif } else if (center_element == EL_MOLE) Store[x][y] = EL_EMERALD_RED; @@ -2845,6 +2963,15 @@ void Explode(int ex, int ey, int phase, int mode) #if 1 ExplodeDelay[x][y] = last_phase; #endif + +#if 0 +#if 1 + GfxFrame[x][y] = 0; /* animation does not start until next frame */ +#else + GfxFrame[x][y] = -1; /* animation does not start until next frame */ +#endif +#endif + Stop[x][y] = TRUE; } @@ -2861,6 +2988,15 @@ void Explode(int ex, int ey, int phase, int mode) x = ex; y = ey; +#if 1 + if (phase == 1) + GfxFrame[x][y] = 0; /* restart explosion animation */ +#endif + +#if 0 + printf(":X: phase == %d [%d]\n", phase, GfxFrame[x][y]); +#endif + #if 1 last_phase = ExplodeDelay[x][y]; #endif @@ -2891,6 +3027,10 @@ void Explode(int ex, int ey, int phase, int mode) if (IS_PLAYER(x, y)) border_element = StorePlayer[x][y]; +#if 0 + printf("::: phase == %d\n", phase); +#endif + if (phase == element_info[border_element].ignition_delay || phase == last_phase) { @@ -2980,6 +3120,10 @@ void Explode(int ex, int ey, int phase, int mode) { int element; +#if 0 + printf("::: explosion %d,%d done [%d]\n", x, y, FrameCounter); +#endif + element = Feld[x][y] = Store[x][y]; Store[x][y] = Store2[x][y] = 0; GfxElement[x][y] = EL_UNDEFINED; @@ -3011,7 +3155,7 @@ void Explode(int ex, int ey, int phase, int mode) #if 1 /* !!! not needed !!! */ #if 1 - if (game.engine_version < VERSION_IDENT(3,0,9,0) && + if (game.engine_version < VERSION_IDENT(3,1,0,0) && CAN_MOVE(Feld[x][y]) && Feld[x][y] != EL_MOLE) InitMovDir(x, y); #else @@ -3047,7 +3191,20 @@ void Explode(int ex, int ey, int phase, int mode) stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON : IMG_SP_EXPLOSION); #endif +#if 1 + int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]); +#else int frame = getGraphicAnimationFrame(graphic, phase - delay); +#endif + +#if 0 + printf("::: phase == %d [%d]\n", phase, GfxFrame[x][y]); +#endif + +#if 0 + printf("::: %d / %d [%d - %d]\n", + GfxFrame[x][y], phase - delay, phase, delay); +#endif #if 0 printf("::: %d ['%s'] -> %d\n", GfxElement[x][y], @@ -3788,6 +3945,10 @@ void Impact(int x, int y) } else { +#if 0 + TestIfElementSmashesCustomElement(x, y, MV_DOWN); +#endif + CheckElementChange(x, y + 1, smashed, CE_SMASHED); CheckTriggeredElementChangeSide(x, y + 1, smashed, @@ -3884,6 +4045,7 @@ inline static void TurnRoundExt(int x, int y) else if (element == EL_BD_BUTTERFLY) /* && MovDir[x][y] == left_dir) */ MovDelay[x][y] = 1; } +#if 0 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY || element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON) { @@ -3902,10 +4064,38 @@ inline static void TurnRoundExt(int x, int y) else if (element == EL_BD_FIREFLY) /* && MovDir[x][y] == right_dir) */ MovDelay[x][y] = 1; } +#else + else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY) + { + TestIfBadThingTouchesOtherBadThing(x, y); + + if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y)) + MovDir[x][y] = left_dir; + else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y)) + MovDir[x][y] = right_dir; + + if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir) + MovDelay[x][y] = 9; + else if (element == EL_BD_FIREFLY) /* && MovDir[x][y] == right_dir) */ + MovDelay[x][y] = 1; + } + else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON) + { + TestIfBadThingTouchesOtherBadThing(x, y); + + if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0)) + MovDir[x][y] = left_dir; + else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0)) + MovDir[x][y] = right_dir; + + if (MovDir[x][y] != old_move_dir) + MovDelay[x][y] = 9; + } +#endif else if (element == EL_YAMYAM) { - boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(left_x, left_y); - boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(right_x, right_y); + boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y); + boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y); if (can_turn_left && can_turn_right) MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir); @@ -3920,8 +4110,10 @@ inline static void TurnRoundExt(int x, int y) } else if (element == EL_DARK_YAMYAM) { - boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(left_x, left_y); - boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(right_x, right_y); + boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element, + left_x, left_y); + boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element, + right_x, right_y); if (can_turn_left && can_turn_right) MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir); @@ -3936,8 +4128,8 @@ inline static void TurnRoundExt(int x, int y) } else if (element == EL_PACMAN) { - boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(left_x, left_y); - boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(right_x, right_y); + boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y); + boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y); if (can_turn_left && can_turn_right) MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir); @@ -3952,9 +4144,9 @@ inline static void TurnRoundExt(int x, int y) } else if (element == EL_PIG) { - boolean can_turn_left = PIG_CAN_ENTER_FIELD(left_x, left_y); - boolean can_turn_right = PIG_CAN_ENTER_FIELD(right_x, right_y); - boolean can_move_on = PIG_CAN_ENTER_FIELD(move_x, move_y); + boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y); + boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y); + boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y); boolean should_turn_left, should_turn_right, should_move_on; int rnd_value = 24; int rnd = RND(rnd_value); @@ -4015,9 +4207,9 @@ inline static void TurnRoundExt(int x, int y) } else if (element == EL_DRAGON) { - boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(left_x, left_y); - boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(right_x, right_y); - boolean can_move_on = DRAGON_CAN_ENTER_FIELD(move_x, move_y); + boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y); + boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y); + boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y); int rnd_value = 24; int rnd = RND(rnd_value); @@ -4065,17 +4257,17 @@ inline static void TurnRoundExt(int x, int y) else if (element == EL_MOLE) { boolean can_move_on = - (MOLE_CAN_ENTER_FIELD(move_x, move_y, + (MOLE_CAN_ENTER_FIELD(element, move_x, move_y, IS_AMOEBOID(Feld[move_x][move_y]) || Feld[move_x][move_y] == EL_AMOEBA_SHRINKING)); if (!can_move_on) { boolean can_turn_left = - (MOLE_CAN_ENTER_FIELD(left_x, left_y, + (MOLE_CAN_ENTER_FIELD(element, left_x, left_y, IS_AMOEBOID(Feld[left_x][left_y]))); boolean can_turn_right = - (MOLE_CAN_ENTER_FIELD(right_x, right_y, + (MOLE_CAN_ENTER_FIELD(element, right_x, right_y, IS_AMOEBOID(Feld[right_x][right_y]))); if (can_turn_left && can_turn_right) @@ -4098,12 +4290,12 @@ inline static void TurnRoundExt(int x, int y) { #if 0 if (MovDir[x][y] & MV_HORIZONTAL && - !SPRING_CAN_ENTER_FIELD(move_x, move_y)) + !SPRING_CAN_ENTER_FIELD(element, move_x, move_y)) MovDir[x][y] = MV_NO_MOVING; #else if (MovDir[x][y] & MV_HORIZONTAL && - (!SPRING_CAN_ENTER_FIELD(move_x, move_y) || - SPRING_CAN_ENTER_FIELD(x, y + 1))) + (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) || + SPRING_CAN_ENTER_FIELD(element, x, y + 1))) MovDir[x][y] = MV_NO_MOVING; #endif @@ -4210,14 +4402,14 @@ inline static void TurnRoundExt(int x, int y) new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL); Moving2Blocked(x, y, &newx, &newy); - if (PENGUIN_CAN_ENTER_FIELD(newx, newy)) + if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy)) return; MovDir[x][y] = new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL); Moving2Blocked(x, y, &newx, &newy); - if (PENGUIN_CAN_ENTER_FIELD(newx, newy)) + if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy)) return; MovDir[x][y] = old_move_dir; @@ -4239,14 +4431,14 @@ inline static void TurnRoundExt(int x, int y) new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL); Moving2Blocked(x, y, &newx, &newy); - if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy)) + if (SATELLITE_CAN_ENTER_FIELD(newx, newy)) return; MovDir[x][y] = new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL); Moving2Blocked(x, y, &newx, &newy); - if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy)) + if (SATELLITE_CAN_ENTER_FIELD(newx, newy)) return; MovDir[x][y] = old_move_dir; @@ -4852,7 +5044,7 @@ void StartMoving(int x, int y) #endif #if 1 - if (game.engine_version >= VERSION_IDENT(3,0,9,0) && + if (game.engine_version >= VERSION_IDENT(3,1,0,0) && WasJustMoving[x][y] && IN_LEV_FIELD(newx, newy) && (Feld[newx][newy] == EL_BLOCKED || IS_PLAYER(newx, newy))) { @@ -5083,7 +5275,7 @@ void StartMoving(int x, int y) else if (CAN_MOVE_INTO_ACID(element) && IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID && (MovDir[x][y] == MV_DOWN || - game.engine_version > VERSION_IDENT(3,0,8,0))) + game.engine_version >= VERSION_IDENT(3,1,0,0))) #else else if (CAN_MOVE_INTO_ACID(element) && MovDir[x][y] == MV_DOWN && IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID) @@ -7182,7 +7374,8 @@ static byte PlayerActions(struct PlayerInfo *player, byte player_action) #if 0 /* !!! TEST !!! */ - CheckGravityMovement(player); + if (player->MovPos == 0) + CheckGravityMovement(player); #endif if (button1) snapped = SnapField(player, dx, dy); @@ -7382,6 +7575,21 @@ void GameActions() recorded_player_action = (tape.playing ? TapePlayAction() : NULL); +#if 1 + if (recorded_player_action == NULL && tape.pausing) + return; +#endif + +#if 0 + printf("::: %d\n", stored_player[0].action); +#endif + +#if 0 + if (recorded_player_action != NULL) + for (i = 0; i < MAX_PLAYERS; i++) + stored_player[i].action = recorded_player_action[i]; +#endif + for (i = 0; i < MAX_PLAYERS; i++) { summarized_player_action |= stored_player[i].action; @@ -7398,43 +7606,91 @@ void GameActions() if (!options.network && !setup.team_mode) local_player->effective_action = summarized_player_action; +#if 1 + if (recorded_player_action != NULL) + for (i = 0; i < MAX_PLAYERS; i++) + stored_player[i].effective_action = recorded_player_action[i]; +#endif + +#if 1 + for (i = 0; i < MAX_PLAYERS; i++) + { + tape_action[i] = stored_player[i].effective_action; + + if (tape.recording && tape_action[i] && !tape.player_participates[i]) + tape.player_participates[i] = TRUE; /* player just appeared from CE */ + } + + /* only save actions from input devices, but not programmed actions */ + if (tape.recording) + TapeRecordAction(tape_action); +#endif + for (i = 0; i < MAX_PLAYERS; i++) { int actual_player_action = stored_player[i].effective_action; #if 1 - /* OLD: overwrite programmed action with tape action (BAD!!!) */ + /* !!! THIS BREAKS THE FOLLOWING TAPES: !!! + - rnd_equinox_tetrachloride 048 + - rnd_equinox_tetrachloride_ii 096 + - rnd_emanuel_schmieg 002 + - doctor_sloan_ww 001, 020 + */ + if (stored_player[i].MovPos == 0) + CheckGravityMovement(&stored_player[i]); +#endif + +#if 1 + /* overwrite programmed action with tape action */ if (stored_player[i].programmed_action) actual_player_action = stored_player[i].programmed_action; #endif +#if 0 + if (stored_player[i].programmed_action) + printf("::: %d\n", stored_player[i].programmed_action); +#endif + if (recorded_player_action) { #if 0 if (stored_player[i].programmed_action && stored_player[i].programmed_action != recorded_player_action[i]) - printf("::: %d <-> %d\n", + printf("::: %d: %d <-> %d\n", i, stored_player[i].programmed_action, recorded_player_action[i]); #endif +#if 0 actual_player_action = recorded_player_action[i]; +#endif } #if 0 - /* NEW: overwrite tape action with programmed action */ + /* overwrite tape action with programmed action */ if (stored_player[i].programmed_action) actual_player_action = stored_player[i].programmed_action; #endif +#if 0 + if (i == 0) + printf("::: action: %d: %x [%d]\n", + stored_player[i].MovPos, actual_player_action, FrameCounter); +#endif + +#if 1 + PlayerActions(&stored_player[i], actual_player_action); +#else tape_action[i] = PlayerActions(&stored_player[i], actual_player_action); if (tape.recording && tape_action[i] && !tape.player_participates[i]) tape.player_participates[i] = TRUE; /* player just appeared from CE */ +#endif ScrollPlayer(&stored_player[i], SCROLL_GO_ON); } -#if 1 +#if 0 if (tape.recording) TapeRecordAction(tape_action); #endif @@ -8065,20 +8321,33 @@ static void CheckGravityMovement(struct PlayerInfo *player) { if (game.gravity && !player->programmed_action) { - int move_dir_vertical = player->action & (MV_UP | MV_DOWN); - int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT); + int move_dir_horizontal = player->action & MV_HORIZONTAL; + int move_dir_vertical = player->action & MV_VERTICAL; int move_dir = - (player->last_move_dir & (MV_LEFT | MV_RIGHT) ? + (player->last_move_dir & MV_HORIZONTAL ? (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) : (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical)); int jx = player->jx, jy = player->jy; int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0); int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0); int new_jx = jx + dx, new_jy = jy + dy; - boolean field_under_player_is_free = - (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1)); + boolean player_is_snapping = player->action & JOY_BUTTON_1; +#if 1 + boolean player_can_fall_down = + (IN_LEV_FIELD(jx, jy + 1) && + (IS_FREE(jx, jy + 1) || + (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid))); +#else + boolean player_can_fall_down = + (IN_LEV_FIELD(jx, jy + 1) && + (IS_FREE(jx, jy + 1))); +#endif boolean player_is_moving_to_valid_field = - (IN_LEV_FIELD(new_jx, new_jy) && + ( +#if 1 + !player_is_snapping && +#endif + IN_LEV_FIELD(new_jx, new_jy) && (Feld[new_jx][new_jy] == EL_SP_BASE || Feld[new_jx][new_jy] == EL_SAND || (IS_SP_PORT(Feld[new_jx][new_jy]) && @@ -8090,10 +8359,25 @@ static void CheckGravityMovement(struct PlayerInfo *player) (IS_WALKABLE(Feld[jx][jy]) && !(element_info[Feld[jx][jy]].access_direction & MV_DOWN))); - if (field_under_player_is_free && +#if 0 + printf("::: checking gravity NOW [%d, %d, %d] [%d] ...\n", + player_can_fall_down, + player_is_standing_on_valid_field, + player_is_moving_to_valid_field, + (player_is_moving_to_valid_field ? Feld[new_jx][new_jy] : -1)); +#endif + + if (player_can_fall_down && !player_is_standing_on_valid_field && !player_is_moving_to_valid_field) + { +#if 0 + printf("::: setting programmed_action to MV_DOWN [%d,%d - %d] ...\n", + jx, jy, FrameCounter); +#endif + player->programmed_action = MV_DOWN; + } } } @@ -8307,7 +8591,7 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy) player->move_delay_value = original_move_delay_value; } - if (player->last_move_dir & (MV_LEFT | MV_RIGHT)) + if (player->last_move_dir & MV_HORIZONTAL) { if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy))) moved |= MovePlayerOneStep(player, dx, 0, dx, dy); @@ -8572,6 +8856,47 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) player->LevelSolved = player->GameOver = TRUE; } +#if 0 + /* !!! ENABLE THIS FOR NEW VERSIONS !!! */ + { + static int trigger_sides[4][2] = + { + /* enter side leave side */ + { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* moving left */ + { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* moving right */ + { CH_SIDE_BOTTOM, CH_SIDE_TOP }, /* moving up */ + { CH_SIDE_TOP, CH_SIDE_BOTTOM } /* moving down */ + }; + int move_direction = player->MovDir; + int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0]; + int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1]; + int old_jx = last_jx; + int old_jy = last_jy; + +#if 1 + if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy])) + { + CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy], + CE_OTHER_GETS_LEFT, + player->index_bit, leave_side); + CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy], + CE_LEFT_BY_PLAYER, + player->index_bit, leave_side); + } + + if (IS_CUSTOM_ELEMENT(Feld[jx][jy])) + { + CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy], + CE_OTHER_GETS_ENTERED, + player->index_bit, enter_side); + CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER, + player->index_bit, enter_side); + } +#endif + + } +#endif + if (game.engine_version >= VERSION_IDENT(3,0,7,0)) { TestIfHeroTouchesBadThing(jx, jy); @@ -8941,6 +9266,108 @@ void TestIfElementHitsCustomElement(int x, int y, int direction) } } +#if 0 +void TestIfElementSmashesCustomElement(int x, int y, int direction) +{ + int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0); + int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0); + int hitx = x + dx, hity = y + dy; + int hitting_element = Feld[x][y]; +#if 0 + boolean object_hit = (IN_LEV_FIELD(hitx, hity) && + !IS_FREE(hitx, hity) && + (!IS_MOVING(hitx, hity) || + MovDir[hitx][hity] != direction || + ABS(MovPos[hitx][hity]) <= TILEY / 2)); +#endif + + if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity)) + return; + +#if 0 + if (IN_LEV_FIELD(hitx, hity) && !object_hit) + return; +#endif + + CheckElementChangeSide(x, y, hitting_element, EP_CAN_SMASH_EVERYTHING, + direction); + + if (IN_LEV_FIELD(hitx, hity)) + { + int opposite_direction = MV_DIR_OPPOSITE(direction); + int hitting_side = direction; + int touched_side = opposite_direction; + int touched_element = MovingOrBlocked2Element(hitx, hity); +#if 1 + boolean object_hit = (!IS_MOVING(hitx, hity) || + MovDir[hitx][hity] != direction || + ABS(MovPos[hitx][hity]) <= TILEY / 2); + + object_hit = TRUE; +#endif + + if (object_hit) + { + int i; + + CheckElementChangeSide(hitx, hity, touched_element, + CE_SMASHED_BY_SOMETHING, opposite_direction); + + if (IS_CUSTOM_ELEMENT(hitting_element) && + HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_SMASHING)) + { + for (i = 0; i < element_info[hitting_element].num_change_pages; i++) + { + struct ElementChangeInfo *change = + &element_info[hitting_element].change_page[i]; + + if (change->can_change && + change->events & CH_EVENT_BIT(CE_OTHER_IS_SMASHING) && + change->trigger_side & touched_side && + +#if 1 + IS_EQUAL_OR_IN_GROUP(touched_element, change->trigger_element) +#else + change->trigger_element == touched_element +#endif + ) + { + CheckElementChangePage(x, y, hitting_element, CE_OTHER_IS_SMASHING, + i); + break; + } + } + } + + if (IS_CUSTOM_ELEMENT(touched_element) && + HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_SMASHED)) + { + for (i = 0; i < element_info[touched_element].num_change_pages; i++) + { + struct ElementChangeInfo *change = + &element_info[touched_element].change_page[i]; + + if (change->can_change && + change->events & CH_EVENT_BIT(CE_OTHER_GETS_SMASHED) && + change->trigger_side & hitting_side && +#if 1 + IS_EQUAL_OR_IN_GROUP(hitting_element, change->trigger_element) +#else + change->trigger_element == hitting_element +#endif + ) + { + CheckElementChangePage(hitx, hity, touched_element, + CE_OTHER_GETS_SMASHED, i); + break; + } + } + } + } + } +} +#endif + void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir) { int i, kill_x = -1, kill_y = -1; @@ -9432,6 +9859,10 @@ int DigField(struct PlayerInfo *player, DOUBLE_PLAYER_SPEED(player); #endif +#if 0 + printf("::: passing port %d,%d [%d]\n", x, y, FrameCounter); +#endif + PlayLevelSound(x, y, SND_CLASS_SP_PORT_PASSING); break; @@ -9976,8 +10407,13 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy) dy == -1 ? MV_UP : dy == +1 ? MV_DOWN : MV_NO_MOVING); +#if 0 + if (player->MovPos) + return FALSE; +#else if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0,0)) return FALSE; +#endif if (!player->active || !IN_LEV_FIELD(x, y)) return FALSE; @@ -10424,7 +10860,25 @@ void RequestQuitGame(boolean ask_if_really_quit) } else { + +#if 1 + if (tape.playing && tape.index_search) + { + SetDrawDeactivationMask(REDRAW_NONE); + audio.sound_deactivated = FALSE; + } +#endif + OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK); + +#if 1 + if (tape.playing && tape.index_search) + { + SetDrawDeactivationMask(REDRAW_FIELD); + audio.sound_deactivated = TRUE; + } +#endif + } }