X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=59ced41619717c82f6fc88b6e1a34d074651ccb7;hb=af07d74262e7d5075feaea67fa16c04c6be0e3f6;hp=0c4100d2f6da2afb37174b7c373eaf1341b2590e;hpb=93d61986b504bb6c5553d0a6e3c7dd07230ac95b;p=rocksndiamonds.git diff --git a/src/game.c b/src/game.c index 0c4100d2..59ced416 100644 --- a/src/game.c +++ b/src/game.c @@ -96,10 +96,15 @@ /* values for other actions */ #define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED) +#define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0) +#define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0) + #define INIT_GFX_RANDOM() (SimpleRND(1000000)) #define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \ RND(element_info[e].push_delay_random)) +#define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \ + RND(element_info[e].drop_delay_random)) #define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \ RND(element_info[e].move_delay_random)) #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \ @@ -109,6 +114,9 @@ ((e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \ (e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : (e)) +#define CAN_GROW_INTO(e) \ + (e == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable)) + #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \ (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ (condition))) @@ -263,6 +271,11 @@ #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)) +#define ACCESS_FROM(e, d) (element_info[e].access_direction &(d)) +#define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d)) +#define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d)) +#define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d)) + /* game button identifiers */ #define GAME_CTRL_ID_STOP 0 #define GAME_CTRL_ID_PAUSE 1 @@ -303,22 +316,22 @@ static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int); #define CheckTriggeredElementChange(x, y, e, ev) \ CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, \ CH_SIDE_ANY, -1) -#define CheckTriggeredElementChangePlayer(x, y, e, ev, p, s) \ +#define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \ CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1) -#define CheckTriggeredElementChangeSide(x, y, e, ev, s) \ +#define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \ CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1) -#define CheckTriggeredElementChangePage(x, y, e, ev, p) \ +#define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \ CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, \ CH_SIDE_ANY, p) static boolean CheckElementChangeExt(int, int, int, int, int, int, int, int); #define CheckElementChange(x, y, e, te, ev) \ CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY, -1) -#define CheckElementChangePlayer(x, y, e, ev, p, s) \ +#define CheckElementChangeByPlayer(x, y, e, ev, p, s) \ CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s, CH_PAGE_ANY) -#define CheckElementChangeSide(x, y, e, te, ev, s) \ +#define CheckElementChangeBySide(x, y, e, te, ev, s) \ CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s, CH_PAGE_ANY) -#define CheckElementChangePage(x, y, e, te, ev, p) \ +#define CheckElementChangeByPage(x, y, e, te, ev, p) \ CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY, p) static void PlayLevelSound(int, int, int); @@ -594,7 +607,7 @@ struct int element; int direction; } -tube_access[] = +access_direction_list[] = { { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }, { EL_TUBE_VERTICAL, MV_UP | MV_DOWN }, @@ -608,7 +621,19 @@ tube_access[] = { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP }, { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN }, - { EL_UNDEFINED, 0 } + { EL_SP_PORT_LEFT, MV_RIGHT }, + { EL_SP_PORT_RIGHT, MV_LEFT }, + { EL_SP_PORT_UP, MV_DOWN }, + { EL_SP_PORT_DOWN, MV_UP }, + { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT }, + { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN }, + { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }, + { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT }, + { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT }, + { EL_SP_GRAVITY_PORT_UP, MV_DOWN }, + { EL_SP_GRAVITY_PORT_DOWN, MV_UP }, + + { EL_UNDEFINED, MV_NO_MOVING } }; static unsigned long trigger_events[MAX_NUM_ELEMENTS]; @@ -977,9 +1002,10 @@ static inline void InitField_WithBug2(int x, int y, boolean init_game) /* this case is in fact a combination of not less than three bugs: first, it calls InitMovDir() for elements that can move, although this is already done by InitField(); then, it checks the element that was at this - field _before_ the call to InitField() (which can change it) - - */ + field _before_ the call to InitField() (which can change it); lastly, it + was not called for "mole with direction" elements, which were treated as + "cannot move" due to (fixed) wrong element initialization in "src/init.c" + */ } inline void DrawGameValue_Emeralds(int value) @@ -1375,15 +1401,15 @@ static void InitGameEngine() /* ---------- initialize access direction -------------------------------- */ - /* initialize access direction values to default */ + /* initialize access direction values to default (access from every side) */ for (i = 0; i < MAX_NUM_ELEMENTS; i++) if (!IS_CUSTOM_ELEMENT(i)) element_info[i].access_direction = MV_ALL_DIRECTIONS; /* set access direction value for certain elements from pre-defined list */ - for (i = 0; tube_access[i].element != EL_UNDEFINED; i++) - element_info[tube_access[i].element].access_direction = - tube_access[i].direction; + for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++) + element_info[access_direction_list[i].element].access_direction = + access_direction_list[i].direction; } @@ -1467,6 +1493,7 @@ void InitGame() player->is_waiting = FALSE; player->is_moving = FALSE; + player->is_auto_moving = FALSE; player->is_digging = FALSE; player->is_snapping = FALSE; player->is_collecting = FALSE; @@ -1609,6 +1636,7 @@ void InitGame() AmoebaNr[x][y] = 0; WasJustMoving[x][y] = 0; WasJustFalling[x][y] = 0; + CheckCollision[x][y] = 0; Stop[x][y] = FALSE; Pushed[x][y] = FALSE; @@ -2078,6 +2106,12 @@ void InitMovDir(int x, int y) else if (move_pattern == MV_ALONG_LEFT_SIDE || move_pattern == MV_ALONG_RIGHT_SIDE) { +#if 1 + /* use random direction as default start direction */ + if (game.engine_version >= VERSION_IDENT(3,1,0,2)) + MovDir[x][y] = 1 << RND(4); +#endif + for (i = 0; i < NUM_DIRECTIONS; i++) { int x1 = x + xy[i][0]; @@ -2488,6 +2522,10 @@ static void RemoveField(int x, int y) ChangePage[x][y] = -1; Pushed[x][y] = FALSE; +#if 0 + ExplodeField[x][y] = EX_TYPE_NONE; +#endif + GfxElement[x][y] = EL_UNDEFINED; GfxAction[x][y] = ACTION_DEFAULT; GfxDir[x][y] = MV_NO_MOVING; @@ -3390,12 +3428,16 @@ void DynaExplode(int ex, int ey) Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER); +#if 1 + if (element != EL_EMPTY && element != EL_EXPLOSION && + !CAN_GROW_INTO(element) && !dynabomb_xl) + break; +#else /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */ - if (element != EL_EMPTY && - element != EL_SAND && - element != EL_EXPLOSION && - !dynabomb_xl) + if (element != EL_EMPTY && element != EL_EXPLOSION && + element != EL_SAND && !dynabomb_xl) break; +#endif } } } @@ -3905,6 +3947,7 @@ void Impact(int x, int y) return; } + /* !!! not sufficient for all cases -- see EL_PEARL below !!! */ /* only reset graphic animation if graphic really changes after impact */ if (impact && el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element)) @@ -3920,6 +3963,8 @@ void Impact(int x, int y) } else if (impact && element == EL_PEARL) { + ResetGfxAnimation(x, y); + Feld[x][y] = EL_PEARL_BREAKING; PlayLevelSound(x, y, SND_PEARL_BREAKING); return; @@ -4039,6 +4084,8 @@ void Impact(int x, int y) } else if (smashed == EL_PEARL) { + ResetGfxAnimation(x, y); + Feld[x][y + 1] = EL_PEARL_BREAKING; PlayLevelSound(x, y, SND_PEARL_BREAKING); return; @@ -4071,10 +4118,18 @@ void Impact(int x, int y) CheckElementChange(x, y + 1, smashed, element, CE_SMASHED); - CheckTriggeredElementChangeSide(x, y + 1, smashed, - CE_OTHER_IS_SWITCHING, CH_SIDE_TOP); - CheckElementChangeSide(x, y + 1, smashed, element, - CE_SWITCHED, CH_SIDE_TOP); +#if 1 + /* !!! TEST ONLY !!! */ + CheckElementChangeBySide(x, y + 1, smashed, element, + CE_SWITCHED, CH_SIDE_TOP); + CheckTriggeredElementChangeBySide(x, y + 1, smashed, + CE_OTHER_IS_SWITCHING,CH_SIDE_TOP); +#else + CheckTriggeredElementChangeBySide(x, y + 1, smashed, + CE_OTHER_IS_SWITCHING,CH_SIDE_TOP); + CheckElementChangeBySide(x, y + 1, smashed, element, + CE_SWITCHED, CH_SIDE_TOP); +#endif } } else @@ -4454,7 +4509,13 @@ inline static void TurnRoundExt(int x, int y) } } +#if 1 + if (element == EL_ROBOT && ZX >= 0 && ZY >= 0 && + (Feld[ZX][ZY] == EL_ROBOT_WHEEL_ACTIVE || + game.engine_version < VERSION_IDENT(3,1,0,0))) +#else if (element == EL_ROBOT && ZX >= 0 && ZY >= 0) +#endif { attr_x = ZX; attr_y = ZY; @@ -4998,12 +5059,16 @@ void StartMoving(int x, int y) #endif } #if 1 - else if ((game.engine_version < VERSION_IDENT(2,2,0,7) && - CAN_SMASH(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] && - (Feld[x][y + 1] == EL_BLOCKED)) || + else if ((game.engine_version >= VERSION_IDENT(3,1,0,0) && + CheckCollision[x][y] && !IS_FREE(x, y + 1)) || + (game.engine_version >= VERSION_IDENT(3,0,7,0) && CAN_SMASH(element) && WasJustFalling[x][y] && - (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1)))) + (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) || + + (game.engine_version < VERSION_IDENT(2,2,0,7) && + CAN_SMASH(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] && + (Feld[x][y + 1] == EL_BLOCKED))) #else #if 1 @@ -5165,9 +5230,15 @@ void StartMoving(int x, int y) #endif #if 1 + +#if 1 + if (game.engine_version >= VERSION_IDENT(3,1,0,0) && + CheckCollision[x][y] && IN_LEV_FIELD_AND_NOT_FREE(newx, newy)) +#else 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))) +#endif { #if 0 printf("::: element %d '%s' WasJustMoving %d [%d, %d, %d, %d]\n", @@ -5555,14 +5626,23 @@ void StartMoving(int x, int y) DrawLevelField(newx, newy); } + /* if digged element was about to explode, prevent the explosion */ + ExplodeField[newx][newy] = EX_TYPE_NONE; + PlayLevelSoundAction(x, y, action); } #if 1 +#if 1 + Store[newx][newy] = EL_EMPTY; + if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element))) + Store[newx][newy] = element_info[element].move_leave_element; +#else Store[newx][newy] = EL_EMPTY; if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element)) || element_info[element].move_leave_type == LEAVE_TYPE_UNLIMITED) Store[newx][newy] = element_info[element].move_leave_element; +#endif #else if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element))) element_info[element].can_leave_element = TRUE; @@ -5769,6 +5849,7 @@ void StartMoving(int x, int y) void ContinueMoving(int x, int y) { int element = Feld[x][y]; + int stored = Store[x][y]; struct ElementInfo *ei = &element_info[element]; int direction = MovDir[x][y]; int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0); @@ -5873,13 +5954,15 @@ void ContinueMoving(int x, int y) { element = Feld[newx][newy] = EL_ACID; } -#if 1 +#if 0 else if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) && - ei->move_leave_element != EL_EMPTY && Store[x][y] != EL_EMPTY) + ei->move_leave_element != EL_EMPTY && + (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || + Store[x][y] != EL_EMPTY)) { /* some elements can leave other elements behind after moving */ - Feld[x][y] = Store[x][y]; + Feld[x][y] = ei->move_leave_element; InitField(x, y, FALSE); if (GFX_CRUMBLED(Feld[x][y])) @@ -5915,6 +5998,22 @@ void ContinueMoving(int x, int y) ResetGfxAnimation(x, y); /* reset animation values for old field */ +#if 1 + if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) && + ei->move_leave_element != EL_EMPTY && + (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || + stored != EL_EMPTY)) + { + /* some elements can leave other elements behind after moving */ + + Feld[x][y] = ei->move_leave_element; + InitField(x, y, FALSE); + + if (GFX_CRUMBLED(Feld[x][y])) + DrawLevelFieldCrumbledSandNeighbours(x, y); + } +#endif + #if 0 /* some elements can leave other elements behind after moving */ if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) && @@ -5950,9 +6049,18 @@ void ContinueMoving(int x, int y) MovDir[newx][newy] = 0; */ +#if 0 if (!CAN_MOVE(element) || (CAN_FALL(element) && direction == MV_DOWN)) GfxDir[x][y] = MovDir[newx][newy] = 0; +#else + if (!CAN_MOVE(element) || + (CAN_FALL(element) && direction == MV_DOWN && + (element == EL_SPRING || + element_info[element].move_pattern == MV_WHEN_PUSHED || + element_info[element].move_pattern == MV_WHEN_DROPPED))) + GfxDir[x][y] = MovDir[newx][newy] = 0; +#endif #endif #endif @@ -5977,10 +6085,16 @@ void ContinueMoving(int x, int y) if (!pushed_by_player) { + int nextx = newx + dx, nexty = newy + dy; + boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty); + WasJustMoving[newx][newy] = 3; if (CAN_FALL(element) && direction == MV_DOWN) WasJustFalling[newx][newy] = 3; + + if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again) + CheckCollision[newx][newy] = 2; } if (DONT_TOUCH(element)) /* object may be nasty to player or others */ @@ -5998,6 +6112,26 @@ void ContinueMoving(int x, int y) (newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1))) Impact(x, newy); +#if 1 + if (pushed_by_player) + { + static int trigger_sides[4] = + { + CH_SIDE_RIGHT, /* moving left */ + CH_SIDE_LEFT, /* moving right */ + CH_SIDE_BOTTOM, /* moving up */ + CH_SIDE_TOP, /* moving down */ + }; + int dig_side = trigger_sides[MV_DIR_BIT(direction)]; + struct PlayerInfo *player = PLAYERINFO(x, y); + + CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER, + player->index_bit, dig_side); + CheckTriggeredElementChangeByPlayer(newx,newy,element,CE_OTHER_GETS_PUSHED, + player->index_bit, dig_side); + } +#endif + #if 1 TestIfElementTouchesCustomElement(x, y); /* empty or new element */ #endif @@ -6018,8 +6152,8 @@ void ContinueMoving(int x, int y) int hitting_element = Feld[newx][newy]; /* !!! fix side (direction) orientation here and elsewhere !!! */ - CheckElementChangeSide(newx, newy, hitting_element, CE_HITTING_SOMETHING, - direction); + CheckElementChangeBySide(newx, newy, hitting_element, CE_HITTING_SOMETHING, + direction); #if 0 if (IN_LEV_FIELD(nextx, nexty)) @@ -6036,8 +6170,8 @@ void ContinueMoving(int x, int y) { int i; - CheckElementChangeSide(nextx, nexty, touched_element, - CE_HIT_BY_SOMETHING, opposite_direction); + CheckElementChangeBySide(nextx, nexty, touched_element, + CE_HIT_BY_SOMETHING, opposite_direction); if (IS_CUSTOM_ELEMENT(hitting_element) && HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING)) @@ -6052,8 +6186,8 @@ void ContinueMoving(int x, int y) change->trigger_side & touched_side && change->trigger_element == touched_element) { - CheckElementChangePage(newx, newy, hitting_element, - touched_element, CE_OTHER_IS_HITTING, i); + CheckElementChangeByPage(newx, newy, hitting_element, + touched_element, CE_OTHER_IS_HITTING,i); break; } } @@ -6072,8 +6206,8 @@ void ContinueMoving(int x, int y) change->trigger_side & hitting_side && change->trigger_element == hitting_element) { - CheckElementChangePage(nextx, nexty, touched_element, - hitting_element, CE_OTHER_GETS_HIT, i); + CheckElementChangeByPage(nextx, nexty, touched_element, + hitting_element, CE_OTHER_GETS_HIT, i); break; } } @@ -6389,6 +6523,15 @@ void AmoebeAbleger(int ax, int ay) if (!IN_LEV_FIELD(x, y)) return; +#if 1 + if (IS_FREE(x, y) || + CAN_GROW_INTO(Feld[x][y]) || + Feld[x][y] == EL_QUICKSAND_EMPTY) + { + newax = x; + neway = y; + } +#else /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */ if (IS_FREE(x, y) || Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY) @@ -6396,6 +6539,7 @@ void AmoebeAbleger(int ax, int ay) newax = x; neway = y; } +#endif if (newax == ax && neway == ay) return; @@ -6414,6 +6558,16 @@ void AmoebeAbleger(int ax, int ay) if (!IN_LEV_FIELD(x, y)) continue; +#if 1 + if (IS_FREE(x, y) || + CAN_GROW_INTO(Feld[x][y]) || + Feld[x][y] == EL_QUICKSAND_EMPTY) + { + newax = x; + neway = y; + break; + } +#else /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */ if (IS_FREE(x, y) || Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY) @@ -6422,13 +6576,18 @@ void AmoebeAbleger(int ax, int ay) neway = y; break; } +#endif else if (IS_PLAYER(x, y)) waiting_for_player = TRUE; } if (newax == ax && neway == ay) /* amoeba cannot grow */ { +#if 1 + if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA)) +#else if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH)) +#endif { Feld[ax][ay] = EL_AMOEBA_DEAD; DrawLevelField(ax, ay); @@ -6559,6 +6718,20 @@ void Life(int ax, int ay) changed = TRUE; } } +#if 1 + else if (IS_FREE(xx, yy) || CAN_GROW_INTO(Feld[xx][yy])) + { /* free border field */ + if (nachbarn >= life[2] && nachbarn <= life[3]) + { + Feld[xx][yy] = element; + MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1); + if (!Stop[xx][yy]) + DrawLevelField(xx, yy); + Stop[xx][yy] = TRUE; + changed = TRUE; + } + } +#else /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */ else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_SAND) { /* free border field */ @@ -6572,6 +6745,7 @@ void Life(int ax, int ay) changed = TRUE; } } +#endif } if (changed) @@ -6597,7 +6771,12 @@ static void StopRobotWheel(int x, int y) static void InitTimegateWheel(int x, int y) { +#if 1 + ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND; +#else + /* another brainless, "type style" bug ... :-( */ ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND; +#endif } static void RunTimegateWheel(int x, int y) @@ -7053,7 +7232,7 @@ static boolean ChangeElementNow(int x, int y, int element, int page) Changed[x][y] |= ChangeEvent[x][y]; /* ignore same changes in this frame */ - CheckTriggeredElementChangePage(x,y, Feld[x][y], CE_OTHER_IS_CHANGING, page); + CheckTriggeredElementChangeByPage(x,y,Feld[x][y], CE_OTHER_IS_CHANGING,page); if (change->explode) { @@ -7072,6 +7251,8 @@ static boolean ChangeElementNow(int x, int y, int element, int page) { boolean is_empty; boolean is_diggable; + boolean is_collectible; + boolean is_removable; boolean is_destructible; int ex = x + xx - 1; int ey = y + yy - 1; @@ -7104,14 +7285,24 @@ static boolean ChangeElementNow(int x, int y, int element, int page) e = MovingOrBlocked2Element(ex, ey); #if 1 + +#if 1 + is_empty = (IS_FREE(ex, ey) || (IS_FREE_OR_PLAYER(ex, ey) && + IS_WALKABLE(content_element))); +#else is_empty = (IS_FREE(ex, ey) || (IS_PLAYER(ex, ey) && IS_WALKABLE(content_element))); +#endif is_diggable = (is_empty || IS_DIGGABLE(e)); + is_collectible = (is_empty || IS_COLLECTIBLE(e)); + is_removable = (is_diggable || is_collectible); is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e)); can_replace[xx][yy] = - ((change->replace_when == CP_WHEN_EMPTY && is_empty) || - (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) || + ((change->replace_when == CP_WHEN_EMPTY && is_empty) || + (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) || + (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) || + (change->replace_when == CP_WHEN_REMOVABLE && is_removable) || (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)); if (!can_replace[xx][yy]) @@ -8026,6 +8217,8 @@ void GameActions() WasJustMoving[x][y]--; if (WasJustFalling[x][y] > 0) WasJustFalling[x][y]--; + if (CheckCollision[x][y] > 0) + CheckCollision[x][y]--; GfxFrame[x][y]++; @@ -8255,6 +8448,21 @@ void GameActions() #endif element = Feld[x][y]; +#if 1 + if (!IS_PLAYER(x,y) && + (element == EL_EMPTY || + CAN_GROW_INTO(element) || + element == EL_QUICKSAND_EMPTY || + element == EL_ACID_SPLASH_LEFT || + element == EL_ACID_SPLASH_RIGHT)) + { + if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) || + (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) || + (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) || + (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET)) + Feld[x][y] = EL_AMOEBA_DROP; + } +#else /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */ if (!IS_PLAYER(x,y) && (element == EL_EMPTY || @@ -8269,6 +8477,7 @@ void GameActions() (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET)) Feld[x][y] = EL_AMOEBA_DROP; } +#endif random = random * 129 + 1; } @@ -8541,6 +8750,7 @@ void ScrollLevel(int dx, int dy) redraw_mask |= REDRAW_FIELD; } +#if 0 static boolean canEnterSupaplexPort(int x, int y, int dx, int dy) { int nextx = x + dx, nexty = y + dy; @@ -8572,6 +8782,63 @@ static boolean canEnterSupaplexPort(int x, int y, int dx, int dy) return TRUE; } +#endif + +static boolean canFallDown(struct PlayerInfo *player) +{ + int jx = player->jx, jy = player->jy; + + return (IN_LEV_FIELD(jx, jy + 1) && + (IS_FREE(jx, jy + 1) || + (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) && + IS_WALKABLE_FROM(Feld[jx][jy], MV_DOWN) && + !IS_WALKABLE_INSIDE(Feld[jx][jy])); +} + +static boolean canPassField(int x, int y, int move_dir) +{ + int opposite_dir = MV_DIR_OPPOSITE(move_dir); + 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 nextx = x + dx; + int nexty = y + dy; + int element = Feld[x][y]; + + return (IS_PASSABLE_FROM(element, opposite_dir) && + !CAN_MOVE(element) && + IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) && + IS_WALKABLE_FROM(Feld[nextx][nexty], move_dir) && + (level.can_pass_to_walkable || IS_FREE(nextx, nexty))); +} + +static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir) +{ + int opposite_dir = MV_DIR_OPPOSITE(move_dir); + 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 newx = x + dx; + int newy = y + dy; +#if 0 + int nextx = newx + dx; + int nexty = newy + dy; +#endif + +#if 1 + return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) && + (IS_DIGGABLE(Feld[newx][newy]) || + IS_WALKABLE_FROM(Feld[newx][newy], opposite_dir) || + canPassField(newx, newy, move_dir))); +#else + return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) && + (IS_DIGGABLE(Feld[newx][newy]) || + IS_WALKABLE_FROM(Feld[newx][newy], opposite_dir) || + (IS_PASSABLE_FROM(Feld[newx][newy], opposite_dir) && + !CAN_MOVE(Feld[newx][newy]) && + IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) && + IS_WALKABLE_FROM(Feld[nextx][nexty], move_dir) && + (level.can_pass_to_walkable || IS_FREE(nextx, nexty))))); +#endif +} static void CheckGravityMovement(struct PlayerInfo *player) { @@ -8584,45 +8851,82 @@ static void CheckGravityMovement(struct PlayerInfo *player) int move_dir_horizontal = player->action & MV_HORIZONTAL; int move_dir_vertical = player->action & MV_VERTICAL; #endif + +#if 1 + boolean player_is_snapping = player->effective_action & JOY_BUTTON_1; +#else + boolean player_is_snapping = player->action & JOY_BUTTON_1; +#endif + + int jx = player->jx, jy = player->jy; + + boolean player_is_moving_to_valid_field = + (!player_is_snapping && + (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) || + canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical))); + +#if 0 int move_dir = (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; +#endif + +#if 0 + int opposite_dir = MV_DIR_OPPOSITE(move_dir); 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; -#if 1 - boolean player_is_snapping = player->effective_action & JOY_BUTTON_1; -#else - boolean player_is_snapping = player->action & JOY_BUTTON_1; + int nextx = new_jx + dx, nexty = new_jy + dy; #endif + +#if 1 + #if 1 + boolean player_can_fall_down = canFallDown(player); +#else 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))); +#endif + #else boolean player_can_fall_down = (IN_LEV_FIELD(jx, jy + 1) && (IS_FREE(jx, jy + 1))); #endif + +#if 0 boolean player_is_moving_to_valid_field = ( #if 1 !player_is_snapping && #endif + +#if 1 + IN_LEV_FIELD(new_jx, new_jy) && + (IS_DIGGABLE(Feld[new_jx][new_jy]) || + (IS_SP_PORT(Feld[new_jx][new_jy]) && + element_info[Feld[new_jx][new_jy]].access_direction & opposite_dir && + IN_LEV_FIELD(nextx, nexty) && + element_info[Feld[nextx][nexty]].access_direction & move_dir)) +#else 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]) && - canEnterSupaplexPort(new_jx, new_jy, dx, dy)))); + canEnterSupaplexPort(new_jx, new_jy, dx, dy))) /* !!! extend EL_SAND to anything diggable !!! */ +#endif + ); +#endif +#if 0 boolean player_is_standing_on_valid_field = (IS_WALKABLE_INSIDE(Feld[jx][jy]) || - (IS_WALKABLE(Feld[jx][jy]) && - !(element_info[Feld[jx][jy]].access_direction & MV_DOWN))); + (IS_WALKABLE(Feld[jx][jy]) && !ACCESS_FROM(Feld[jx][jy], MV_DOWN))); +#endif #if 0 printf("::: checking gravity NOW [%d, %d, %d] [%d] [%d / %d] ...\n", @@ -8635,7 +8939,9 @@ static void CheckGravityMovement(struct PlayerInfo *player) #endif if (player_can_fall_down && +#if 0 !player_is_standing_on_valid_field && +#endif !player_is_moving_to_valid_field) { #if 0 @@ -8757,7 +9063,9 @@ boolean MovePlayerOneStep(struct PlayerInfo *player, player->step_counter++; +#if 0 player->drop_delay = 0; +#endif PlayerVisit[jx][jy] = FrameCounter; @@ -8766,17 +9074,17 @@ boolean MovePlayerOneStep(struct PlayerInfo *player, #if 0 if (IS_CUSTOM_ELEMENT(Feld[jx][jy])) { - CheckTriggeredElementChangeSide(jx, jy, Feld[jx][jy], CE_OTHER_GETS_LEFT, - leave_side); - CheckElementChangeSide(jx, jy, Feld[jx][jy], CE_LEFT_BY_PLAYER,leave_side); + CheckTriggeredElementChangeBySide(jx, jy, Feld[jx][jy], CE_OTHER_GETS_LEFT, + leave_side); + CheckElementChangeBySide(jx,jy, Feld[jx][jy],CE_LEFT_BY_PLAYER,leave_side); } if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy])) { - CheckTriggeredElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy], - CE_OTHER_GETS_ENTERED, enter_side); - CheckElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy], - CE_ENTERED_BY_PLAYER, enter_side); + CheckTriggeredElementChangeBySide(new_jx, new_jy, Feld[new_jx][new_jy], + CE_OTHER_GETS_ENTERED, enter_side); + CheckElementChangeBySide(new_jx, new_jy, Feld[new_jx][new_jy], + CE_ENTERED_BY_PLAYER, enter_side); } #endif @@ -8828,6 +9136,9 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy) #endif + /* store if player is automatically moved to next field */ + player->is_auto_moving = (player->programmed_action != MV_NO_MOVING); + /* remove the last programmed player action */ player->programmed_action = 0; @@ -8976,6 +9287,10 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy) #if 0 /* !!! ENABLE THIS FOR OLD VERSIONS !!! */ + +#if 1 + if (game.engine_version < VERSION_IDENT(3,1,0,0)) +#endif { static int trigger_sides[4][2] = { @@ -8990,22 +9305,23 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy) int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1]; #if 1 - CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy], - CE_OTHER_GETS_LEFT, - player->index_bit, leave_side); - + /* !!! TEST ONLY !!! */ if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy])) - CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy], - CE_LEFT_BY_PLAYER, - player->index_bit, leave_side); + CheckElementChangeByPlayer(old_jx, old_jy, Feld[old_jx][old_jy], + CE_LEFT_BY_PLAYER, + player->index_bit, leave_side); - CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy], - CE_OTHER_GETS_ENTERED, - player->index_bit, enter_side); + CheckTriggeredElementChangeByPlayer(old_jx, old_jy, Feld[old_jx][old_jy], + CE_OTHER_GETS_LEFT, + player->index_bit, leave_side); if (IS_CUSTOM_ELEMENT(Feld[jx][jy])) - CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER, - player->index_bit, enter_side); + CheckElementChangeByPlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER, + player->index_bit, enter_side); + + CheckTriggeredElementChangeByPlayer(jx, jy, Feld[jx][jy], + CE_OTHER_GETS_ENTERED, + player->index_bit, enter_side); #endif } @@ -9125,6 +9441,9 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) #if 1 /* !!! ENABLE THIS FOR NEW VERSIONS !!! */ /* this breaks one level: "machine", level 000 */ +#if 0 + if (game.engine_version >= VERSION_IDENT(3,1,0,0)) +#endif { static int trigger_sides[4][2] = { @@ -9141,22 +9460,23 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) int old_jy = last_jy; #if 1 - CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy], - CE_OTHER_GETS_LEFT, - player->index_bit, leave_side); - + /* !!! TEST ONLY !!! */ if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy])) - CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy], - CE_LEFT_BY_PLAYER, - player->index_bit, leave_side); + CheckElementChangeByPlayer(old_jx, old_jy, Feld[old_jx][old_jy], + CE_LEFT_BY_PLAYER, + player->index_bit, leave_side); - CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy], - CE_OTHER_GETS_ENTERED, - player->index_bit, enter_side); + CheckTriggeredElementChangeByPlayer(old_jx, old_jy, Feld[old_jx][old_jy], + CE_OTHER_GETS_LEFT, + player->index_bit, leave_side); if (IS_CUSTOM_ELEMENT(Feld[jx][jy])) - CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER, - player->index_bit, enter_side); + CheckElementChangeByPlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER, + player->index_bit, enter_side); + + CheckTriggeredElementChangeByPlayer(jx, jy, Feld[jx][jy], + CE_OTHER_GETS_ENTERED, + player->index_bit, enter_side); #endif } @@ -9295,11 +9615,20 @@ void TestIfPlayerTouchesCustomElement(int x, int y) else continue; /* center and border element do not touch */ - CheckTriggeredElementChangePlayer(xx, yy, border_element, - CE_OTHER_GETS_TOUCHED, - player->index_bit, border_side); - CheckElementChangePlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER, - player->index_bit, border_side); +#if 1 + /* !!! TEST ONLY !!! */ + CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER, + player->index_bit, border_side); + CheckTriggeredElementChangeByPlayer(xx, yy, border_element, + CE_OTHER_GETS_TOUCHED, + player->index_bit, border_side); +#else + CheckTriggeredElementChangeByPlayer(xx, yy, border_element, + CE_OTHER_GETS_TOUCHED, + player->index_bit, border_side); + CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER, + player->index_bit, border_side); +#endif } else if (IS_PLAYER(xx, yy)) { @@ -9311,11 +9640,20 @@ void TestIfPlayerTouchesCustomElement(int x, int y) continue; /* center and border element do not touch */ } - CheckTriggeredElementChangePlayer(x, y, center_element, - CE_OTHER_GETS_TOUCHED, - player->index_bit, center_side); - CheckElementChangePlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER, - player->index_bit, center_side); +#if 1 + /* !!! TEST ONLY !!! */ + CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER, + player->index_bit, center_side); + CheckTriggeredElementChangeByPlayer(x, y, center_element, + CE_OTHER_GETS_TOUCHED, + player->index_bit, center_side); +#else + CheckTriggeredElementChangeByPlayer(x, y, center_element, + CE_OTHER_GETS_TOUCHED, + player->index_bit, center_side); + CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER, + player->index_bit, center_side); +#endif break; } @@ -9424,8 +9762,8 @@ void TestIfElementTouchesCustomElement(int x, int y) printf("::: border_element %d, %d\n", x, y); #endif - CheckElementChangePage(xx, yy, border_element, center_element, - CE_OTHER_IS_TOUCHING, j); + CheckElementChangeByPage(xx, yy, border_element, center_element, + CE_OTHER_IS_TOUCHING, j); break; } } @@ -9438,8 +9776,8 @@ void TestIfElementTouchesCustomElement(int x, int y) printf("::: center_element %d, %d\n", x, y); #endif - CheckElementChangePage(x, y, center_element, border_trigger_element, - CE_OTHER_IS_TOUCHING, center_element_change_page); + CheckElementChangeByPage(x, y, center_element, border_trigger_element, + CE_OTHER_IS_TOUCHING, center_element_change_page); } } @@ -9469,8 +9807,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction) touched_element = (IN_LEV_FIELD(hitx, hity) ? MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL); - CheckElementChangeSide(x, y, hitting_element, touched_element, - CE_HITTING_SOMETHING, direction); + CheckElementChangeBySide(x, y, hitting_element, touched_element, + CE_HITTING_SOMETHING, direction); if (IN_LEV_FIELD(hitx, hity)) { @@ -9492,8 +9830,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction) { int i; - CheckElementChangeSide(hitx, hity, touched_element, hitting_element, - CE_HIT_BY_SOMETHING, opposite_direction); + CheckElementChangeBySide(hitx, hity, touched_element, hitting_element, + CE_HIT_BY_SOMETHING, opposite_direction); if (IS_CUSTOM_ELEMENT(hitting_element) && HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING)) @@ -9514,8 +9852,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction) #endif ) { - CheckElementChangePage(x, y, hitting_element, touched_element, - CE_OTHER_IS_HITTING, i); + CheckElementChangeByPage(x, y, hitting_element, touched_element, + CE_OTHER_IS_HITTING, i); break; } } @@ -9539,8 +9877,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction) #endif ) { - CheckElementChangePage(hitx, hity, touched_element, - hitting_element, CE_OTHER_GETS_HIT, i); + CheckElementChangeByPage(hitx, hity, touched_element, + hitting_element, CE_OTHER_GETS_HIT, i); break; } } @@ -9576,8 +9914,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction) touched_element = (IN_LEV_FIELD(hitx, hity) ? MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL); - CheckElementChangeSide(x, y, hitting_element, touched_element, - EP_CAN_SMASH_EVERYTHING, direction); + CheckElementChangeBySide(x, y, hitting_element, touched_element, + EP_CAN_SMASH_EVERYTHING, direction); if (IN_LEV_FIELD(hitx, hity)) { @@ -9599,8 +9937,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction) { int i; - CheckElementChangeSide(hitx, hity, touched_element, hitting_element, - CE_SMASHED_BY_SOMETHING, opposite_direction); + CheckElementChangeBySide(hitx, hity, touched_element, hitting_element, + CE_SMASHED_BY_SOMETHING, opposite_direction); if (IS_CUSTOM_ELEMENT(hitting_element) && HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_SMASHING)) @@ -9621,8 +9959,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction) #endif ) { - CheckElementChangePage(x, y, hitting_element, touched_element, - CE_OTHER_IS_SMASHING, i); + CheckElementChangeByPage(x, y, hitting_element, touched_element, + CE_OTHER_IS_SMASHING, i); break; } } @@ -9646,8 +9984,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction) #endif ) { - CheckElementChangePage(hitx, hity, touched_element, - hitting_element, CE_OTHER_GETS_SMASHED, i); + CheckElementChangeByPage(hitx, hity, touched_element, + hitting_element, CE_OTHER_GETS_SMASHED,i); break; } } @@ -9660,6 +9998,7 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction) void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir) { int i, kill_x = -1, kill_y = -1; + int bad_element = -1; static int test_xy[4][2] = { { 0, -1 }, @@ -9681,6 +10020,7 @@ void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir) test_x = good_x + test_xy[i][0]; test_y = good_y + test_xy[i][1]; + if (!IN_LEV_FIELD(test_x, test_y)) continue; @@ -9701,6 +10041,8 @@ void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir) { kill_x = test_x; kill_y = test_y; + bad_element = test_element; + break; } } @@ -9711,10 +10053,18 @@ void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir) { struct PlayerInfo *player = PLAYERINFO(good_x, good_y); +#if 1 + if (player->shield_deadly_time_left > 0 && + !IS_INDESTRUCTIBLE(bad_element)) + Bang(kill_x, kill_y); + else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y)) + KillHero(player); +#else if (player->shield_deadly_time_left > 0) Bang(kill_x, kill_y); else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y)) KillHero(player); +#endif } else Bang(good_x, good_y); @@ -9803,10 +10153,18 @@ void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir) { struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y); +#if 1 + if (player->shield_deadly_time_left > 0 && + !IS_INDESTRUCTIBLE(bad_element)) + Bang(bad_x, bad_y); + else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y)) + KillHero(player); +#else if (player->shield_deadly_time_left > 0) Bang(bad_x, bad_y); else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y)) KillHero(player); +#endif } else Bang(kill_x, kill_y); @@ -10075,8 +10433,10 @@ int DigField(struct PlayerInfo *player, #endif - if (IS_WALKABLE(old_element) && - !(element_info[old_element].access_direction & move_direction)) + if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction)) + return MF_NO_ACTION; /* field has no opening in this direction */ + + if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction)) return MF_NO_ACTION; /* field has no opening in this direction */ element = Feld[x][y]; @@ -10087,6 +10447,7 @@ int DigField(struct PlayerInfo *player, switch (element) { +#if 0 case EL_SP_PORT_LEFT: case EL_SP_PORT_RIGHT: case EL_SP_PORT_UP: @@ -10154,6 +10515,7 @@ int DigField(struct PlayerInfo *player, PlayLevelSound(x, y, SND_CLASS_SP_PORT_PASSING); break; +#endif #if 0 case EL_TUBE_ANY: @@ -10202,19 +10564,32 @@ int DigField(struct PlayerInfo *player, default: +#if 1 + if (IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction)) +#else if (IS_WALKABLE(element)) +#endif { int sound_action = ACTION_WALKING; - if (!(element_info[element].access_direction & opposite_direction)) +#if 0 + if (!ACCESS_FROM(element, opposite_direction)) return MF_NO_ACTION; /* field not accessible from this direction */ +#endif + +#if 1 + if (element == EL_EMPTY_SPACE && + game.gravity && !player->is_auto_moving && + canFallDown(player) && move_direction != MV_DOWN) + return MF_NO_ACTION; /* player cannot walk here due to gravity */ +#endif - if (element >= EL_GATE_1 && element <= EL_GATE_4) + if (IS_GATE(element)) { if (!player->key[element - EL_GATE_1]) return MF_NO_ACTION; } - else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY) + else if (IS_GATE_GRAY(element)) { if (!player->key[element - EL_GATE_1_GRAY]) return MF_NO_ACTION; @@ -10238,30 +10613,63 @@ int DigField(struct PlayerInfo *player, break; } +#if 1 + else if (IS_PASSABLE(element) && canPassField(x, y, move_direction)) +#else else if (IS_PASSABLE(element)) +#endif { +#if 0 + if (!canPassField(x, y, move_direction)) + return MF_NO_ACTION; +#else + +#if 0 +#if 1 + if (!IN_LEV_FIELD(nextx, nexty) || IS_PLAYER(nextx, nexty) || + !IS_WALKABLE_FROM(Feld[nextx][nexty], move_direction) || + (!level.can_pass_to_walkable && !IS_FREE(nextx, nexty))) + return MF_NO_ACTION; +#else if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty)) return MF_NO_ACTION; +#endif +#endif +#if 1 + if (!ACCESS_FROM(element, opposite_direction)) + return MF_NO_ACTION; /* field not accessible from this direction */ +#else if (IS_CUSTOM_ELEMENT(element) && - !(element_info[element].access_direction & opposite_direction)) + !ACCESS_FROM(element, opposite_direction)) return MF_NO_ACTION; /* field not accessible from this direction */ +#endif #if 1 if (CAN_MOVE(element)) /* only fixed elements can be passed! */ return MF_NO_ACTION; #endif - if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4) +#endif + + if (IS_EM_GATE(element)) { if (!player->key[element - EL_EM_GATE_1]) return MF_NO_ACTION; } - else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY) + else if (IS_EM_GATE_GRAY(element)) { if (!player->key[element - EL_EM_GATE_1_GRAY]) return MF_NO_ACTION; } + else if (IS_SP_PORT(element)) + { + if (element == EL_SP_GRAVITY_PORT_LEFT || + element == EL_SP_GRAVITY_PORT_RIGHT || + element == EL_SP_GRAVITY_PORT_UP || + element == EL_SP_GRAVITY_PORT_DOWN) + game.gravity = !game.gravity; + } /* automatically move to the next field with double speed */ player->programmed_action = move_direction; @@ -10299,8 +10707,8 @@ int DigField(struct PlayerInfo *player, PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING); - CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_DIGGED, - player->index_bit, dig_side); + CheckTriggeredElementChangeByPlayer(x, y, element,CE_OTHER_GETS_DIGGED, + player->index_bit, dig_side); #if 1 if (mode == DF_SNAP) @@ -10372,7 +10780,8 @@ int DigField(struct PlayerInfo *player, ShowEnvelope(element - EL_ENVELOPE_1); #endif } - else if (IS_DROPPABLE(element)) /* can be collected and dropped */ + else if (IS_DROPPABLE(element) || + IS_THROWABLE(element)) /* can be collected and dropped */ { int i; @@ -10398,9 +10807,9 @@ int DigField(struct PlayerInfo *player, RaiseScoreElement(element); PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING); - CheckTriggeredElementChangePlayer(x, y, element, - CE_OTHER_GETS_COLLECTED, - player->index_bit, dig_side); + CheckTriggeredElementChangeByPlayer(x, y, element, + CE_OTHER_GETS_COLLECTED, + player->index_bit, dig_side); #if 1 if (mode == DF_SNAP) @@ -10556,10 +10965,23 @@ int DigField(struct PlayerInfo *player, else player->push_delay_value = -1; /* get new value later */ - CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PUSHED, - player->index_bit, dig_side); - CheckElementChangePlayer(x, y, element, CE_PUSHED_BY_PLAYER, - player->index_bit, dig_side); +#if 1 + /* check for element change _after_ element has been pushed! */ +#else + +#if 1 + /* !!! TEST ONLY !!! */ + CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER, + player->index_bit, dig_side); + CheckTriggeredElementChangeByPlayer(x, y, element,CE_OTHER_GETS_PUSHED, + player->index_bit, dig_side); +#else + CheckTriggeredElementChangeByPlayer(x, y, element,CE_OTHER_GETS_PUSHED, + player->index_bit, dig_side); + CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER, + player->index_bit, dig_side); +#endif +#endif break; } @@ -10663,17 +11085,34 @@ int DigField(struct PlayerInfo *player, player->switch_x = x; player->switch_y = y; - CheckTriggeredElementChangePlayer(x, y, element, - CE_OTHER_IS_SWITCHING, - player->index_bit, dig_side); - CheckElementChangePlayer(x, y, element, CE_SWITCHED, - player->index_bit, dig_side); +#if 1 + /* !!! TEST ONLY !!! */ + CheckElementChangeByPlayer(x, y, element, CE_SWITCHED, + player->index_bit, dig_side); + CheckTriggeredElementChangeByPlayer(x, y, element, + CE_OTHER_IS_SWITCHING, + player->index_bit, dig_side); +#else + CheckTriggeredElementChangeByPlayer(x, y, element, + CE_OTHER_IS_SWITCHING, + player->index_bit, dig_side); + CheckElementChangeByPlayer(x, y, element, CE_SWITCHED, + player->index_bit, dig_side); +#endif } - CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PRESSED, - player->index_bit, dig_side); - CheckElementChangePlayer(x, y, element, CE_PRESSED_BY_PLAYER, - player->index_bit, dig_side); +#if 1 + /* !!! TEST ONLY !!! (this breaks "machine", level 000) */ + CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER, + player->index_bit, dig_side); + CheckTriggeredElementChangeByPlayer(x,y, element,CE_OTHER_GETS_PRESSED, + player->index_bit, dig_side); +#else + CheckTriggeredElementChangeByPlayer(x,y, element,CE_OTHER_GETS_PRESSED, + player->index_bit, dig_side); + CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER, + player->index_bit, dig_side); +#endif } return MF_NO_ACTION; @@ -10772,17 +11211,29 @@ boolean DropElement(struct PlayerInfo *player) CH_SIDE_TOP, /* dropping up */ CH_SIDE_BOTTOM, /* dropping down */ }; - int jx = player->jx, jy = player->jy; + int old_element, new_element; + int dropx = player->jx, dropy = player->jy; int drop_direction = player->MovDir; int drop_side = trigger_sides[MV_DIR_BIT(drop_direction)]; - int old_element = Feld[jx][jy]; - int new_element = (player->inventory_size > 0 ? - player->inventory_element[player->inventory_size - 1] : - player->inventory_infinite_element != EL_UNDEFINED ? - player->inventory_infinite_element : - player->dynabombs_left > 0 ? - EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr : - EL_UNDEFINED); + int drop_element = (player->inventory_size > 0 ? + player->inventory_element[player->inventory_size - 1] : + player->inventory_infinite_element != EL_UNDEFINED ? + player->inventory_infinite_element : + player->dynabombs_left > 0 ? + EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr : + EL_UNDEFINED); + + if (IS_THROWABLE(drop_element)) + { + dropx += GET_DX_FROM_DIR(drop_direction); + dropy += GET_DY_FROM_DIR(drop_direction); + + if (!IN_LEV_FIELD(dropx, dropy)) + return FALSE; + } + + old_element = Feld[dropx][dropy]; /* old element at dropping position */ + new_element = drop_element; /* default: no change when dropping */ /* check if player is active, not moving and ready to drop */ if (!player->active || player->MovPos || player->drop_delay > 0) @@ -10815,10 +11266,10 @@ boolean DropElement(struct PlayerInfo *player) #endif if (old_element != EL_EMPTY) - Back[jx][jy] = old_element; /* store old element on this field */ + Back[dropx][dropy] = old_element; /* store old element on this field */ - ResetGfxAnimation(jx, jy); - ResetRandomAnimationValue(jx, jy); + ResetGfxAnimation(dropx, dropy); + ResetRandomAnimationValue(dropx, dropy); if (player->inventory_size > 0 || player->inventory_infinite_element != EL_UNDEFINED) @@ -10839,25 +11290,35 @@ boolean DropElement(struct PlayerInfo *player) new_element = EL_SP_DISK_RED_ACTIVE; } - Feld[jx][jy] = new_element; + Feld[dropx][dropy] = new_element; - if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy))) - DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0); + if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy))) + DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy), + el2img(Feld[dropx][dropy]), 0); - PlayLevelSoundAction(jx, jy, ACTION_DROPPING); + PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING); #if 1 /* needed if previous element just changed to "empty" in the last frame */ - Changed[jx][jy] = 0; /* allow another change */ + Changed[dropx][dropy] = 0; /* allow another change */ #endif - CheckTriggeredElementChangePlayer(jx, jy, new_element, - CE_OTHER_GETS_DROPPED, - player->index_bit, drop_side); - CheckElementChangePlayer(jx, jy, new_element, CE_DROPPED_BY_PLAYER, - player->index_bit, drop_side); +#if 1 + /* !!! TEST ONLY !!! */ + CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER, + player->index_bit, drop_side); + CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element, + CE_OTHER_GETS_DROPPED, + player->index_bit, drop_side); +#else + CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element, + CE_OTHER_GETS_DROPPED, + player->index_bit, drop_side); + CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER, + player->index_bit, drop_side); +#endif - TestIfElementTouchesCustomElement(jx, jy); + TestIfElementTouchesCustomElement(dropx, dropy); } else /* player is dropping a dyna bomb */ { @@ -10867,74 +11328,92 @@ boolean DropElement(struct PlayerInfo *player) new_element = EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr; #endif - Feld[jx][jy] = new_element; + Feld[dropx][dropy] = new_element; - if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy))) - DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0); + if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy))) + DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy), + el2img(Feld[dropx][dropy]), 0); - PlayLevelSoundAction(jx, jy, ACTION_DROPPING); + PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING); } #if 1 - if (Feld[jx][jy] == new_element) /* uninitialized unless CE change */ + if (Feld[dropx][dropy] == new_element) /* uninitialized unless CE change */ { #if 1 - InitField_WithBug1(jx, jy, FALSE); + InitField_WithBug1(dropx, dropy, FALSE); #else - InitField(jx, jy, FALSE); - if (CAN_MOVE(Feld[jx][jy])) - InitMovDir(jx, jy); + InitField(dropx, dropy, FALSE); + if (CAN_MOVE(Feld[dropx][dropy])) + InitMovDir(dropx, dropy); #endif } - new_element = Feld[jx][jy]; + new_element = Feld[dropx][dropy]; /* element might have changed */ if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) && element_info[new_element].move_pattern == MV_WHEN_DROPPED) { +#if 0 int move_stepsize = element_info[new_element].move_stepsize; - int direction, dx, dy, nextx, nexty; +#endif + int move_direction, nextx, nexty; if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC) - MovDir[jx][jy] = player->MovDir; + MovDir[dropx][dropy] = drop_direction; + + move_direction = MovDir[dropx][dropy]; + nextx = dropx + GET_DX_FROM_DIR(move_direction); + nexty = dropy + GET_DY_FROM_DIR(move_direction); - direction = MovDir[jx][jy]; - dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0); - dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0); - nextx = jx + dx; - nexty = jy + dy; +#if 1 + Changed[dropx][dropy] = 0; /* allow another change */ + CheckCollision[dropx][dropy] = 2; +#else if (IN_LEV_FIELD(nextx, nexty) && IS_FREE(nextx, nexty)) { #if 0 - WasJustMoving[jx][jy] = 3; + WasJustMoving[dropx][dropy] = 3; #else - InitMovingField(jx, jy, direction); - ContinueMoving(jx, jy); +#if 1 + InitMovingField(dropx, dropy, move_direction); + ContinueMoving(dropx, dropy); +#endif #endif } +#if 1 else { - Changed[jx][jy] = 0; /* allow another change */ + Changed[dropx][dropy] = 0; /* allow another change */ #if 1 - TestIfElementHitsCustomElement(jx, jy, direction); + TestIfElementHitsCustomElement(dropx, dropy, move_direction); #else - CheckElementChangeSide(jx, jy, new_element, touched_element, - CE_HITTING_SOMETHING, direction); + CheckElementChangeBySide(dropx, dropy, new_element, touched_element, + CE_HITTING_SOMETHING, move_direction); #endif } +#endif +#endif + +#if 0 player->drop_delay = 2 * TILEX / move_stepsize + 1; +#endif } #if 0 player->drop_delay = 8 + 8 + 8; #endif +#if 1 + player->drop_delay = GET_NEW_DROP_DELAY(drop_element); +#endif + #endif player->is_dropping = TRUE;