#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)
+ ELEMENT_CAN_ENTER_FIELD_BASE_4(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))
-
-#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)
#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))
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);
}
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);
}
/* 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 */
}
}
}
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;
{
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 */
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;
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;
Delay(wait_delay_value);
}
}
+#endif
}
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;
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;
#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;
}
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
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)
{
#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
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],
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)
{
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);
}
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);
}
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);
}
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);
}
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);
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)
{
#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
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;
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;
#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)))
{
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)
#if 0
/* !!! TEST !!! */
- CheckGravityMovement(player);
+ if (player->MovPos == 0)
+ CheckGravityMovement(player);
#endif
if (button1)
snapped = SnapField(player, dx, dy);
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];
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 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
int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
int new_jx = jx + dx, new_jy = jy + dy;
boolean player_is_snapping = player->action & JOY_BUTTON_1;
-#if 0
- /* !!! MAKE THIS CUSTOMIZABLE !!! */
- boolean field_under_player_is_free_or_acid =
+#if 1
+ boolean player_can_fall_down =
(IN_LEV_FIELD(jx, jy + 1) &&
- (IS_FREE(jx, jy + 1) || Feld[jx][jy + 1] == EL_ACID));
+ (IS_FREE(jx, jy + 1) ||
+ (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)));
#else
- boolean field_under_player_is_free_or_acid =
+ boolean player_can_fall_down =
(IN_LEV_FIELD(jx, jy + 1) &&
(IS_FREE(jx, jy + 1)));
#endif
#if 0
printf("::: checking gravity NOW [%d, %d, %d] [%d] ...\n",
- field_under_player_is_free_or_acid,
+ 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 (field_under_player_is_free_or_acid &&
+ if (player_can_fall_down &&
!player_is_standing_on_valid_field &&
!player_is_moving_to_valid_field)
{
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);
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;
}
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
+
}
}
projects / rocksndiamonds.git / blobdiff