CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
}
-static inline void InitField_WithBug1(int x, int y, boolean init_game)
+inline static void InitField_WithBug1(int x, int y, boolean init_game)
{
InitField(x, y, init_game);
InitMovDir(x, y);
}
-static inline void InitField_WithBug2(int x, int y, boolean init_game)
+inline static void InitField_WithBug2(int x, int y, boolean init_game)
{
int old_element = Feld[x][y];
for (i = 0; i < MAX_PLAYERS; i++)
game.snapshot.last_action[i] = 0;
game.snapshot.changed_action = FALSE;
+ game.snapshot.collected_item = FALSE;
game.snapshot.mode =
(strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
SNAPSHOT_MODE_EVERY_STEP :
strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
- SNAPSHOT_MODE_EVERY_MOVE : SNAPSHOT_MODE_OFF);
+ SNAPSHOT_MODE_EVERY_MOVE :
+ strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
+ SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
}
int get_num_special_action(int element, int action_first, int action_last)
int initial_move_dir = MV_DOWN;
int i, j, x, y;
- game_status = GAME_MODE_PLAYING;
+ // required here to update video display before fading (FIX THIS)
+ DrawMaskedBorder(REDRAW_DOOR_2);
- StopAnimation();
+ game_status = GAME_MODE_PLAYING;
if (!game.restart_level)
CloseDoor(DOOR_CLOSE_1);
FadeOut(fade_mask);
+ OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
+
ClearField();
DrawCompleteVideoDisplay();
BlitScreenToBitmap(backbuffer);
/* !!! FIX THIS (END) !!! */
+ DrawMaskedBorder(fade_mask);
+
FadeIn(fade_mask);
#if 1
{
UnmapGameButtons();
UnmapTapeButtons();
+
+ FreeGameButtons();
+ CreateGameButtons();
+
game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
+
MapGameButtons();
MapTapeButtons();
if (!local_player->LevelSolved_SaveScore)
{
- FadeOut(REDRAW_FIELD);
-
game_status = GAME_MODE_MAIN;
DrawMainMenu();
}
else
{
- FadeOut(REDRAW_FIELD);
-
game_status = GAME_MODE_MAIN;
if (raise_level)
boolean no_delay = (tape.warp_forward);
int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
int wait_delay_value = (no_delay ? 0 : frame_delay_value);
+ int new_scroll_x, new_scroll_y;
- if (quick_relocation)
+ if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
{
- if (!IN_VIS_FIELD(SCREENX(x), SCREENY(y)) || center_screen)
- {
- if (!level.shifted_relocation || center_screen)
- {
- /* quick relocation (without scrolling), with centering of screen */
+ /* case 1: quick relocation inside visible screen (without scrolling) */
- scroll_x = (x < SBX_Left + MIDPOSX ? SBX_Left :
- x > SBX_Right + MIDPOSX ? SBX_Right :
- x - MIDPOSX);
+ RedrawPlayfield();
- scroll_y = (y < SBY_Upper + MIDPOSY ? SBY_Upper :
- y > SBY_Lower + MIDPOSY ? SBY_Lower :
- y - MIDPOSY);
- }
- else
- {
- /* quick relocation (without scrolling), but do not center screen */
-
- int center_scroll_x = (old_x < SBX_Left + MIDPOSX ? SBX_Left :
- old_x > SBX_Right + MIDPOSX ? SBX_Right :
- old_x - MIDPOSX);
-
- int center_scroll_y = (old_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- old_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- old_y - MIDPOSY);
-
- int offset_x = x + (scroll_x - center_scroll_x);
- int offset_y = y + (scroll_y - center_scroll_y);
-
- scroll_x = (offset_x < SBX_Left + MIDPOSX ? SBX_Left :
- offset_x > SBX_Right + MIDPOSX ? SBX_Right :
- offset_x - MIDPOSX);
+ return;
+ }
- scroll_y = (offset_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- offset_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- offset_y - MIDPOSY);
- }
- }
- else
- {
- if (!level.shifted_relocation || center_screen)
- {
- /* quick relocation (without scrolling), with centering of screen */
+ if (!level.shifted_relocation || center_screen)
+ {
+ /* relocation _with_ centering of screen */
- scroll_x = (x < SBX_Left + MIDPOSX ? SBX_Left :
+ new_scroll_x = (x < SBX_Left + MIDPOSX ? SBX_Left :
x > SBX_Right + MIDPOSX ? SBX_Right :
x - MIDPOSX);
- scroll_y = (y < SBY_Upper + MIDPOSY ? SBY_Upper :
+ new_scroll_y = (y < SBY_Upper + MIDPOSY ? SBY_Upper :
y > SBY_Lower + MIDPOSY ? SBY_Lower :
y - MIDPOSY);
- }
- else
- {
- /* quick relocation (without scrolling), but do not center screen */
+ }
+ else
+ {
+ /* relocation _without_ centering of screen */
- int center_scroll_x = (old_x < SBX_Left + MIDPOSX ? SBX_Left :
- old_x > SBX_Right + MIDPOSX ? SBX_Right :
- old_x - MIDPOSX);
+ int center_scroll_x = (old_x < SBX_Left + MIDPOSX ? SBX_Left :
+ old_x > SBX_Right + MIDPOSX ? SBX_Right :
+ old_x - MIDPOSX);
- int center_scroll_y = (old_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- old_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- old_y - MIDPOSY);
+ int center_scroll_y = (old_y < SBY_Upper + MIDPOSY ? SBY_Upper :
+ old_y > SBY_Lower + MIDPOSY ? SBY_Lower :
+ old_y - MIDPOSY);
- int offset_x = x + (scroll_x - center_scroll_x);
- int offset_y = y + (scroll_y - center_scroll_y);
+ int offset_x = x + (scroll_x - center_scroll_x);
+ int offset_y = y + (scroll_y - center_scroll_y);
- scroll_x = (offset_x < SBX_Left + MIDPOSX ? SBX_Left :
+ new_scroll_x = (offset_x < SBX_Left + MIDPOSX ? SBX_Left :
offset_x > SBX_Right + MIDPOSX ? SBX_Right :
offset_x - MIDPOSX);
- scroll_y = (offset_y < SBY_Upper + MIDPOSY ? SBY_Upper :
+ new_scroll_y = (offset_y < SBY_Upper + MIDPOSY ? SBY_Upper :
offset_y > SBY_Lower + MIDPOSY ? SBY_Lower :
offset_y - MIDPOSY);
- }
- }
-
- RedrawPlayfield(TRUE, 0,0,0,0);
}
- else
- {
- int scroll_xx, scroll_yy;
-
- if (!level.shifted_relocation || center_screen)
- {
- /* visible relocation (with scrolling), with centering of screen */
-
- scroll_xx = (x < SBX_Left + MIDPOSX ? SBX_Left :
- x > SBX_Right + MIDPOSX ? SBX_Right :
- x - MIDPOSX);
-
- scroll_yy = (y < SBY_Upper + MIDPOSY ? SBY_Upper :
- y > SBY_Lower + MIDPOSY ? SBY_Lower :
- y - MIDPOSY);
- }
- else
- {
- /* visible relocation (with scrolling), but do not center screen */
-
- int center_scroll_x = (old_x < SBX_Left + MIDPOSX ? SBX_Left :
- old_x > SBX_Right + MIDPOSX ? SBX_Right :
- old_x - MIDPOSX);
-
- int center_scroll_y = (old_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- old_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- old_y - MIDPOSY);
- int offset_x = x + (scroll_x - center_scroll_x);
- int offset_y = y + (scroll_y - center_scroll_y);
+ if (quick_relocation)
+ {
+ /* case 2: quick relocation (redraw without visible scrolling) */
- scroll_xx = (offset_x < SBX_Left + MIDPOSX ? SBX_Left :
- offset_x > SBX_Right + MIDPOSX ? SBX_Right :
- offset_x - MIDPOSX);
+ scroll_x = new_scroll_x;
+ scroll_y = new_scroll_y;
- scroll_yy = (offset_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- offset_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- offset_y - MIDPOSY);
- }
+ RedrawPlayfield();
+ return;
+ }
- ScrollScreen(NULL, SCROLL_GO_ON); /* scroll last frame to full tile */
+ /* case 3: visible relocation (with scrolling to new position) */
- while (scroll_x != scroll_xx || scroll_y != scroll_yy)
- {
- int dx = 0, dy = 0;
- int fx = FX, fy = FY;
+ ScrollScreen(NULL, SCROLL_GO_ON); /* scroll last frame to full tile */
- dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
- dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
+ while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
+ {
+ int dx = 0, dy = 0;
+ int fx = FX, fy = FY;
- if (dx == 0 && dy == 0) /* no scrolling needed at all */
- break;
+ dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
+ dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
- scroll_x -= dx;
- scroll_y -= dy;
+ if (dx == 0 && dy == 0) /* no scrolling needed at all */
+ break;
- fx += dx * TILEX / 2;
- fy += dy * TILEY / 2;
+ scroll_x -= dx;
+ scroll_y -= dy;
- ScrollLevel(dx, dy);
- DrawAllPlayers();
+ fx += dx * TILEX / 2;
+ fy += dy * TILEY / 2;
- /* scroll in two steps of half tile size to make things smoother */
- BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
- Delay(wait_delay_value);
+ ScrollLevel(dx, dy);
+ DrawAllPlayers();
- /* scroll second step to align at full tile size */
- BackToFront();
- Delay(wait_delay_value);
- }
+ /* scroll in two steps of half tile size to make things smoother */
+ BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
+ Delay(wait_delay_value);
- DrawAllPlayers();
+ /* scroll second step to align at full tile size */
BackToFront();
Delay(wait_delay_value);
}
+
+ DrawAllPlayers();
+ BackToFront();
+ Delay(wait_delay_value);
}
void RelocatePlayer(int jx, int jy, int el_player_raw)
{
local_player->gems_still_needed = action_arg_number_new;
+ game.snapshot.collected_item = TRUE;
+
game_panel_controls[GAME_PANEL_GEMS].value =
local_player->gems_still_needed;
{
/* !!! not clear why graphic animation should be reset at all here !!! */
/* !!! UPDATE: but is needed for correct Snake Bite tail animation !!! */
+ /* !!! SOLUTION: do not reset if graphics engine set to 4 or above !!! */
+
+ /*
+ GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
+
+ When using an animation frame delay of 1 (this only happens with
+ "sp_zonk.moving.left/right" in the classic graphics), the default
+ (non-moving) animation shows wrong animation frames (while the
+ moving animation, like "sp_zonk.moving.left/right", is correct,
+ so this graphical bug never shows up with the classic graphics).
+ For an animation with 4 frames, this causes wrong frames 0,0,1,2
+ be drawn instead of the correct frames 0,1,2,3. This is caused by
+ "GfxFrame[][]" being reset *twice* (in two successive frames) after
+ an element change: First when the change delay ("ChangeDelay[][]")
+ counter has reached zero after decrementing, then a second time in
+ the next frame (after "GfxFrame[][]" was already incremented) when
+ "ChangeDelay[][]" is reset to the initial delay value again.
+
+ This causes frame 0 to be drawn twice, while the last frame won't
+ be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
+
+ As some animations may already be cleverly designed around this bug
+ (at least the "Snake Bite" snake tail animation does this), it cannot
+ simply be fixed here without breaking such existing animations.
+ Unfortunately, it cannot easily be detected if a graphics set was
+ designed "before" or "after" the bug was fixed. As a workaround,
+ a new graphics set option "game.graphics_engine_version" was added
+ to be able to specify the game's major release version for which the
+ graphics set was designed, which can then be used to decide if the
+ bugfix should be used (version 4 and above) or not (version 3 or
+ below, or if no version was specified at all, as with old sets).
+
+ (The wrong/fixed animation frames can be tested with the test level set
+ "test_gfxframe" and level "000", which contains a specially prepared
+ custom element at level position (x/y) == (11/9) which uses the zonk
+ animation mentioned above. Using "game.graphics_engine_version: 4"
+ fixes the wrong animation frames, showing the correct frames 0,1,2,3.
+ This can also be seen from the debug output for this test element.)
+ */
+
/* when a custom element is about to change (for example by change delay),
do not reset graphic animation when the custom element is moving */
- if (!IS_MOVING(x, y))
+ if (game.graphics_engine_version < 4 &&
+ !IS_MOVING(x, y))
{
ResetGfxAnimation(x, y);
ResetRandomAnimationValue(x, y);
byte tape_action[MAX_PLAYERS];
int i;
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- // allow engine snapshot if movement attempt was stopped
- if ((game.snapshot.last_action[i] & KEY_MOTION) != 0 &&
- (player->action & KEY_MOTION) == 0)
- game.snapshot.changed_action = TRUE;
-
- // allow engine snapshot in case of snapping/dropping attempt
- if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
- (player->action & KEY_BUTTON) != 0)
- game.snapshot.changed_action = TRUE;
-
- game.snapshot.last_action[i] = player->action;
- }
-
/* detect endless loops, caused by custom element programming */
if (recursion_loop_detected && recursion_loop_depth == 0)
{
SendToServer_MovePlayer(summarized_player_action);
#endif
+ // summarize all actions at local players mapped input device position
+ // (this allows using different input devices in single player mode)
if (!options.network && !game.team_mode)
- local_player->effective_action = summarized_player_action;
+ stored_player[map_player_action[local_player->index_nr]].effective_action =
+ summarized_player_action;
if (tape.recording &&
setup.team_mode &&
#if USE_NEW_PLAYER_ASSIGNMENTS
// !!! also map player actions in single player mode !!!
// if (game.team_mode)
+ if (1)
{
byte mapped_action[MAX_PLAYERS];
#endif
#endif
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ // allow engine snapshot in case of changed movement attempt
+ if ((game.snapshot.last_action[i] & KEY_MOTION) !=
+ (stored_player[i].effective_action & KEY_MOTION))
+ game.snapshot.changed_action = TRUE;
+
+ // allow engine snapshot in case of snapping/dropping attempt
+ if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
+ (stored_player[i].effective_action & KEY_BUTTON) != 0)
+ game.snapshot.changed_action = TRUE;
+
+ game.snapshot.last_action[i] = stored_player[i].effective_action;
+ }
+
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
{
GameActions_EM_Main();
if (local_player->gems_still_needed < 0)
local_player->gems_still_needed = 0;
+ game.snapshot.collected_item = TRUE;
+
game_panel_controls[GAME_PANEL_GEMS].value = local_player->gems_still_needed;
DisplayGameControlValues();
SCAN_PLAYFIELD(xx, yy)
{
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;
+
+ ResetGfxAnimation(xx, yy);
+ TEST_DrawLevelField(xx, yy);
+ }
}
}
else if (IS_BELT_SWITCH(element))
#endif
{
if (quick_quit)
- {
FadeSkipNextFadeIn();
- game_status = GAME_MODE_MAIN;
-
- DrawMainMenu();
- }
- else
- {
- game_status = GAME_MODE_MAIN;
+ game_status = GAME_MODE_MAIN;
- DrawMainMenu();
- }
+ DrawMainMenu();
}
}
else /* continue playing the game */
(initial_snapshot ||
(game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
(game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
- game.snapshot.changed_action));
+ game.snapshot.changed_action) ||
+ (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
+ game.snapshot.collected_item));
game.snapshot.changed_action = FALSE;
+ game.snapshot.collected_item = FALSE;
if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
tape.quick_resume ||
static void HandleGameButtonsExt(int id, int button)
{
+ static boolean game_undo_executed = FALSE;
int steps = BUTTON_STEPSIZE(button);
boolean handle_game_buttons =
(game_status == GAME_MODE_PLAYING ||
}
else
TapeTogglePause(TAPE_TOGGLE_MANUAL);
+
+ game_undo_executed = FALSE;
+
break;
case GAME_CTRL_ID_PLAY:
break;
case GAME_CTRL_ID_UNDO:
+ // Important: When using "save snapshot when collecting an item" mode,
+ // load last (current) snapshot for first "undo" after pressing "pause"
+ // (else the last-but-one snapshot would be loaded, because the snapshot
+ // pointer already points to the last snapshot when pressing "pause",
+ // which is fine for "every step/move" mode, but not for "every collect")
+ if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
+ !game_undo_executed)
+ steps--;
+
+ game_undo_executed = TRUE;
+
GameUndo(steps);
break;
projects / rocksndiamonds.git / blobdiff