static void TestIfPlayerTouchesCustomElement(int, int);
static void TestIfElementTouchesCustomElement(int, int);
+static boolean CheckTriggeredElementSideChange(int, int, int, int, int);
static boolean CheckTriggeredElementChange(int, int, int, int);
+static boolean CheckElementSideChange(int, int, int, int, int, int);
static boolean CheckElementChange(int, int, int, int);
static void PlaySoundLevel(int, int, int);
NULL,
NULL
},
+ {
+ EL_SP_EXIT_OPENING,
+ EL_SP_EXIT_OPEN,
+ 29,
+ NULL,
+ NULL,
+ NULL
+ },
+ {
+ EL_SP_EXIT_CLOSING,
+ EL_SP_EXIT_CLOSED,
+ 29,
+ NULL,
+ NULL,
+ NULL
+ },
{
EL_SWITCHGATE_OPENING,
EL_SWITCHGATE_OPEN,
MovDir[x][y] = 1 << RND(4);
break;
+#if 0
case EL_SP_EMPTY:
Feld[x][y] = EL_EMPTY;
break;
+#endif
+#if 0
case EL_EM_KEY_1_FILE:
Feld[x][y] = EL_EM_KEY_1;
break;
case EL_EM_KEY_4_FILE:
Feld[x][y] = EL_EM_KEY_4;
break;
+#endif
case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
ei->change_events = CE_BITMASK_DEFAULT;
for (j=0; j < NUM_CHANGE_EVENTS; j++)
{
- ei->event_page_num[j] = 0;
+ ei->event_page_nr[j] = 0;
ei->event_page[j] = &ei->change_page[0];
}
}
!(ei->change_events & CH_EVENT_BIT(k)))
{
ei->change_events |= CH_EVENT_BIT(k);
- ei->event_page_num[k] = j;
+ ei->event_page_nr[k] = j;
ei->event_page[k] = &ei->change_page[j];
}
}
player->Frame = 0;
player->StepFrame = 0;
+ player->switch_x = -1;
+ player->switch_y = -1;
+
player->use_murphy_graphic = FALSE;
player->use_disk_red_graphic = FALSE;
player->is_digging = FALSE;
player->is_collecting = FALSE;
+ player->show_envelope = 0;
+
player->move_delay = game.initial_move_delay;
player->move_delay_value = game.initial_move_delay_value;
game.timegate_time_left = 0;
game.switchgate_pos = 0;
game.balloon_dir = MV_NO_MOVING;
+ game.gravity = level.initial_gravity;
game.explosions_delayed = TRUE;
+ game.envelope_active = FALSE;
+
for (i=0; i<4; i++)
{
game.belt_dir[i] = MV_NO_MOVING;
JustStopped[x][y] = 0;
Stop[x][y] = FALSE;
Pushed[x][y] = FALSE;
- Changed[x][y] = FALSE;
+
+ Changed[x][y] = CE_BITMASK_DEFAULT;
+ ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
+
ExplodePhase[x][y] = 0;
ExplodeField[x][y] = EX_NO_EXPLOSION;
}
/* close exit door after last player */
- if (Feld[ExitX][ExitY] == EL_EXIT_OPEN && AllPlayersGone)
+ if ((Feld[ExitX][ExitY] == EL_EXIT_OPEN ||
+ Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN) && AllPlayersGone)
{
- Feld[ExitX][ExitY] = EL_EXIT_CLOSING;
+ int element = Feld[ExitX][ExitY];
- PlaySoundLevelElementAction(ExitX, ExitY, EL_EXIT_OPEN, ACTION_CLOSING);
+ Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
+ EL_SP_EXIT_CLOSING);
+
+ PlaySoundLevelElementAction(ExitX, ExitY, element, ACTION_CLOSING);
}
/* Hero disappears */
if (GfxElement[x][y] == EL_UNDEFINED)
{
- printf("\n\n\n");
+ printf("\n\n");
printf("Explode(): x = %d, y = %d: GfxElement == EL_UNDEFINED\n", x, y);
printf("Explode(): This should never happen!\n");
- printf("\n\n\n");
+ printf("\n\n");
GfxElement[x][y] = EL_EMPTY;
}
InitMovDir(x, y);
DrawLevelField(x, y);
- if (CAN_BE_CRUMBLED(element))
+ TestIfElementTouchesCustomElement(x, y);
+
+ if (GFX_CRUMBLED(element))
DrawLevelFieldCrumbledSandNeighbours(x, y);
if (IS_PLAYER(x, y) && !PLAYERINFO(x,y)->present)
int element = Feld[x][y];
#endif
+#if 1
+ if (IS_PLAYER(x, y) && !PLAYER_PROTECTED(x, y))
+#else
if (IS_PLAYER(x, y))
+#endif
{
struct PlayerInfo *player = PLAYERINFO(x, y);
else
{
CheckElementChange(x, y + 1, smashed, CE_SMASHED);
+
+ CheckTriggeredElementSideChange(x, y + 1, smashed, CH_SIDE_TOP,
+ CE_OTHER_IS_SWITCHING);
+ CheckElementSideChange(x, y + 1, smashed, CH_SIDE_TOP,
+ CE_SWITCHED, -1);
}
}
else
MovDir[x][y] = old_move_dir;
}
}
+ else if (element_info[element].move_pattern == MV_WHEN_PUSHED)
+ {
+ if (!IN_LEV_FIELD_AND_IS_FREE(move_x, move_y))
+ MovDir[x][y] = MV_NO_MOVING;
+
+ MovDelay[x][y] = 0;
+ }
}
static boolean JustBeingPushed(int x, int y)
#endif
}
#if 1
+
+#if 0
+ /* TEST: bug where player gets not killed by falling rock ... */
+ else if (CAN_SMASH(element) &&
+ (Feld[x][y + 1] == EL_BLOCKED ||
+ IS_PLAYER(x, y + 1)) &&
+ JustStopped[x][y] && !Pushed[x][y + 1])
+
+#else
#if 1
else if (game.engine_version < RELEASE_IDENT(2,2,0,7) &&
CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
JustStopped[x][y])
#endif
+#endif
+
{
/* calling "Impact()" here is not only completely unneccessary
(because it already gets called from "ContinueMoving()" in
{
int newx, newy;
+#if 1
+ if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
+ return;
+#else
if ((element == EL_SATELLITE ||
element == EL_BALLOON ||
element == EL_SPRING)
&& JustBeingPushed(x, y))
return;
+#endif
#if 0
#if 0
element1 != EL_DRAGON && element2 != EL_DRAGON &&
element1 != EL_FLAMES && element2 != EL_FLAMES)
{
+#if 1
+ ResetGfxAnimation(x, y);
+ GfxAction[x][y] = ACTION_ATTACKING;
+#endif
+
if (IS_PLAYER(x, y))
DrawPlayerField(x, y);
else
Feld[newx1][newy1] = EL_FLAMES;
if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
Feld[newx2][newy2] = EL_FLAMES;
+
return;
}
}
/* copy element change control values to new field */
ChangeDelay[newx][newy] = ChangeDelay[x][y];
+ Changed[newx][newy] = Changed[x][y];
+ ChangeEvent[newx][newy] = ChangeEvent[x][y];
+
+ ChangeDelay[x][y] = 0;
+ Changed[x][y] = CE_BITMASK_DEFAULT;
+ ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
/* copy animation control values to new field */
GfxFrame[newx][newy] = GfxFrame[x][y];
Stop[newx][newy] = TRUE; /* ignore this element until the next frame */
+ /* prevent pushed element from moving on in pushed direction */
+ if (pushed && CAN_MOVE(element) &&
+ element_info[element].move_pattern & MV_ANY_DIRECTION &&
+ !(element_info[element].move_pattern & MovDir[newx][newy]))
+ TurnRound(newx, newy);
+
if (!pushed) /* special case: moving object pushed by player */
JustStopped[newx][newy] = 3;
Impact(x, newy);
if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
- CheckElementChange(newx, newy, element, CE_COLLISION);
+ CheckElementSideChange(newx, newy, element, direction, CE_COLLISION, -1);
+
+#if 1
+ TestIfElementTouchesCustomElement(x, y); /* for empty space */
+#endif
TestIfPlayerTouchesCustomElement(newx, newy);
TestIfElementTouchesCustomElement(newx, newy);
return;
}
- Feld[x][y] = EL_SP_EXIT_OPEN;
+ if (AllPlayersGone) /* do not re-open exit door closed after last player */
+ return;
+
+ Feld[x][y] = EL_SP_EXIT_OPENING;
PlaySoundLevelNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
}
RemoveField(x, y);
Feld[x][y] = target_element;
- Changed[x][y] = TRUE; /* no more changes in this frame */
+ Changed[x][y] |= ChangeEvent[x][y]; /* ignore same changes in this frame */
ResetGfxAnimation(x, y);
ResetRandomAnimationValue(x, y);
DrawLevelField(x, y);
- if (CAN_BE_CRUMBLED(Feld[x][y]))
+ if (GFX_CRUMBLED(Feld[x][y]))
DrawLevelFieldCrumbledSandNeighbours(x, y);
TestIfBadThingTouchesHero(x, y);
{
struct ElementChangeInfo *change = &element_info[element].change_page[page];
- if (Changed[x][y]) /* do not change already changed elements */
+ /* always use default change event to prevent running into a loop */
+ if (ChangeEvent[x][y] == CE_BITMASK_DEFAULT)
+ ChangeEvent[x][y] = CH_EVENT_BIT(CE_DELAY);
+
+ /* do not change already changed elements with same change event */
+#if 0
+ if (Changed[x][y] & ChangeEvent[x][y])
return FALSE;
+#else
+ if (Changed[x][y])
+ return FALSE;
+#endif
- Changed[x][y] = TRUE; /* no more changes in this frame */
+ Changed[x][y] |= ChangeEvent[x][y]; /* ignore same changes in this frame */
CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_IS_CHANGING);
if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
RemoveMovingField(ex, ey);
+ ChangeEvent[ex][ey] = ChangeEvent[x][y];
+
ChangeElementNowExt(ex, ey, change->content[xx][yy]);
something_has_changed = TRUE;
int element = MovingOrBlocked2Element(x, y);
struct ElementChangeInfo *change = &element_info[element].change_page[page];
+#if 0
+#ifdef DEBUG
+ if (!CAN_CHANGE(element))
+ {
+ printf("\n\n");
+ printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
+ x, y, element, element_info[element].token_name);
+ printf("ChangeElement(): This should never happen!\n");
+ printf("\n\n");
+ }
+#endif
+#endif
+
if (ChangeDelay[x][y] == 0) /* initialize element change */
{
ChangeDelay[x][y] = ( change->delay_fixed * change->delay_frames +
}
}
-static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
- int trigger_event)
+static boolean CheckTriggeredElementSideChange(int lx, int ly,
+ int trigger_element,
+ int trigger_side,
+ int trigger_event)
{
int i, j, x, y;
if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
return FALSE;
-#if 0
- /* prevent this function from running into a loop */
- if (trigger_event == CE_OTHER_IS_CHANGING)
- Changed[lx][ly] = TRUE;
-#endif
-
for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
-#if 1
boolean change_element = FALSE;
- int page;
+ int page = 0;
- if (!CAN_CHANGE(element) ||
- !HAS_ANY_CHANGE_EVENT(element, trigger_event))
+ if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
continue;
for (j=0; j < element_info[element].num_change_pages; j++)
{
- if (element_info[element].change_page[j].trigger_element ==
- trigger_element)
+ struct ElementChangeInfo *change = &element_info[element].change_page[j];
+
+ if (change->sides & trigger_side &&
+ change->trigger_element == trigger_element)
{
change_element = TRUE;
page = j;
if (!change_element)
continue;
-#else
- if (!CAN_CHANGE(element) ||
- !HAS_ANY_CHANGE_EVENT(element, trigger_event) ||
- element_info[element].change->trigger_element != trigger_element)
- continue;
-#endif
-
for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
{
- if (x == lx && y == ly) /* do not change trigger element itself */
- continue;
-
#if 0
- if (Changed[x][y]) /* do not change already changed elements */
+ if (x == lx && y == ly) /* do not change trigger element itself */
continue;
#endif
if (Feld[x][y] == element)
{
ChangeDelay[x][y] = 1;
+ ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
ChangeElement(x, y, page);
-
-#if 0
- Changed[x][y] = TRUE; /* prevent element from being changed again */
-#endif
}
}
}
-#if 0
- /* reset change prevention array */
- for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
- Changed[x][y] = FALSE;
-#endif
-
return TRUE;
}
-static boolean CheckElementChangeExt(int x, int y, int element,
- int trigger_event, int page)
+static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
+ int trigger_event)
+{
+ return CheckTriggeredElementSideChange(lx, ly, trigger_element, CH_SIDE_ANY,
+ trigger_event);
+}
+
+static boolean CheckElementSideChange(int x, int y, int element, int side,
+ int trigger_event, int page)
{
if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
return FALSE;
if (Feld[x][y] == EL_BLOCKED)
+ {
Blocked2Moving(x, y, &x, &y);
+ element = Feld[x][y];
+ }
+
+ if (page < 0)
+ page = element_info[element].event_page_nr[trigger_event];
+
+ if (!(element_info[element].change_page[page].sides & side))
+ return FALSE;
ChangeDelay[x][y] = 1;
+ ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
ChangeElement(x, y, page);
return TRUE;
static boolean CheckElementChange(int x, int y, int element, int trigger_event)
{
- int page = element_info[element].event_page_num[trigger_event];
-
- return CheckElementChangeExt(x, y, element, trigger_event, page);
+ return CheckElementSideChange(x, y, element, CH_SIDE_ANY, trigger_event, -1);
}
static void PlayerActions(struct PlayerInfo *player, byte player_action)
for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
{
- Changed[x][y] = FALSE;
+ Changed[x][y] = CE_BITMASK_DEFAULT;
+ ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
Stop[x][y] = FALSE;
if (JustStopped[x][y] > 0)
/* this may take place after moving, so 'element' may have changed */
if (IS_CHANGING(x, y))
{
- ChangeElement(x, y, element_info[element].event_page_num[CE_DELAY]);
+ ChangeElement(x, y, element_info[element].event_page_nr[CE_DELAY]);
element = Feld[x][y];
graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
}
}
}
- if (TimeFrames >= (1000 / GameFrameDelay))
+ if (TimeFrames >= FRAMES_PER_SECOND)
{
TimeFrames = 0;
TimePlayed++;
stored_player[i].StepFrame += move_frames;
}
#endif
+
+#if 1
+ if (local_player->show_envelope != 0 && local_player->MovPos == 0)
+ {
+ ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
+
+ local_player->show_envelope = 0;
+ }
+#endif
}
static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
static void CheckGravityMovement(struct PlayerInfo *player)
{
- if (level.gravity && !player->programmed_action)
+ 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);
boolean MoveFigureOneStep(struct PlayerInfo *player,
int dx, int dy, int real_dx, int real_dy)
{
+ static int change_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 = (dx == -1 ? MV_LEFT :
+ dx == +1 ? MV_RIGHT :
+ dy == -1 ? MV_UP :
+ dy == +1 ? MV_DOWN : MV_NO_MOVING);
+ int enter_side = change_sides[MV_DIR_BIT(move_direction)][0];
+ int leave_side = change_sides[MV_DIR_BIT(move_direction)][1];
int jx = player->jx, jy = player->jy;
- int new_jx = jx+dx, new_jy = jy+dy;
+ int new_jx = jx + dx, new_jy = jy + dy;
int element;
int can_move;
StorePlayer[jx][jy] = 0;
player->last_jx = jx;
player->last_jy = jy;
- jx = player->jx = new_jx;
- jy = player->jy = new_jy;
- StorePlayer[jx][jy] = player->element_nr;
+ player->jx = new_jx;
+ player->jy = new_jy;
+ StorePlayer[new_jx][new_jy] = player->element_nr;
player->MovPos =
(dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
ScrollFigure(player, SCROLL_INIT);
+#if 1
+ if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
+ {
+ CheckTriggeredElementSideChange(jx, jy, Feld[jx][jy], leave_side,
+ CE_OTHER_GETS_LEFT);
+ CheckElementSideChange(jx, jy, Feld[jx][jy], leave_side,
+ CE_LEFT_BY_PLAYER, -1);
+ }
+
+ if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
+ {
+ CheckTriggeredElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy],
+ enter_side, CE_OTHER_GETS_ENTERED);
+ CheckElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy], enter_side,
+ CE_ENTERED_BY_PLAYER, -1);
+ }
+#endif
+
return MF_MOVING;
}
#if 1
player->snapped = FALSE;
#endif
+
+#if 1
+ player->Switching = FALSE;
+#endif
}
else
{
DrawPlayer(player); /* needed here only to cleanup last field */
#endif
- if (player->MovPos == 0)
+ if (player->MovPos == 0) /* player reached destination field */
{
if (IS_PASSABLE(Feld[last_jx][last_jy]))
{
player->last_jy = jy;
if (Feld[jx][jy] == EL_EXIT_OPEN ||
- Feld[jx][jy] == EL_SP_EXIT_OPEN)
+ Feld[jx][jy] == EL_SP_EXIT_OPEN ||
+ Feld[jx][jy] == EL_SP_EXIT_OPENING) /* <-- special case */
{
DrawPlayer(player); /* needed here only to cleanup last field */
RemoveHero(player);
if (local_player->friends_still_needed == 0 ||
- Feld[jx][jy] == EL_SP_EXIT_OPEN)
+ IS_SP_ELEMENT(Feld[jx][jy]))
player->LevelSolved = player->GameOver = TRUE;
}
{ +1, 0 },
{ 0, +1 }
};
+ static int change_sides[4][2] =
+ {
+ /* center side border side */
+ { CH_SIDE_TOP, CH_SIDE_BOTTOM }, /* check top */
+ { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* check left */
+ { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* check right */
+ { CH_SIDE_BOTTOM, CH_SIDE_TOP } /* check bottom */
+ };
int i;
#if 0
{
int xx = x + xy[i][0];
int yy = y + xy[i][1];
+ int center_side = change_sides[i][0];
+ int border_side = change_sides[i][1];
if (!IN_LEV_FIELD(xx, yy))
continue;
+#if 1
+ if (IS_PLAYER(x, y))
+ {
+ CheckTriggeredElementSideChange(xx, yy, Feld[xx][yy], border_side,
+ CE_OTHER_GETS_TOUCHED);
+ CheckElementSideChange(xx, yy, Feld[xx][yy], border_side,
+ CE_TOUCHED_BY_PLAYER, -1);
+ }
+ else if (IS_PLAYER(xx, yy))
+ {
+ CheckTriggeredElementSideChange(x, y, Feld[x][y], center_side,
+ CE_OTHER_GETS_TOUCHED);
+ CheckElementSideChange(x, y, Feld[x][y], center_side,
+ CE_TOUCHED_BY_PLAYER, -1);
+
+ break;
+ }
+#else
if (IS_PLAYER(x, y))
{
CheckTriggeredElementChange(xx, yy, Feld[xx][yy], CE_OTHER_GETS_TOUCHED);
break;
}
+#endif
}
#if 0
{ +1, 0 },
{ 0, +1 }
};
+ static int change_sides[4][2] =
+ {
+ /* center side border side */
+ { CH_SIDE_TOP, CH_SIDE_BOTTOM }, /* check top */
+ { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* check left */
+ { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* check right */
+ { CH_SIDE_BOTTOM, CH_SIDE_TOP } /* check bottom */
+ };
boolean change_center_element = FALSE;
int center_element_change_page = 0;
int center_element = Feld[x][y];
{
int xx = x + xy[i][0];
int yy = y + xy[i][1];
+ int center_side = change_sides[i][0];
+ int border_side = change_sides[i][1];
int border_element;
if (!IN_LEV_FIELD(xx, yy))
&element_info[center_element].change_page[j];
if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
+ change->sides & border_side &&
change->trigger_element == border_element)
{
change_center_element = TRUE;
&element_info[border_element].change_page[j];
if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
+ change->sides & center_side &&
change->trigger_element == center_element)
{
- CheckElementChangeExt(xx,yy, border_element,CE_OTHER_IS_TOUCHING, j);
+ CheckElementSideChange(xx, yy, border_element, CH_SIDE_ANY,
+ CE_OTHER_IS_TOUCHING, j);
break;
}
}
}
if (change_center_element)
- CheckElementChangeExt(x, y, center_element, CE_OTHER_IS_TOUCHING,
- center_element_change_page);
+ CheckElementSideChange(x, y, center_element, CH_SIDE_ANY,
+ CE_OTHER_IS_TOUCHING, center_element_change_page);
#if 0
check_changing = FALSE;
int DigField(struct PlayerInfo *player,
int x, int y, int real_dx, int real_dy, int mode)
{
+ static int change_sides[4] =
+ {
+ CH_SIDE_RIGHT, /* moving left */
+ CH_SIDE_LEFT, /* moving right */
+ CH_SIDE_BOTTOM, /* moving up */
+ CH_SIDE_TOP, /* moving down */
+ };
boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
int jx = player->jx, jy = player->jy;
int dx = x - jx, dy = y - jy;
dx == +1 ? MV_RIGHT :
dy == -1 ? MV_UP :
dy == +1 ? MV_DOWN : MV_NO_MOVING);
+ int dig_side = change_sides[MV_DIR_BIT(move_direction)];
int element;
if (player->MovPos == 0)
switch (element)
{
+#if 0
case EL_ROBOT_WHEEL:
Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
ZX = x;
PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
return MF_ACTION;
break;
+#endif
+#if 0
case EL_SP_TERMINAL:
{
int xx, yy;
return MF_ACTION;
}
break;
+#endif
+#if 0
case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
+#if 1
+ if (!PLAYER_SWITCHING(player, x, y))
+#else
if (!player->Switching)
+#endif
{
player->Switching = TRUE;
+ player->switch_x = x;
+ player->switch_y = y;
+
ToggleBeltSwitch(x, y);
PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
}
return MF_ACTION;
break;
+#endif
+#if 0
case EL_SWITCHGATE_SWITCH_UP:
case EL_SWITCHGATE_SWITCH_DOWN:
+#if 1
+ if (!PLAYER_SWITCHING(player, x, y))
+#else
if (!player->Switching)
+#endif
{
player->Switching = TRUE;
+ player->switch_x = x;
+ player->switch_y = y;
+
ToggleSwitchgateSwitch(x, y);
PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
}
return MF_ACTION;
break;
+#endif
+#if 0
case EL_LIGHT_SWITCH:
case EL_LIGHT_SWITCH_ACTIVE:
+#if 1
+ if (!PLAYER_SWITCHING(player, x, y))
+#else
if (!player->Switching)
+#endif
{
player->Switching = TRUE;
+ player->switch_x = x;
+ player->switch_y = y;
+
ToggleLightSwitch(x, y);
PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
SND_LIGHT_SWITCH_ACTIVATING :
}
return MF_ACTION;
break;
+#endif
+#if 0
case EL_TIMEGATE_SWITCH:
ActivateTimegateSwitch(x, y);
PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
return MF_ACTION;
break;
+#endif
+#if 0
case EL_BALLOON_SWITCH_LEFT:
case EL_BALLOON_SWITCH_RIGHT:
case EL_BALLOON_SWITCH_UP:
return MF_ACTION;
break;
+#endif
case EL_SP_PORT_LEFT:
case EL_SP_PORT_RIGHT:
element == EL_SP_GRAVITY_PORT_RIGHT ||
element == EL_SP_GRAVITY_PORT_UP ||
element == EL_SP_GRAVITY_PORT_DOWN)
- level.gravity = !level.gravity;
+ game.gravity = !game.gravity;
/* automatically move to the next field with double speed */
player->programmed_action = move_direction;
}
break;
+#if 0
case EL_LAMP:
Feld[x][y] = EL_LAMP_ACTIVE;
local_player->lights_still_needed--;
PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
return MF_ACTION;
break;
+#endif
+#if 0
case EL_TIME_ORB_FULL:
Feld[x][y] = EL_TIME_ORB_EMPTY;
TimeLeft += 10;
PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
return MF_ACTION;
break;
+#endif
default:
if (!player->key[element - EL_GATE_1_GRAY])
return MF_NO_ACTION;
}
- else if (element == EL_EXIT_OPEN || element == EL_SP_EXIT_OPEN)
+ else if (element == EL_EXIT_OPEN ||
+ element == EL_SP_EXIT_OPEN ||
+ element == EL_SP_EXIT_OPENING)
{
sound_action = ACTION_PASSING; /* player is passing exit */
}
if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
return MF_NO_ACTION;
+#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)
{
if (!player->key[element - EL_EM_GATE_1])
GfxElement[x][y] = GFX_ELEMENT(element);
#else
GfxElement[x][y] =
- (CAN_BE_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
+ (GFX_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
#endif
player->is_digging = TRUE;
}
CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_DIGGED);
- TestIfElementTouchesCustomElement(x, y);
+ TestIfElementTouchesCustomElement(x, y); /* for empty space */
break;
}
el2edimg(EL_KEY_1 + key_nr));
redraw_mask |= REDRAW_DOOR_1;
}
- else if (element == EL_ENVELOPE)
+ else if (IS_ENVELOPE(element))
{
- ShowEnvelope();
+#if 1
+ player->show_envelope = element;
+#else
+ ShowEnvelope(element - EL_ENVELOPE_1);
+#endif
}
else if (IS_DROPPABLE(element)) /* can be collected and dropped */
{
CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_COLLECTED);
- TestIfElementTouchesCustomElement(x, y);
+ TestIfElementTouchesCustomElement(x, y); /* for empty space */
break;
}
!(element == EL_SPRING && use_spring_bug))
return MF_NO_ACTION;
+#if 1
+ /* do not push elements already moving away faster than player */
+ if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
+ ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
+ return MF_NO_ACTION;
+#else
if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
return MF_NO_ACTION;
-
+#endif
if (!player->Pushing &&
game.engine_version >= RELEASE_IDENT(2,2,0,7))
player->push_delay_value = GET_NEW_PUSH_DELAY(element);
if (game.engine_version < RELEASE_IDENT(2,2,0,7))
player->push_delay_value = GET_NEW_PUSH_DELAY(element);
+#if 1
+ CheckTriggeredElementSideChange(x, y, element, dig_side,
+ CE_OTHER_GETS_PUSHED);
+ CheckElementSideChange(x, y, element, dig_side,
+ CE_PUSHED_BY_PLAYER, -1);
+#else
CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PUSHED);
CheckElementChange(x, y, element, CE_PUSHED_BY_PLAYER);
+#endif
break;
}
+ else if (IS_SWITCHABLE(element))
+ {
+ if (PLAYER_SWITCHING(player, x, y))
+ return MF_ACTION;
+
+#if 1
+ PlaySoundLevelElementAction(x, y, element, ACTION_ACTIVATING);
+#endif
+
+ if (element == EL_ROBOT_WHEEL)
+ {
+ Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
+ ZX = x;
+ ZY = y;
+
+ DrawLevelField(x, y);
+
+#if 0
+ PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
+#endif
+ }
+ else if (element == EL_SP_TERMINAL)
+ {
+ int xx, yy;
+
+#if 0
+ PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
+#endif
+
+ for (yy=0; yy<lev_fieldy; yy++)
+ {
+ for (xx=0; xx<lev_fieldx; xx++)
+ {
+ if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
+ Bang(xx, yy);
+ else if (Feld[xx][yy] == EL_SP_TERMINAL)
+ Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
+ }
+ }
+ }
+ else if (IS_BELT_SWITCH(element))
+ {
+#if 0
+ if (!PLAYER_SWITCHING(player, x, y))
+#endif
+ {
+ player->Switching = TRUE;
+ player->switch_x = x;
+ player->switch_y = y;
+
+ ToggleBeltSwitch(x, y);
+
+#if 0
+ PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
+#endif
+ }
+ }
+ else if (element == EL_SWITCHGATE_SWITCH_UP ||
+ element == EL_SWITCHGATE_SWITCH_DOWN)
+ {
+#if 0
+ if (!PLAYER_SWITCHING(player, x, y))
+#endif
+ {
+ player->Switching = TRUE;
+ player->switch_x = x;
+ player->switch_y = y;
+
+ ToggleSwitchgateSwitch(x, y);
+
+#if 0
+ PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
+#endif
+ }
+ }
+ else if (element == EL_LIGHT_SWITCH ||
+ element == EL_LIGHT_SWITCH_ACTIVE)
+ {
+#if 0
+ if (!PLAYER_SWITCHING(player, x, y))
+#endif
+ {
+ player->Switching = TRUE;
+ player->switch_x = x;
+ player->switch_y = y;
+
+ ToggleLightSwitch(x, y);
+
+#if 0
+ PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
+ SND_LIGHT_SWITCH_ACTIVATING :
+ SND_LIGHT_SWITCH_DEACTIVATING);
+#endif
+ }
+ }
+ else if (element == EL_TIMEGATE_SWITCH)
+ {
+ ActivateTimegateSwitch(x, y);
+
+#if 0
+ PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
+#endif
+ }
+ else if (element == EL_BALLOON_SWITCH_LEFT ||
+ element == EL_BALLOON_SWITCH_RIGHT ||
+ element == EL_BALLOON_SWITCH_UP ||
+ element == EL_BALLOON_SWITCH_DOWN ||
+ element == EL_BALLOON_SWITCH_ANY)
+ {
+ if (element == EL_BALLOON_SWITCH_ANY)
+ game.balloon_dir = move_direction;
+ else
+ game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
+ element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
+ element == EL_BALLOON_SWITCH_UP ? MV_UP :
+ element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
+ MV_NO_MOVING);
+
+#if 0
+ PlaySoundLevel(x, y, SND_CLASS_BALLOON_SWITCH_ACTIVATING);
+#endif
+ }
+ else if (element == EL_LAMP)
+ {
+ Feld[x][y] = EL_LAMP_ACTIVE;
+ local_player->lights_still_needed--;
+
+ DrawLevelField(x, y);
+
+#if 0
+ PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
+#endif
+ }
+ else if (element == EL_TIME_ORB_FULL)
+ {
+ Feld[x][y] = EL_TIME_ORB_EMPTY;
+ TimeLeft += 10;
+ DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
+
+ DrawLevelField(x, y);
+
+#if 0
+ PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
+#endif
+ }
+
+ return MF_ACTION;
+ }
else
{
- CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PRESSED);
- CheckElementChange(x, y, element, CE_PRESSED_BY_PLAYER);
+#if 1
+ if (!PLAYER_SWITCHING(player, x, y))
+#else
+ if (!player->Switching)
+#endif
+ {
+ player->Switching = TRUE;
+ player->switch_x = x;
+ player->switch_y = y;
+
+ CheckTriggeredElementSideChange(x, y, element, dig_side,
+ CE_OTHER_IS_SWITCHING);
+ CheckElementSideChange(x, y, element, dig_side, CE_SWITCHED, -1);
+ }
+
+ CheckTriggeredElementSideChange(x, y, element, dig_side,
+ CE_OTHER_GETS_PRESSED);
+ CheckElementSideChange(x, y, element, dig_side,
+ CE_PRESSED_BY_PLAYER, -1);
}
return MF_NO_ACTION;
projects / rocksndiamonds.git / blobdiff