/* for Explode() */
#define EX_PHASE_START 0
-#define EX_NO_EXPLOSION 0
-#define EX_NORMAL 1
-#define EX_CENTER 2
-#define EX_BORDER 3
+#define EX_TYPE_NONE 0
+#define EX_TYPE_NORMAL (1 << 0)
+#define EX_TYPE_CENTER (1 << 1)
+#define EX_TYPE_BORDER (1 << 2)
+#define EX_TYPE_CROSS (1 << 3)
+#define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER)
/* special positions in the game control window (relative to control window) */
#define XX_LEVEL 37
#define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
(element_info[e].move_delay_random))
+#define GET_TARGET_ELEMENT(e, ch) \
+ ((e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
+ (e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : (e))
+
#define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
(condition)))
static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
#define CheckTriggeredElementChange(x, y, e, ev) \
- CheckTriggeredElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, -1)
+ CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, \
+ CH_SIDE_ANY, -1)
#define CheckTriggeredElementChangePlayer(x, y, e, ev, p, s) \
CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
#define CheckTriggeredElementChangeSide(x, y, e, ev, s) \
- CheckTriggeredElementChangeExt(x, y, e, ev, -1, s, -1)
+ CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
#define CheckTriggeredElementChangePage(x, y, e, ev, p) \
- CheckTriggeredElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, p)
+ CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, \
+ CH_SIDE_ANY, p)
-static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
-#define CheckElementChange(x, y, e, ev) \
- CheckElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, -1)
+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) \
- CheckElementChangeExt(x, y, e, ev, p, s, -1)
-#define CheckElementChangeSide(x, y, e, ev, s) \
- CheckElementChangeExt(x, y, e, ev, -1, s, -1)
-#define CheckElementChangePage(x, y, e, ev, p) \
- CheckElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, p)
+ CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s, CH_PAGE_ANY)
+#define CheckElementChangeSide(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) \
+ CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
static void PlayLevelSound(int, int, int);
static void PlayLevelSoundNearest(int, int, int);
ei->change->post_change_function = ch_delay->post_change_function;
ei->change_events |= CH_EVENT_BIT(CE_DELAY);
+
+#if 1
+ SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
+#endif
}
#if 1
}
#endif
+ /* ---------- initialize run-time trigger player and element ------------- */
+
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
+
+ for (j = 0; j < ei->num_change_pages; j++)
+ {
+ ei->change_page[j].actual_trigger_element = EL_EMPTY;
+ ei->change_page[j].actual_trigger_player = EL_PLAYER_1;
+ }
+ }
+
/* ---------- initialize trigger events ---------------------------------- */
/* initialize trigger events information */
ExplodePhase[x][y] = 0;
ExplodeDelay[x][y] = 0;
- ExplodeField[x][y] = EX_NO_EXPLOSION;
+ ExplodeField[x][y] = EX_TYPE_NONE;
RunnerVisit[x][y] = 0;
PlayerVisit[x][y] = 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) && i != EL_EMPTY_SPACE) &&
+ 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 */
for (i = 0; i < element_info[element].num_change_pages; i++)
{
- content = element_info[element].change_page[i].content[xx][yy];
+ content= element_info[element].change_page[i].target_content[xx][yy];
is_player = ELEM_IS_PLAYER(content);
if (is_player && (found_rating < 1 || element < found_element))
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;
-#if 1
RemoveField(x, y); /* temporarily remove newly placed player */
DrawLevelField(x, y);
-#endif
if (player->present)
{
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 (player != local_player) /* do not visually relocate other players */
+ return;
+
+ if (level.instant_relocation)
{
#if 1
+ int offset = (setup.scroll_delay ? 3 : 0);
+ int jx = local_player->jx;
+ int jy = local_player->jy;
+
+ if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
+ {
+ 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);
+ }
+ else
+ {
+ if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
+ (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
+ scroll_x = jx - MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
+
+ if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
+ (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
+ scroll_y = jy - MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
+ /* 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 - old_jx);
scroll_y += (local_player->jy - old_jy);
/* 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);
+ }
+ else
+ {
+#if 1
#if 0
- DrawAllPlayers();
- BackToFront();
+ int offset = (setup.scroll_delay ? 3 : 0);
+ int jx = local_player->jx;
+ int jy = local_player->jy;
#endif
- }
+ int scroll_xx = -999, scroll_yy = -999;
+
+ ScrollScreen(NULL, SCROLL_GO_ON); /* scroll last frame to full tile */
+
+ while (scroll_xx != scroll_x || scroll_yy != scroll_y)
+ {
+ int dx = 0, dy = 0;
+ int fx = FX, fy = FY;
+ scroll_xx = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
+ local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
+ local_player->jx - MIDPOSX);
+
+ scroll_yy = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
+ local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
+ local_player->jy - MIDPOSY);
+
+ dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
+ dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
+
+#if 1
+ if (dx == 0 && dy == 0) /* no scrolling needed at all */
+ break;
#else
+ if (scroll_xx == scroll_x && scroll_yy == scroll_y)
+ break;
+#endif
- if (player == local_player)
- {
+ scroll_x -= dx;
+ scroll_y -= dy;
+
+ fx += dx * TILEX / 2;
+ fy += dy * TILEY / 2;
+
+ ScrollLevel(dx, dy);
+ DrawAllPlayers();
+
+ /* scroll in two steps of half tile size to make things smoother */
+ BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
+ FlushDisplay();
+ Delay(wait_delay_value);
+
+ /* scroll second step to align at full tile size */
+ BackToFront();
+ Delay(wait_delay_value);
+ }
+#else
int scroll_xx = -999, scroll_yy = -999;
+ ScrollScreen(NULL, SCROLL_GO_ON); /* scroll last frame to full tile */
+
while (scroll_xx != scroll_x || scroll_yy != scroll_y)
{
int dx = 0, dy = 0;
dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
+#if 1
+ if (dx == 0 && dy == 0) /* no scrolling needed at all */
+ break;
+#else
+ if (scroll_xx == scroll_x && scroll_yy == scroll_y)
+ break;
+#endif
+
scroll_x -= dx;
scroll_y -= dy;
BackToFront();
Delay(wait_delay_value);
}
- }
#endif
+ }
}
void Explode(int ex, int ey, int phase, int mode)
/* --- This is only really needed (and now handled) in "Impact()". --- */
/* do not explode moving elements that left the explode field in time */
if (game.engine_version >= VERSION_IDENT(2,2,0,7) &&
- center_element == EL_EMPTY && (mode == EX_NORMAL || mode == EX_CENTER))
+ center_element == EL_EMPTY &&
+ (mode == EX_TYPE_NORMAL || mode == EX_TYPE_CENTER))
return;
#endif
- if (mode == EX_NORMAL || mode == EX_CENTER)
+ if (mode == EX_TYPE_NORMAL || mode == EX_TYPE_CENTER)
PlayLevelSoundAction(ex, ey, ACTION_EXPLODING);
/* remove things displayed in background while burning dynamite */
}
#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;
int element;
#if 1
- if (!IN_LEV_FIELD(x, y) || (mode != EX_NORMAL && (x != ex || y != ey)))
+#if 1
+ if (!IN_LEV_FIELD(x, y) ||
+ (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
+ (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
continue;
#else
if (!IN_LEV_FIELD(x, y) ||
- ((mode != EX_NORMAL || center_element == EL_AMOEBA_TO_DIAMOND) &&
+ (mode != EX_TYPE_NORMAL && (x != ex || y != ey)))
+ continue;
+#endif
+#else
+ if (!IN_LEV_FIELD(x, y) ||
+ ((mode != EX_TYPE_NORMAL ||
+ center_element == EL_AMOEBA_TO_DIAMOND) &&
(x != ex || y != ey)))
continue;
#endif
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;
Store[x][y] = EL_EMPTY;
if (x != ex || y != ey ||
- center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_BORDER)
+ center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_TYPE_BORDER)
Store2[x][y] = element;
#if 0
#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)
{
{
int element;
+#if 0
+ printf("::: done: phase == %d\n", phase);
+#endif
+
#if 0
printf("::: explosion %d,%d done [%d]\n", x, y, FrameCounter);
#endif
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],
player->dynabombs_left++;
}
- Explode(ex, ey, EX_PHASE_START, EX_CENTER);
+ Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
for (i = 0; i < NUM_DIRECTIONS; i++)
{
if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
continue;
- Explode(x, y, EX_PHASE_START, EX_BORDER);
+ Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
/* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
if (element != EL_EMPTY &&
case EL_PACMAN:
case EL_MOLE:
RaiseScoreElement(element);
- Explode(x, y, EX_PHASE_START, EX_NORMAL);
+ Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
break;
case EL_DYNABOMB_PLAYER_1_ACTIVE:
case EL_DYNABOMB_PLAYER_2_ACTIVE:
case EL_AMOEBA_TO_DIAMOND:
#endif
if (IS_PLAYER(x, y))
- Explode(x, y, EX_PHASE_START, EX_NORMAL);
+ Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
else
- Explode(x, y, EX_PHASE_START, EX_CENTER);
+ Explode(x, y, EX_PHASE_START, EX_TYPE_CENTER);
break;
default:
- if (CAN_EXPLODE_DYNA(element))
+ if (CAN_EXPLODE_CROSS(element))
+#if 1
+ Explode(x, y, EX_PHASE_START, EX_TYPE_CROSS);
+#else
DynaExplode(x, y);
+#endif
else if (CAN_EXPLODE_1X1(element))
- Explode(x, y, EX_PHASE_START, EX_CENTER);
+ Explode(x, y, EX_PHASE_START, EX_TYPE_CENTER);
else
- Explode(x, y, EX_PHASE_START, EX_NORMAL);
+ Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
break;
}
boolean object_hit = FALSE;
boolean impact = (lastline || object_hit);
int element = Feld[x][y];
- int smashed = EL_UNDEFINED;
+ int smashed = EL_STEELWALL;
if (!lastline) /* check if element below was hit */
{
PlayLevelSound(x, y, SND_PEARL_BREAKING);
return;
}
- else if (impact && CheckElementChange(x, y, element, CE_IMPACT))
+ else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
{
PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
TestIfElementSmashesCustomElement(x, y, MV_DOWN);
#endif
- CheckElementChange(x, y + 1, smashed, CE_SMASHED);
+ 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, CE_SWITCHED, CH_SIDE_TOP);
+ CheckElementChangeSide(x, y + 1, smashed, element,
+ CE_SWITCHED, CH_SIDE_TOP);
}
}
else
{
- CheckElementChange(x, y + 1, smashed, CE_SMASHED);
+ CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
}
}
}
MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
MovDelay[newx][newy] = 0;
- /* copy element change control values to new field */
- ChangeDelay[newx][newy] = ChangeDelay[x][y];
- ChangePage[newx][newy] = ChangePage[x][y];
- Changed[newx][newy] = Changed[x][y];
- ChangeEvent[newx][newy] = ChangeEvent[x][y];
+ if (CAN_CHANGE(element))
+ {
+ /* copy element change control values to new field */
+ ChangeDelay[newx][newy] = ChangeDelay[x][y];
+ ChangePage[newx][newy] = ChangePage[x][y];
+ Changed[newx][newy] = Changed[x][y];
+ ChangeEvent[newx][newy] = ChangeEvent[x][y];
+ }
ChangeDelay[x][y] = 0;
ChangePage[x][y] = -1;
change->trigger_element == touched_element)
{
CheckElementChangePage(newx, newy, hitting_element,
- CE_OTHER_IS_HITTING, i);
+ touched_element, CE_OTHER_IS_HITTING, i);
break;
}
}
change->trigger_element == hitting_element)
{
CheckElementChangePage(nextx, nexty, touched_element,
- CE_OTHER_GETS_HIT, i);
+ hitting_element, CE_OTHER_GETS_HIT, i);
break;
}
}
static boolean ChangeElementNow(int x, int y, int element, int page)
{
struct ElementChangeInfo *change = &element_info[element].change_page[page];
+ int target_element;
/* 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);
+ if (ChangeEvent[x][y] == CH_EVENT_BIT(CE_DELAY))
+ {
+ /* reset actual trigger element and player */
+ change->actual_trigger_element = EL_EMPTY;
+ change->actual_trigger_player = EL_PLAYER_1;
+ }
+
/* do not change already changed elements with same change event */
#if 0
if (Changed[x][y] & ChangeEvent[x][y])
return TRUE;
}
- if (change->use_content)
+ if (change->use_target_content)
{
- boolean complete_change = TRUE;
- boolean can_change[3][3];
+ boolean complete_replace = TRUE;
+ boolean can_replace[3][3];
int xx, yy;
for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
{
- boolean half_destructible;
+ boolean is_empty;
+ boolean is_diggable;
+ boolean is_destructible;
int ex = x + xx - 1;
int ey = y + yy - 1;
+ int content_element = change->target_content[xx][yy];
int e;
- can_change[xx][yy] = TRUE;
+ can_replace[xx][yy] = TRUE;
if (ex == x && ey == y) /* do not check changing element itself */
continue;
- if (change->content[xx][yy] == EL_EMPTY_SPACE)
+ if (content_element == EL_EMPTY_SPACE)
{
- can_change[xx][yy] = FALSE; /* do not change empty borders */
+ can_replace[xx][yy] = FALSE; /* do not replace border with space */
continue;
}
if (!IN_LEV_FIELD(ex, ey))
{
- can_change[xx][yy] = FALSE;
- complete_change = FALSE;
+ can_replace[xx][yy] = FALSE;
+ complete_replace = FALSE;
continue;
}
if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
e = MovingOrBlocked2Element(ex, ey);
+#if 1
+ is_empty = (IS_FREE(ex, ey) || (IS_PLAYER(ex, ey) &&
+ IS_WALKABLE(content_element)));
+ is_diggable = (is_empty || IS_DIGGABLE(e));
+ 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_DESTRUCTIBLE && is_destructible));
+
+ if (!can_replace[xx][yy])
+ complete_replace = FALSE;
+#else
+ empty_for_element = (IS_FREE(ex, ey) || (IS_FREE_OR_PLAYER(ex, ey) &&
+ IS_WALKABLE(content_element)));
+#if 1
+ half_destructible = (empty_for_element || IS_DIGGABLE(e));
+#else
half_destructible = (IS_FREE(ex, ey) || IS_DIGGABLE(e));
+#endif
- if ((change->power <= CP_NON_DESTRUCTIVE && !IS_FREE(ex, ey)) ||
- (change->power <= CP_HALF_DESTRUCTIVE && !half_destructible) ||
- (change->power <= CP_FULL_DESTRUCTIVE && IS_INDESTRUCTIBLE(e)))
+ if ((change->replace_when <= CP_WHEN_EMPTY && !empty_for_element) ||
+ (change->replace_when <= CP_WHEN_DIGGABLE && !half_destructible) ||
+ (change->replace_when <= CP_WHEN_DESTRUCTIBLE && IS_INDESTRUCTIBLE(e)))
{
- can_change[xx][yy] = FALSE;
- complete_change = FALSE;
+ can_replace[xx][yy] = FALSE;
+ complete_replace = FALSE;
}
+#endif
}
- if (!change->only_complete || complete_change)
+ if (!change->only_if_complete || complete_replace)
{
boolean something_has_changed = FALSE;
- if (change->only_complete && change->use_random_change &&
- RND(100) < change->random)
+ if (change->only_if_complete && change->use_random_replace &&
+ RND(100) < change->random_percentage)
return FALSE;
for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
{
int ex = x + xx - 1;
int ey = y + yy - 1;
+ int content_element;
- if (can_change[xx][yy] && (!change->use_random_change ||
- RND(100) < change->random))
+ if (can_replace[xx][yy] && (!change->use_random_replace ||
+ RND(100) < change->random_percentage))
{
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]);
+ content_element = change->target_content[xx][yy];
+ target_element = GET_TARGET_ELEMENT(content_element, change);
+
+ ChangeElementNowExt(ex, ey, target_element);
something_has_changed = TRUE;
}
else
{
- ChangeElementNowExt(x, y, change->target_element);
+ target_element = GET_TARGET_ELEMENT(change->target_element, change);
+
+ ChangeElementNowExt(x, y, target_element);
PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
}
struct ElementInfo *ei = &element_info[element];
struct ElementChangeInfo *change = &ei->change_page[page];
-#if 0
#ifdef DEBUG
- if (!CAN_CHANGE(element))
+ if (!CAN_CHANGE(element) && !CAN_CHANGE(Back[x][y]))
{
printf("\n\n");
printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
printf("\n\n");
}
#endif
+
+ /* this can happen with classic bombs on walkable, changing elements */
+ if (!CAN_CHANGE(element))
+ {
+#if 0
+ if (!CAN_CHANGE(Back[x][y])) /* prevent permanent repetition */
+ ChangeDelay[x][y] = 0;
#endif
+ return;
+ }
+
if (ChangeDelay[x][y] == 0) /* initialize element change */
{
ChangeDelay[x][y] = ( change->delay_fixed * change->delay_frames +
{
page = ChangePage[x][y];
ChangePage[x][y] = -1;
+
+ change = &ei->change_page[page];
}
#if 0
int trigger_page)
{
int i, j, x, y;
+ int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
return FALSE;
change->events & CH_EVENT_BIT(trigger_event) &&
change->trigger_side & trigger_side &&
change->trigger_player & trigger_player &&
- change->trigger_page & (1 << trigger_page) &&
+ change->trigger_page & trigger_page_bits &&
IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
{
#if 0
change_element = TRUE;
page = j;
+ change->actual_trigger_element = trigger_element;
+ change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
+
break;
}
}
static boolean CheckElementChangeExt(int x, int y,
int element,
+ int trigger_element,
int trigger_event,
int trigger_player,
int trigger_side,
element = Feld[x][y];
}
+#if 1
+ if (Feld[x][y] != element) /* check if element has already changed */
+ {
+#if 0
+ printf("::: %d ('%s') != %d ('%s') [%d]\n",
+ Feld[x][y], element_info[Feld[x][y]].token_name,
+ element, element_info[element].token_name,
+ trigger_event);
+#endif
+
+ return FALSE;
+ }
+#endif
+
#if 1
if (trigger_page < 0)
{
change_element = TRUE;
trigger_page = i;
+ change->actual_trigger_element = trigger_element;
+ change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
+
break;
}
}
if (!change_element)
return FALSE;
}
+ else
+ {
+ struct ElementInfo *ei = &element_info[element];
+ struct ElementChangeInfo *change = &ei->change_page[trigger_page];
+
+ change->actual_trigger_element = trigger_element;
+ change->actual_trigger_player = EL_PLAYER_1; /* unused */
+ }
#else
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++)
{
- rnd_equinox_tetrachloride 048
- rnd_equinox_tetrachloride_ii 096
- rnd_emanuel_schmieg 002
- - doctor_sloan_ww 020
+ - doctor_sloan_ww 001, 020
*/
if (stored_player[i].MovPos == 0)
CheckGravityMovement(&stored_player[i]);
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
CheckDynamite(x, y);
#if 0
else if (element == EL_EXPLOSION && !game.explosions_delayed)
- Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
+ Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
#endif
else if (element == EL_AMOEBA_GROWING)
AmoebeWaechst(x, y);
if (ExplodeField[x][y])
Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
else if (element == EL_EXPLOSION)
- Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
+ Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
- ExplodeField[x][y] = EX_NO_EXPLOSION;
+ ExplodeField[x][y] = EX_TYPE_NONE;
}
game.explosions_delayed = TRUE;
{
if (game.gravity && !player->programmed_action)
{
+#if 1
+ int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
+ int move_dir_vertical = player->effective_action & MV_VERTICAL;
+#else
int move_dir_horizontal = player->action & MV_HORIZONTAL;
int move_dir_vertical = player->action & MV_VERTICAL;
+#endif
int move_dir =
(player->last_move_dir & MV_HORIZONTAL ?
(move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
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;
+#endif
#if 1
boolean player_can_fall_down =
(IN_LEV_FIELD(jx, jy + 1) &&
!(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
#if 0
- printf("::: checking gravity NOW [%d, %d, %d] [%d] ...\n",
+ printf("::: checking gravity NOW [%d, %d, %d] [%d] [%d / %d] ...\n",
player_can_fall_down,
player_is_standing_on_valid_field,
player_is_moving_to_valid_field,
- (player_is_moving_to_valid_field ? Feld[new_jx][new_jy] : -1));
+ (player_is_moving_to_valid_field ? Feld[new_jx][new_jy] : -1),
+ player->effective_action,
+ player->can_fall_into_acid);
#endif
if (player_can_fall_down &&
{
if (jx != old_jx) /* player has moved horizontally */
{
- if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
+ if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
(player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
/* don't scroll against the player's moving direction */
- if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
+ if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
(player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
scroll_x = old_scroll_x;
}
else /* player has moved vertically */
{
- if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
+ if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
(player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
/* don't scroll against the player's moving direction */
- if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
+ if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
(player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
scroll_y = old_scroll_y;
}
player->is_dropping = FALSE;
-#if 1
+#if 0
+ /* !!! ENABLE THIS FOR OLD VERSIONS !!! */
{
static int trigger_sides[4][2] =
{
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);
+
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);
- }
+
+ CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
+ CE_OTHER_GETS_ENTERED,
+ player->index_bit, enter_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
}
player->LevelSolved = player->GameOver = TRUE;
}
-#if 0
+#if 1
/* !!! ENABLE THIS FOR NEW VERSIONS !!! */
+ /* this breaks one level: "machine", level 000 */
{
static int trigger_sides[4][2] =
{
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);
+
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);
- }
+
+ CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
+ CE_OTHER_GETS_ENTERED,
+ player->index_bit, enter_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
}
boolean change_center_element = FALSE;
int center_element_change_page = 0;
int center_element = Feld[x][y]; /* should always be non-moving! */
+ int border_trigger_element;
int i, j;
for (i = 0; i < NUM_DIRECTIONS; i++)
{
change_center_element = TRUE;
center_element_change_page = j;
+ border_trigger_element = border_element;
break;
}
#endif
)
{
- CheckElementChangePage(xx, yy, border_element, CE_OTHER_IS_TOUCHING,
- j);
+#if 0
+ printf("::: border_element %d, %d\n", x, y);
+#endif
+
+ CheckElementChangePage(xx, yy, border_element, center_element,
+ CE_OTHER_IS_TOUCHING, j);
break;
}
}
}
if (change_center_element)
- CheckElementChangePage(x, y, center_element, CE_OTHER_IS_TOUCHING,
- center_element_change_page);
+ {
+#if 0
+ 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);
+ }
}
void TestIfElementHitsCustomElement(int x, int y, int direction)
int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
int hitx = x + dx, hity = y + dy;
int hitting_element = Feld[x][y];
+ int touched_element;
#if 0
boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
!IS_FREE(hitx, hity) &&
return;
#endif
- CheckElementChangeSide(x, y, hitting_element, CE_HITTING_SOMETHING,
- direction);
+ touched_element = (IN_LEV_FIELD(hitx, hity) ?
+ MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
+
+ CheckElementChangeSide(x, y, hitting_element, touched_element,
+ CE_HITTING_SOMETHING, direction);
if (IN_LEV_FIELD(hitx, hity))
{
int opposite_direction = MV_DIR_OPPOSITE(direction);
int hitting_side = direction;
int touched_side = opposite_direction;
+#if 0
int touched_element = MovingOrBlocked2Element(hitx, hity);
+#endif
#if 1
boolean object_hit = (!IS_MOVING(hitx, hity) ||
MovDir[hitx][hity] != direction ||
{
int i;
- CheckElementChangeSide(hitx, hity, touched_element, CE_HIT_BY_SOMETHING,
- opposite_direction);
+ CheckElementChangeSide(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))
#endif
)
{
- CheckElementChangePage(x, y, hitting_element, CE_OTHER_IS_HITTING,
- i);
+ CheckElementChangePage(x, y, hitting_element, touched_element,
+ CE_OTHER_IS_HITTING, i);
break;
}
}
)
{
CheckElementChangePage(hitx, hity, touched_element,
- CE_OTHER_GETS_HIT, i);
+ hitting_element, CE_OTHER_GETS_HIT, i);
break;
}
}
int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
int hitx = x + dx, hity = y + dy;
int hitting_element = Feld[x][y];
+ int touched_element;
#if 0
boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
!IS_FREE(hitx, hity) &&
return;
#endif
- CheckElementChangeSide(x, y, hitting_element, EP_CAN_SMASH_EVERYTHING,
- 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);
if (IN_LEV_FIELD(hitx, hity))
{
int opposite_direction = MV_DIR_OPPOSITE(direction);
int hitting_side = direction;
int touched_side = opposite_direction;
+#if 0
int touched_element = MovingOrBlocked2Element(hitx, hity);
+#endif
#if 1
boolean object_hit = (!IS_MOVING(hitx, hity) ||
MovDir[hitx][hity] != direction ||
{
int i;
- CheckElementChangeSide(hitx, hity, touched_element,
+ CheckElementChangeSide(hitx, hity, touched_element, hitting_element,
CE_SMASHED_BY_SOMETHING, opposite_direction);
if (IS_CUSTOM_ELEMENT(hitting_element) &&
#endif
)
{
- CheckElementChangePage(x, y, hitting_element, CE_OTHER_IS_SMASHING,
- i);
+ CheckElementChangePage(x, y, hitting_element, touched_element,
+ CE_OTHER_IS_SMASHING, i);
break;
}
}
)
{
CheckElementChangePage(hitx, hity, touched_element,
- CE_OTHER_GETS_SMASHED, i);
+ hitting_element, CE_OTHER_GETS_SMASHED, i);
break;
}
}
PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_DIGGED,
- player->index_bit, CH_SIDE_ANY);
+ player->index_bit, dig_side);
#if 1
if (mode == DF_SNAP)
CheckTriggeredElementChangePlayer(x, y, element,
CE_OTHER_GETS_COLLECTED,
- player->index_bit, CH_SIDE_ANY);
+ player->index_bit, dig_side);
#if 1
if (mode == DF_SNAP)
boolean DropElement(struct PlayerInfo *player)
{
+ static int trigger_sides[4] =
+ {
+ CH_SIDE_LEFT, /* dropping left */
+ CH_SIDE_RIGHT, /* dropping right */
+ CH_SIDE_TOP, /* dropping up */
+ CH_SIDE_BOTTOM, /* dropping down */
+ };
int jx = player->jx, jy = 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] :
CheckTriggeredElementChangePlayer(jx, jy, new_element,
CE_OTHER_GETS_DROPPED,
- player->index_bit, CH_SIDE_ANY);
+ player->index_bit, drop_side);
CheckElementChangePlayer(jx, jy, new_element, CE_DROPPED_BY_PLAYER,
- player->index_bit, CH_SIDE_ANY);
+ player->index_bit, drop_side);
TestIfElementTouchesCustomElement(jx, jy);
}
#if 1
TestIfElementHitsCustomElement(jx, jy, direction);
#else
- CheckElementChangeSide(jx, jy, new_element, CE_HITTING_SOMETHING,
- direction);
+ CheckElementChangeSide(jx, jy, new_element, touched_element,
+ CE_HITTING_SOMETHING, direction);
#endif
}
projects / rocksndiamonds.git / blobdiff