X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=717ea8d2f263fd0d3ab1d3d99677ac860a469acc;hb=3da9c6a38081401af8c47d78330a199104f9ad2f;hp=4e4c901c990286248b043614b2716d243a3d822e;hpb=c0c5862d9ee59c70412b1c35e558101b109a8ec9;p=rocksndiamonds.git diff --git a/src/game.c b/src/game.c index 4e4c901c..717ea8d2 100644 --- a/src/game.c +++ b/src/game.c @@ -1,7 +1,7 @@ /*********************************************************** * Rocks'n'Diamonds -- McDuffin Strikes Back! * *----------------------------------------------------------* -* (c) 1995-2002 Artsoft Entertainment * +* (c) 1995-2006 Artsoft Entertainment * * Holger Schemel * * Detmolder Strasse 189 * * 33604 Bielefeld * @@ -52,7 +52,42 @@ #define USE_CODE_THAT_BREAKS_SNAKE_BITE (USE_NEW_STUFF * 1) #define USE_UFAST_PLAYER_EXIT_BUGFIX (USE_NEW_STUFF * 1) -#define USE_NEW_GAME_WON (USE_NEW_STUFF * 1) + +#define USE_GFX_RESET_ONLY_WHEN_MOVING (USE_NEW_STUFF * 1) +#define USE_GFX_RESET_PLAYER_ARTWORK (USE_NEW_STUFF * 1) + +#define USE_FIX_KILLED_BY_NON_WALKABLE (USE_NEW_STUFF * 1) +#define USE_FIX_IMPACT_COLLISION (USE_NEW_STUFF * 1) +#define USE_FIX_CE_ACTION_WITH_PLAYER (USE_NEW_STUFF * 1) +#define USE_FIX_NO_ACTION_AFTER_CHANGE (USE_NEW_STUFF * 1) + +#define USE_PLAYER_REANIMATION (USE_NEW_STUFF * 1) + +#define USE_GFX_RESET_WHEN_NOT_MOVING (USE_NEW_STUFF * 1) + +#define USE_NEW_PLAYER_ASSIGNMENTS (USE_NEW_STUFF * 1) + +#define USE_DELAYED_GFX_REDRAW (USE_NEW_STUFF * 0) + +#if USE_DELAYED_GFX_REDRAW +#define TEST_DrawLevelField(x, y) \ + GfxRedraw[x][y] |= GFX_REDRAW_TILE +#define TEST_DrawLevelFieldCrumbledSand(x, y) \ + GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED +#define TEST_DrawLevelFieldCrumbledSandNeighbours(x, y) \ + GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS +#define TEST_DrawTwinkleOnField(x, y) \ + GfxRedraw[x][y] |= GFX_REDRAW_TILE_TWINKLED +#else +#define TEST_DrawLevelField(x, y) \ + DrawLevelField(x, y) +#define TEST_DrawLevelFieldCrumbledSand(x, y) \ + DrawLevelFieldCrumbledSand(x, y) +#define TEST_DrawLevelFieldCrumbledSandNeighbours(x, y) \ + DrawLevelFieldCrumbledSandNeighbours(x, y) +#define TEST_DrawTwinkleOnField(x, y) \ + DrawTwinkleOnField(x, y) +#endif /* for DigField() */ @@ -80,48 +115,33 @@ #define EX_TYPE_DYNA (1 << 4) #define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER) -#if 1 - -#define PANEL_DEACTIVATED(p) ((p).x < 0 || (p).y < 0) - -/* special positions in the game control window (relative to control window) */ -#define XX_LEVEL1 (game.panel.level.x) -#define XX_LEVEL2 (game.panel.level.x - 1) -#define YY_LEVEL (game.panel.level.y) -#define XX_EMERALDS (game.panel.gems.x) -#define YY_EMERALDS (game.panel.gems.y) -#define XX_DYNAMITE (game.panel.inventory.x) -#define YY_DYNAMITE (game.panel.inventory.y) -#define XX_KEYS (game.panel.keys.x) -#define YY_KEYS (game.panel.keys.y) -#define XX_SCORE (game.panel.score.x) -#define YY_SCORE (game.panel.score.y) -#define XX_TIME1 (game.panel.time.x) -#define XX_TIME2 (game.panel.time.x + 1) -#define YY_TIME (game.panel.time.y) - -#else +#define PANEL_OFF() (local_player->LevelSolved_PanelOff) +#define PANEL_DEACTIVATED(p) ((p)->x < 0 || (p)->y < 0 || PANEL_OFF()) +#define PANEL_XPOS(p) (DX + ALIGNED_TEXT_XPOS(p)) +#define PANEL_YPOS(p) (DY + ALIGNED_TEXT_YPOS(p)) /* special positions in the game control window (relative to control window) */ -#define XX_LEVEL 37 -#define YY_LEVEL 20 -#define XX_EMERALDS 29 -#define YY_EMERALDS 54 -#define XX_DYNAMITE 29 -#define YY_DYNAMITE 89 -#define XX_KEYS 18 -#define YY_KEYS 123 -#define XX_SCORE 15 -#define YY_SCORE 159 -#define XX_TIME1 29 -#define XX_TIME2 30 -#define YY_TIME 194 - -#endif +#define XX_LEVEL1 (PANEL_XPOS(game.panel.level)) +#define XX_LEVEL2 (PANEL_XPOS(game.panel.level) - 1) +#define XX_LEVEL (PANEL_XPOS(game.panel.level)) +#define YY_LEVEL (PANEL_YPOS(game.panel.level)) +#define XX_EMERALDS (PANEL_XPOS(game.panel.gems)) +#define YY_EMERALDS (PANEL_YPOS(game.panel.gems)) +#define XX_DYNAMITE (PANEL_XPOS(game.panel.inventory)) +#define YY_DYNAMITE (PANEL_YPOS(game.panel.inventory)) +#define XX_KEYS (PANEL_XPOS(game.panel.keys)) +#define YY_KEYS (PANEL_YPOS(game.panel.keys)) +#define XX_SCORE (PANEL_XPOS(game.panel.score)) +#define YY_SCORE (PANEL_YPOS(game.panel.score)) +#define XX_TIME1 (PANEL_XPOS(game.panel.time)) +#define XX_TIME2 (PANEL_XPOS(game.panel.time) + 1) +#define XX_TIME (PANEL_XPOS(game.panel.time)) +#define YY_TIME (PANEL_YPOS(game.panel.time)) /* special positions in the game control window (relative to main window) */ #define DX_LEVEL1 (DX + XX_LEVEL1) #define DX_LEVEL2 (DX + XX_LEVEL2) +#define DX_LEVEL (DX + XX_LEVEL) #define DY_LEVEL (DY + YY_LEVEL) #define DX_EMERALDS (DX + XX_EMERALDS) #define DY_EMERALDS (DY + YY_EMERALDS) @@ -133,1224 +153,2905 @@ #define DY_SCORE (DY + YY_SCORE) #define DX_TIME1 (DX + XX_TIME1) #define DX_TIME2 (DX + XX_TIME2) +#define DX_TIME (DX + XX_TIME) #define DY_TIME (DY + YY_TIME) -/* values for delayed check of falling and moving elements and for collision */ -#define CHECK_DELAY_MOVING 3 -#define CHECK_DELAY_FALLING 3 -#define CHECK_DELAY_COLLISION 2 - -/* values for initial player move delay (initial delay counter value) */ -#define INITIAL_MOVE_DELAY_OFF -1 -#define INITIAL_MOVE_DELAY_ON 0 - -/* values for player movement speed (which is in fact a delay value) */ -#define MOVE_DELAY_MIN_SPEED 32 -#define MOVE_DELAY_NORMAL_SPEED 8 -#define MOVE_DELAY_HIGH_SPEED 4 -#define MOVE_DELAY_MAX_SPEED 1 - -#if 0 -#define DOUBLE_MOVE_DELAY(x) (x = (x <= MOVE_DELAY_HIGH_SPEED ? x * 2 : x)) -#define HALVE_MOVE_DELAY(x) (x = (x >= MOVE_DELAY_HIGH_SPEED ? x / 2 : x)) -#else -#define DOUBLE_MOVE_DELAY(x) (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x)) -#define HALVE_MOVE_DELAY(x) (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x)) -#endif -#define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY((p)->move_delay_value)) -#define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value)) - -/* values for other actions */ -#define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED) -#define MOVE_STEPSIZE_MIN (1) -#define MOVE_STEPSIZE_MAX (TILEX) - -#define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0) -#define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0) - -#define INIT_GFX_RANDOM() (SimpleRND(1000000)) - -#define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \ - RND(element_info[e].push_delay_random)) -#define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \ - RND(element_info[e].drop_delay_random)) -#define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \ - RND(element_info[e].move_delay_random)) -#define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \ - (element_info[e].move_delay_random)) -#define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\ - RND(element_info[e].ce_value_random_initial)) -#define GET_CE_SCORE(e) ( (element_info[e].collect_score)) -#define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \ - RND((c)->delay_random * (c)->delay_frames)) -#define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \ - RND((c)->delay_random)) - - #if 1 -#define GET_VALID_RUNTIME_ELEMENT(e) \ - ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e)) -#else -#define GET_VALID_FILE_ELEMENT(e) \ - ((e) >= NUM_FILE_ELEMENTS ? EL_UNKNOWN : (e)) -#endif - -#define RESOLVED_REFERENCE_ELEMENT(be, e) \ - ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \ - (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \ - (be) + (e) - EL_SELF) - -#define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \ - ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \ - (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \ - (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \ - (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \ - (e) == EL_CURRENT_CE_VALUE ? (cv) : \ - (e) == EL_CURRENT_CE_SCORE ? (cs) : \ - (e) >= EL_LAST_CE_8 && (e) <= EL_NEXT_CE_8 ? \ - RESOLVED_REFERENCE_ELEMENT(be, e) : \ - (e)) - -#define CAN_GROW_INTO(e) \ - ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable)) - -#define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \ - (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ - (condition))) - -#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))) - -#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)))) - -#define ELEMENT_CAN_ENTER_FIELD(e, x, y) \ - ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0) - -#define SATELLITE_CAN_ENTER_FIELD(x, y) \ - ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0) - -#define ANDROID_CAN_ENTER_FIELD(e, x, y) \ - ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Feld[x][y] == EL_EMC_PLANT) - -#define ANDROID_CAN_CLONE_FIELD(x, y) \ - (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Feld[x][y]) || \ - CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT))) - -#define ENEMY_CAN_ENTER_FIELD(e, x, y) \ - ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0) - -#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) - -#define SPRING_CAN_BUMP_FROM_FIELD(x, y) \ - (IN_LEV_FIELD(x, y) && (Feld[x][y] == EL_EMC_SPRING_BUMPER || \ - Feld[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE)) - -#if 0 -#define GROUP_NR(e) ((e) - EL_GROUP_START) -#define IS_IN_GROUP(e, nr) (element_info[e].in_group[nr] == TRUE) -#define IS_IN_GROUP_EL(e, ge) (IS_IN_GROUP(e, (ge) - EL_GROUP_START)) - -#define IS_EQUAL_OR_IN_GROUP(e, ge) \ - (IS_GROUP_ELEMENT(ge) ? IS_IN_GROUP(e, GROUP_NR(ge)) : (e) == (ge)) -#endif - -#define MOVE_ENTER_EL(e) (element_info[e].move_enter_element) - -#define CE_ENTER_FIELD_COND(e, x, y) \ - (!IS_PLAYER(x, y) && \ - IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e))) - -#define CUSTOM_ELEMENT_CAN_ENTER_FIELD(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)) - -#define ACCESS_FROM(e, d) (element_info[e].access_direction &(d)) -#define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d)) -#define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d)) -#define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d)) - -/* game button identifiers */ -#define GAME_CTRL_ID_STOP 0 -#define GAME_CTRL_ID_PAUSE 1 -#define GAME_CTRL_ID_PLAY 2 -#define SOUND_CTRL_ID_MUSIC 3 -#define SOUND_CTRL_ID_LOOPS 4 -#define SOUND_CTRL_ID_SIMPLE 5 - -#define NUM_GAME_BUTTONS 6 - - -/* forward declaration for internal use */ - -static void CreateField(int, int, int); - -static void SetPlayerWaiting(struct PlayerInfo *, boolean); -static void AdvanceFrameAndPlayerCounters(int); - -static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int); -static boolean MovePlayer(struct PlayerInfo *, int, int); -static void ScrollPlayer(struct PlayerInfo *, int); -static void ScrollScreen(struct PlayerInfo *, int); - -int DigField(struct PlayerInfo *, int, int, int, int, int, int, int); - -static void InitBeltMovement(void); -static void CloseAllOpenTimegates(void); -static void CheckGravityMovement(struct PlayerInfo *); -static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *); -static void KillPlayerUnlessEnemyProtected(int, int); -static void KillPlayerUnlessExplosionProtected(int, int); - -static void TestIfPlayerTouchesCustomElement(int, int); -static void TestIfElementTouchesCustomElement(int, int); -static void TestIfElementHitsCustomElement(int, int, int); -#if 0 -static void TestIfElementSmashesCustomElement(int, int, int); -#endif - -static void HandleElementChange(int, int, int); -static void ExecuteCustomElementAction(int, int, int, int); -static boolean ChangeElement(int, int, int, int); - -static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int); -#define CheckTriggeredElementChange(x, y, e, ev) \ - CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1) -#define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \ - CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1) -#define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \ - CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1) -#define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \ - CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p) +/* game panel display and control definitions */ + +#define GAME_PANEL_LEVEL_NUMBER 0 +#define GAME_PANEL_GEMS 1 +#define GAME_PANEL_INVENTORY_COUNT 2 +#define GAME_PANEL_INVENTORY_FIRST_1 3 +#define GAME_PANEL_INVENTORY_FIRST_2 4 +#define GAME_PANEL_INVENTORY_FIRST_3 5 +#define GAME_PANEL_INVENTORY_FIRST_4 6 +#define GAME_PANEL_INVENTORY_FIRST_5 7 +#define GAME_PANEL_INVENTORY_FIRST_6 8 +#define GAME_PANEL_INVENTORY_FIRST_7 9 +#define GAME_PANEL_INVENTORY_FIRST_8 10 +#define GAME_PANEL_INVENTORY_LAST_1 11 +#define GAME_PANEL_INVENTORY_LAST_2 12 +#define GAME_PANEL_INVENTORY_LAST_3 13 +#define GAME_PANEL_INVENTORY_LAST_4 14 +#define GAME_PANEL_INVENTORY_LAST_5 15 +#define GAME_PANEL_INVENTORY_LAST_6 16 +#define GAME_PANEL_INVENTORY_LAST_7 17 +#define GAME_PANEL_INVENTORY_LAST_8 18 +#define GAME_PANEL_KEY_1 19 +#define GAME_PANEL_KEY_2 20 +#define GAME_PANEL_KEY_3 21 +#define GAME_PANEL_KEY_4 22 +#define GAME_PANEL_KEY_5 23 +#define GAME_PANEL_KEY_6 24 +#define GAME_PANEL_KEY_7 25 +#define GAME_PANEL_KEY_8 26 +#define GAME_PANEL_KEY_WHITE 27 +#define GAME_PANEL_KEY_WHITE_COUNT 28 +#define GAME_PANEL_SCORE 29 +#define GAME_PANEL_HIGHSCORE 30 +#define GAME_PANEL_TIME 31 +#define GAME_PANEL_TIME_HH 32 +#define GAME_PANEL_TIME_MM 33 +#define GAME_PANEL_TIME_SS 34 +#define GAME_PANEL_SHIELD_NORMAL 35 +#define GAME_PANEL_SHIELD_NORMAL_TIME 36 +#define GAME_PANEL_SHIELD_DEADLY 37 +#define GAME_PANEL_SHIELD_DEADLY_TIME 38 +#define GAME_PANEL_EXIT 39 +#define GAME_PANEL_EMC_MAGIC_BALL 40 +#define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 41 +#define GAME_PANEL_LIGHT_SWITCH 42 +#define GAME_PANEL_LIGHT_SWITCH_TIME 43 +#define GAME_PANEL_TIMEGATE_SWITCH 44 +#define GAME_PANEL_TIMEGATE_SWITCH_TIME 45 +#define GAME_PANEL_SWITCHGATE_SWITCH 46 +#define GAME_PANEL_EMC_LENSES 47 +#define GAME_PANEL_EMC_LENSES_TIME 48 +#define GAME_PANEL_EMC_MAGNIFIER 49 +#define GAME_PANEL_EMC_MAGNIFIER_TIME 50 +#define GAME_PANEL_BALLOON_SWITCH 51 +#define GAME_PANEL_DYNABOMB_NUMBER 52 +#define GAME_PANEL_DYNABOMB_SIZE 53 +#define GAME_PANEL_DYNABOMB_POWER 54 +#define GAME_PANEL_PENGUINS 55 +#define GAME_PANEL_SOKOBAN_OBJECTS 56 +#define GAME_PANEL_SOKOBAN_FIELDS 57 +#define GAME_PANEL_ROBOT_WHEEL 58 +#define GAME_PANEL_CONVEYOR_BELT_1 59 +#define GAME_PANEL_CONVEYOR_BELT_2 60 +#define GAME_PANEL_CONVEYOR_BELT_3 61 +#define GAME_PANEL_CONVEYOR_BELT_4 62 +#define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 63 +#define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 64 +#define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 65 +#define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 66 +#define GAME_PANEL_MAGIC_WALL 67 +#define GAME_PANEL_MAGIC_WALL_TIME 68 +#define GAME_PANEL_GRAVITY_STATE 69 +#define GAME_PANEL_GRAPHIC_1 70 +#define GAME_PANEL_GRAPHIC_2 71 +#define GAME_PANEL_GRAPHIC_3 72 +#define GAME_PANEL_GRAPHIC_4 73 +#define GAME_PANEL_GRAPHIC_5 74 +#define GAME_PANEL_GRAPHIC_6 75 +#define GAME_PANEL_GRAPHIC_7 76 +#define GAME_PANEL_GRAPHIC_8 77 +#define GAME_PANEL_ELEMENT_1 78 +#define GAME_PANEL_ELEMENT_2 79 +#define GAME_PANEL_ELEMENT_3 80 +#define GAME_PANEL_ELEMENT_4 81 +#define GAME_PANEL_ELEMENT_5 82 +#define GAME_PANEL_ELEMENT_6 83 +#define GAME_PANEL_ELEMENT_7 84 +#define GAME_PANEL_ELEMENT_8 85 +#define GAME_PANEL_ELEMENT_COUNT_1 86 +#define GAME_PANEL_ELEMENT_COUNT_2 87 +#define GAME_PANEL_ELEMENT_COUNT_3 88 +#define GAME_PANEL_ELEMENT_COUNT_4 89 +#define GAME_PANEL_ELEMENT_COUNT_5 90 +#define GAME_PANEL_ELEMENT_COUNT_6 91 +#define GAME_PANEL_ELEMENT_COUNT_7 92 +#define GAME_PANEL_ELEMENT_COUNT_8 93 +#define GAME_PANEL_CE_SCORE_1 94 +#define GAME_PANEL_CE_SCORE_2 95 +#define GAME_PANEL_CE_SCORE_3 96 +#define GAME_PANEL_CE_SCORE_4 97 +#define GAME_PANEL_CE_SCORE_5 98 +#define GAME_PANEL_CE_SCORE_6 99 +#define GAME_PANEL_CE_SCORE_7 100 +#define GAME_PANEL_CE_SCORE_8 101 +#define GAME_PANEL_CE_SCORE_1_ELEMENT 102 +#define GAME_PANEL_CE_SCORE_2_ELEMENT 103 +#define GAME_PANEL_CE_SCORE_3_ELEMENT 104 +#define GAME_PANEL_CE_SCORE_4_ELEMENT 105 +#define GAME_PANEL_CE_SCORE_5_ELEMENT 106 +#define GAME_PANEL_CE_SCORE_6_ELEMENT 107 +#define GAME_PANEL_CE_SCORE_7_ELEMENT 108 +#define GAME_PANEL_CE_SCORE_8_ELEMENT 109 +#define GAME_PANEL_PLAYER_NAME 110 +#define GAME_PANEL_LEVEL_NAME 111 +#define GAME_PANEL_LEVEL_AUTHOR 112 + +#define NUM_GAME_PANEL_CONTROLS 113 + +struct GamePanelOrderInfo +{ + int nr; + int sort_priority; +}; -static boolean CheckElementChangeExt(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) -#define CheckElementChangeByPlayer(x, y, e, ev, p, s) \ - CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s) -#define CheckElementChangeBySide(x, y, e, te, ev, s) \ - CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s) +static struct GamePanelOrderInfo game_panel_order[NUM_GAME_PANEL_CONTROLS]; -static void PlayLevelSound(int, int, int); -static void PlayLevelSoundNearest(int, int, int); -static void PlayLevelSoundAction(int, int, int); -static void PlayLevelSoundElementAction(int, int, int, int); -static void PlayLevelSoundElementActionIfLoop(int, int, int, int); -static void PlayLevelSoundActionIfLoop(int, int, int); -static void StopLevelSoundActionIfLoop(int, int, int); -static void PlayLevelMusic(); +struct GamePanelControlInfo +{ + int nr; -static void MapGameButtons(); -static void HandleGameButtons(struct GadgetInfo *); + struct TextPosInfo *pos; + int type; -int AmoebeNachbarNr(int, int); -void AmoebeUmwandeln(int, int); -void ContinueMoving(int, int); -void Bang(int, int); -void InitMovDir(int, int); -void InitAmoebaNr(int, int); -int NewHiScore(void); + int value, last_value; + int frame, last_frame; + int gfx_frame; + int gfx_random; +}; -void TestIfGoodThingHitsBadThing(int, int, int); -void TestIfBadThingHitsGoodThing(int, int, int); -void TestIfPlayerTouchesBadThing(int, int); -void TestIfPlayerRunsIntoBadThing(int, int, int); -void TestIfBadThingTouchesPlayer(int, int); -void TestIfBadThingRunsIntoPlayer(int, int, int); -void TestIfFriendTouchesBadThing(int, int); -void TestIfBadThingTouchesFriend(int, int); -void TestIfBadThingTouchesOtherBadThing(int, int); - -void KillPlayer(struct PlayerInfo *); -void BuryPlayer(struct PlayerInfo *); -void RemovePlayer(struct PlayerInfo *); - -boolean SnapField(struct PlayerInfo *, int, int); -boolean DropElement(struct PlayerInfo *); - -static int getInvisibleActiveFromInvisibleElement(int); -static int getInvisibleFromInvisibleActiveElement(int); - -static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS]; - - -/* ------------------------------------------------------------------------- */ -/* definition of elements that automatically change to other elements after */ -/* a specified time, eventually calling a function when changing */ -/* ------------------------------------------------------------------------- */ - -/* forward declaration for changer functions */ -static void InitBuggyBase(int, int); -static void WarnBuggyBase(int, int); - -static void InitTrap(int, int); -static void ActivateTrap(int, int); -static void ChangeActiveTrap(int, int); - -static void InitRobotWheel(int, int); -static void RunRobotWheel(int, int); -static void StopRobotWheel(int, int); - -static void InitTimegateWheel(int, int); -static void RunTimegateWheel(int, int); - -static void InitMagicBallDelay(int, int); -static void ActivateMagicBall(int, int); - -static void InitDiagonalMovingElement(int, int); - -struct ChangingElementInfo -{ - int element; - int target_element; - int change_delay; - void (*pre_change_function)(int x, int y); - void (*change_function)(int x, int y); - void (*post_change_function)(int x, int y); -}; - -static struct ChangingElementInfo change_delay_list[] = +static struct GamePanelControlInfo game_panel_controls[] = { { - EL_NUT_BREAKING, - EL_EMERALD, - 6, - NULL, - NULL, - NULL + GAME_PANEL_LEVEL_NUMBER, + &game.panel.level_number, + TYPE_INTEGER, }, { - EL_PEARL_BREAKING, - EL_EMPTY, - 8, - NULL, - NULL, - NULL + GAME_PANEL_GEMS, + &game.panel.gems, + TYPE_INTEGER, }, { - EL_EXIT_OPENING, - EL_EXIT_OPEN, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_COUNT, + &game.panel.inventory_count, + TYPE_INTEGER, }, { - EL_EXIT_CLOSING, - EL_EXIT_CLOSED, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_1, + &game.panel.inventory_first[0], + TYPE_ELEMENT, }, { - EL_SP_EXIT_OPENING, - EL_SP_EXIT_OPEN, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_2, + &game.panel.inventory_first[1], + TYPE_ELEMENT, }, { - EL_SP_EXIT_CLOSING, - EL_SP_EXIT_CLOSED, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_3, + &game.panel.inventory_first[2], + TYPE_ELEMENT, }, { - EL_SWITCHGATE_OPENING, - EL_SWITCHGATE_OPEN, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_4, + &game.panel.inventory_first[3], + TYPE_ELEMENT, }, { - EL_SWITCHGATE_CLOSING, - EL_SWITCHGATE_CLOSED, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_5, + &game.panel.inventory_first[4], + TYPE_ELEMENT, }, { - EL_TIMEGATE_OPENING, - EL_TIMEGATE_OPEN, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_6, + &game.panel.inventory_first[5], + TYPE_ELEMENT, }, { - EL_TIMEGATE_CLOSING, - EL_TIMEGATE_CLOSED, - 29, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_7, + &game.panel.inventory_first[6], + TYPE_ELEMENT, }, - { - EL_ACID_SPLASH_LEFT, - EL_EMPTY, - 8, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_FIRST_8, + &game.panel.inventory_first[7], + TYPE_ELEMENT, }, { - EL_ACID_SPLASH_RIGHT, - EL_EMPTY, - 8, - NULL, - NULL, - NULL + GAME_PANEL_INVENTORY_LAST_1, + &game.panel.inventory_last[0], + TYPE_ELEMENT, }, { - EL_SP_BUGGY_BASE, - EL_SP_BUGGY_BASE_ACTIVATING, - 0, - InitBuggyBase, - NULL, - NULL + GAME_PANEL_INVENTORY_LAST_2, + &game.panel.inventory_last[1], + TYPE_ELEMENT, }, { - EL_SP_BUGGY_BASE_ACTIVATING, - EL_SP_BUGGY_BASE_ACTIVE, - 0, - InitBuggyBase, - NULL, - NULL + GAME_PANEL_INVENTORY_LAST_3, + &game.panel.inventory_last[2], + TYPE_ELEMENT, }, { - EL_SP_BUGGY_BASE_ACTIVE, - EL_SP_BUGGY_BASE, - 0, - InitBuggyBase, - WarnBuggyBase, - NULL + GAME_PANEL_INVENTORY_LAST_4, + &game.panel.inventory_last[3], + TYPE_ELEMENT, }, { - EL_TRAP, - EL_TRAP_ACTIVE, - 0, - InitTrap, - NULL, - ActivateTrap + GAME_PANEL_INVENTORY_LAST_5, + &game.panel.inventory_last[4], + TYPE_ELEMENT, }, { - EL_TRAP_ACTIVE, - EL_TRAP, - 31, - NULL, - ChangeActiveTrap, - NULL + GAME_PANEL_INVENTORY_LAST_6, + &game.panel.inventory_last[5], + TYPE_ELEMENT, }, { - EL_ROBOT_WHEEL_ACTIVE, - EL_ROBOT_WHEEL, - 0, - InitRobotWheel, - RunRobotWheel, - StopRobotWheel + GAME_PANEL_INVENTORY_LAST_7, + &game.panel.inventory_last[6], + TYPE_ELEMENT, }, { - EL_TIMEGATE_SWITCH_ACTIVE, - EL_TIMEGATE_SWITCH, - 0, - InitTimegateWheel, - RunTimegateWheel, - NULL + GAME_PANEL_INVENTORY_LAST_8, + &game.panel.inventory_last[7], + TYPE_ELEMENT, }, { - EL_EMC_MAGIC_BALL_ACTIVE, - EL_EMC_MAGIC_BALL_ACTIVE, - 0, - InitMagicBallDelay, - NULL, - ActivateMagicBall + GAME_PANEL_KEY_1, + &game.panel.key[0], + TYPE_ELEMENT, }, { - EL_EMC_SPRING_BUMPER_ACTIVE, - EL_EMC_SPRING_BUMPER, - 8, - NULL, - NULL, - NULL + GAME_PANEL_KEY_2, + &game.panel.key[1], + TYPE_ELEMENT, }, { - EL_DIAGONAL_SHRINKING, - EL_UNDEFINED, - 0, - NULL, - NULL, - NULL + GAME_PANEL_KEY_3, + &game.panel.key[2], + TYPE_ELEMENT, }, { - EL_DIAGONAL_GROWING, - EL_UNDEFINED, - 0, - NULL, - NULL, - InitDiagonalMovingElement + GAME_PANEL_KEY_4, + &game.panel.key[3], + TYPE_ELEMENT, }, - { - EL_UNDEFINED, - EL_UNDEFINED, - -1, - NULL, - NULL, - NULL - } -}; - -struct -{ - int element; - int push_delay_fixed, push_delay_random; -} -push_delay_list[] = -{ - { EL_SPRING, 0, 0 }, - { EL_BALLOON, 0, 0 }, - - { EL_SOKOBAN_OBJECT, 2, 0 }, - { EL_SOKOBAN_FIELD_FULL, 2, 0 }, - { EL_SATELLITE, 2, 0 }, - { EL_SP_DISK_YELLOW, 2, 0 }, - - { EL_UNDEFINED, 0, 0 }, -}; - -struct -{ - int element; - int move_stepsize; -} -move_stepsize_list[] = -{ - { EL_AMOEBA_DROP, 2 }, - { EL_AMOEBA_DROPPING, 2 }, - { EL_QUICKSAND_FILLING, 1 }, - { EL_QUICKSAND_EMPTYING, 1 }, - { EL_MAGIC_WALL_FILLING, 2 }, - { EL_BD_MAGIC_WALL_FILLING, 2 }, - { EL_MAGIC_WALL_EMPTYING, 2 }, - { EL_BD_MAGIC_WALL_EMPTYING, 2 }, - - { EL_UNDEFINED, 0 }, -}; - -struct -{ - int element; - int count; -} -collect_count_list[] = -{ - { EL_EMERALD, 1 }, - { EL_BD_DIAMOND, 1 }, - { EL_EMERALD_YELLOW, 1 }, - { EL_EMERALD_RED, 1 }, - { EL_EMERALD_PURPLE, 1 }, - { EL_DIAMOND, 3 }, - { EL_SP_INFOTRON, 1 }, - { EL_PEARL, 5 }, - { EL_CRYSTAL, 8 }, + GAME_PANEL_KEY_5, + &game.panel.key[4], + TYPE_ELEMENT, + }, + { + GAME_PANEL_KEY_6, + &game.panel.key[5], + TYPE_ELEMENT, + }, + { + GAME_PANEL_KEY_7, + &game.panel.key[6], + TYPE_ELEMENT, + }, + { + GAME_PANEL_KEY_8, + &game.panel.key[7], + TYPE_ELEMENT, + }, + { + GAME_PANEL_KEY_WHITE, + &game.panel.key_white, + TYPE_ELEMENT, + }, + { + GAME_PANEL_KEY_WHITE_COUNT, + &game.panel.key_white_count, + TYPE_INTEGER, + }, + { + GAME_PANEL_SCORE, + &game.panel.score, + TYPE_INTEGER, + }, + { + GAME_PANEL_HIGHSCORE, + &game.panel.highscore, + TYPE_INTEGER, + }, + { + GAME_PANEL_TIME, + &game.panel.time, + TYPE_INTEGER, + }, + { + GAME_PANEL_TIME_HH, + &game.panel.time_hh, + TYPE_INTEGER, + }, + { + GAME_PANEL_TIME_MM, + &game.panel.time_mm, + TYPE_INTEGER, + }, + { + GAME_PANEL_TIME_SS, + &game.panel.time_ss, + TYPE_INTEGER, + }, + { + GAME_PANEL_SHIELD_NORMAL, + &game.panel.shield_normal, + TYPE_ELEMENT, + }, + { + GAME_PANEL_SHIELD_NORMAL_TIME, + &game.panel.shield_normal_time, + TYPE_INTEGER, + }, + { + GAME_PANEL_SHIELD_DEADLY, + &game.panel.shield_deadly, + TYPE_ELEMENT, + }, + { + GAME_PANEL_SHIELD_DEADLY_TIME, + &game.panel.shield_deadly_time, + TYPE_INTEGER, + }, + { + GAME_PANEL_EXIT, + &game.panel.exit, + TYPE_ELEMENT, + }, + { + GAME_PANEL_EMC_MAGIC_BALL, + &game.panel.emc_magic_ball, + TYPE_ELEMENT, + }, + { + GAME_PANEL_EMC_MAGIC_BALL_SWITCH, + &game.panel.emc_magic_ball_switch, + TYPE_ELEMENT, + }, + { + GAME_PANEL_LIGHT_SWITCH, + &game.panel.light_switch, + TYPE_ELEMENT, + }, + { + GAME_PANEL_LIGHT_SWITCH_TIME, + &game.panel.light_switch_time, + TYPE_INTEGER, + }, + { + GAME_PANEL_TIMEGATE_SWITCH, + &game.panel.timegate_switch, + TYPE_ELEMENT, + }, + { + GAME_PANEL_TIMEGATE_SWITCH_TIME, + &game.panel.timegate_switch_time, + TYPE_INTEGER, + }, + { + GAME_PANEL_SWITCHGATE_SWITCH, + &game.panel.switchgate_switch, + TYPE_ELEMENT, + }, + { + GAME_PANEL_EMC_LENSES, + &game.panel.emc_lenses, + TYPE_ELEMENT, + }, + { + GAME_PANEL_EMC_LENSES_TIME, + &game.panel.emc_lenses_time, + TYPE_INTEGER, + }, + { + GAME_PANEL_EMC_MAGNIFIER, + &game.panel.emc_magnifier, + TYPE_ELEMENT, + }, + { + GAME_PANEL_EMC_MAGNIFIER_TIME, + &game.panel.emc_magnifier_time, + TYPE_INTEGER, + }, + { + GAME_PANEL_BALLOON_SWITCH, + &game.panel.balloon_switch, + TYPE_ELEMENT, + }, + { + GAME_PANEL_DYNABOMB_NUMBER, + &game.panel.dynabomb_number, + TYPE_INTEGER, + }, + { + GAME_PANEL_DYNABOMB_SIZE, + &game.panel.dynabomb_size, + TYPE_INTEGER, + }, + { + GAME_PANEL_DYNABOMB_POWER, + &game.panel.dynabomb_power, + TYPE_ELEMENT, + }, + { + GAME_PANEL_PENGUINS, + &game.panel.penguins, + TYPE_INTEGER, + }, + { + GAME_PANEL_SOKOBAN_OBJECTS, + &game.panel.sokoban_objects, + TYPE_INTEGER, + }, + { + GAME_PANEL_SOKOBAN_FIELDS, + &game.panel.sokoban_fields, + TYPE_INTEGER, + }, + { + GAME_PANEL_ROBOT_WHEEL, + &game.panel.robot_wheel, + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_1, + &game.panel.conveyor_belt[0], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_2, + &game.panel.conveyor_belt[1], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_3, + &game.panel.conveyor_belt[2], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_4, + &game.panel.conveyor_belt[3], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_1_SWITCH, + &game.panel.conveyor_belt_switch[0], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_2_SWITCH, + &game.panel.conveyor_belt_switch[1], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_3_SWITCH, + &game.panel.conveyor_belt_switch[2], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CONVEYOR_BELT_4_SWITCH, + &game.panel.conveyor_belt_switch[3], + TYPE_ELEMENT, + }, + { + GAME_PANEL_MAGIC_WALL, + &game.panel.magic_wall, + TYPE_ELEMENT, + }, + { + GAME_PANEL_MAGIC_WALL_TIME, + &game.panel.magic_wall_time, + TYPE_INTEGER, + }, + { + GAME_PANEL_GRAVITY_STATE, + &game.panel.gravity_state, + TYPE_STRING, + }, + { + GAME_PANEL_GRAPHIC_1, + &game.panel.graphic[0], + TYPE_ELEMENT, + }, + { + GAME_PANEL_GRAPHIC_2, + &game.panel.graphic[1], + TYPE_ELEMENT, + }, + { + GAME_PANEL_GRAPHIC_3, + &game.panel.graphic[2], + TYPE_ELEMENT, + }, + { + GAME_PANEL_GRAPHIC_4, + &game.panel.graphic[3], + TYPE_ELEMENT, + }, + { + GAME_PANEL_GRAPHIC_5, + &game.panel.graphic[4], + TYPE_ELEMENT, + }, + { + GAME_PANEL_GRAPHIC_6, + &game.panel.graphic[5], + TYPE_ELEMENT, + }, + { + GAME_PANEL_GRAPHIC_7, + &game.panel.graphic[6], + TYPE_ELEMENT, + }, + { + GAME_PANEL_GRAPHIC_8, + &game.panel.graphic[7], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_1, + &game.panel.element[0], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_2, + &game.panel.element[1], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_3, + &game.panel.element[2], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_4, + &game.panel.element[3], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_5, + &game.panel.element[4], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_6, + &game.panel.element[5], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_7, + &game.panel.element[6], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_8, + &game.panel.element[7], + TYPE_ELEMENT, + }, + { + GAME_PANEL_ELEMENT_COUNT_1, + &game.panel.element_count[0], + TYPE_INTEGER, + }, + { + GAME_PANEL_ELEMENT_COUNT_2, + &game.panel.element_count[1], + TYPE_INTEGER, + }, + { + GAME_PANEL_ELEMENT_COUNT_3, + &game.panel.element_count[2], + TYPE_INTEGER, + }, + { + GAME_PANEL_ELEMENT_COUNT_4, + &game.panel.element_count[3], + TYPE_INTEGER, + }, + { + GAME_PANEL_ELEMENT_COUNT_5, + &game.panel.element_count[4], + TYPE_INTEGER, + }, + { + GAME_PANEL_ELEMENT_COUNT_6, + &game.panel.element_count[5], + TYPE_INTEGER, + }, + { + GAME_PANEL_ELEMENT_COUNT_7, + &game.panel.element_count[6], + TYPE_INTEGER, + }, + { + GAME_PANEL_ELEMENT_COUNT_8, + &game.panel.element_count[7], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_1, + &game.panel.ce_score[0], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_2, + &game.panel.ce_score[1], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_3, + &game.panel.ce_score[2], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_4, + &game.panel.ce_score[3], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_5, + &game.panel.ce_score[4], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_6, + &game.panel.ce_score[5], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_7, + &game.panel.ce_score[6], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_8, + &game.panel.ce_score[7], + TYPE_INTEGER, + }, + { + GAME_PANEL_CE_SCORE_1_ELEMENT, + &game.panel.ce_score_element[0], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CE_SCORE_2_ELEMENT, + &game.panel.ce_score_element[1], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CE_SCORE_3_ELEMENT, + &game.panel.ce_score_element[2], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CE_SCORE_4_ELEMENT, + &game.panel.ce_score_element[3], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CE_SCORE_5_ELEMENT, + &game.panel.ce_score_element[4], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CE_SCORE_6_ELEMENT, + &game.panel.ce_score_element[5], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CE_SCORE_7_ELEMENT, + &game.panel.ce_score_element[6], + TYPE_ELEMENT, + }, + { + GAME_PANEL_CE_SCORE_8_ELEMENT, + &game.panel.ce_score_element[7], + TYPE_ELEMENT, + }, + { + GAME_PANEL_PLAYER_NAME, + &game.panel.player_name, + TYPE_STRING, + }, + { + GAME_PANEL_LEVEL_NAME, + &game.panel.level_name, + TYPE_STRING, + }, + { + GAME_PANEL_LEVEL_AUTHOR, + &game.panel.level_author, + TYPE_STRING, + }, - { EL_UNDEFINED, 0 }, + { + -1, + NULL, + -1, + } }; +#endif + + +/* values for delayed check of falling and moving elements and for collision */ +#define CHECK_DELAY_MOVING 3 +#define CHECK_DELAY_FALLING CHECK_DELAY_MOVING +#define CHECK_DELAY_COLLISION 2 +#define CHECK_DELAY_IMPACT CHECK_DELAY_COLLISION + +/* values for initial player move delay (initial delay counter value) */ +#define INITIAL_MOVE_DELAY_OFF -1 +#define INITIAL_MOVE_DELAY_ON 0 + +/* values for player movement speed (which is in fact a delay value) */ +#define MOVE_DELAY_MIN_SPEED 32 +#define MOVE_DELAY_NORMAL_SPEED 8 +#define MOVE_DELAY_HIGH_SPEED 4 +#define MOVE_DELAY_MAX_SPEED 1 + +#define DOUBLE_MOVE_DELAY(x) (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x)) +#define HALVE_MOVE_DELAY(x) (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x)) + +#define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY( (p)->move_delay_value)) +#define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value)) + +/* values for other actions */ +#define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED) +#define MOVE_STEPSIZE_MIN (1) +#define MOVE_STEPSIZE_MAX (TILEX) + +#define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0) +#define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0) + +#define INIT_GFX_RANDOM() (GetSimpleRandom(1000000)) + +#define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \ + RND(element_info[e].push_delay_random)) +#define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \ + RND(element_info[e].drop_delay_random)) +#define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \ + RND(element_info[e].move_delay_random)) +#define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \ + (element_info[e].move_delay_random)) +#define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\ + RND(element_info[e].ce_value_random_initial)) +#define GET_CE_SCORE(e) ( (element_info[e].collect_score)) +#define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \ + RND((c)->delay_random * (c)->delay_frames)) +#define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \ + RND((c)->delay_random)) + + +#define GET_VALID_RUNTIME_ELEMENT(e) \ + ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e)) + +#define RESOLVED_REFERENCE_ELEMENT(be, e) \ + ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \ + (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \ + (be) + (e) - EL_SELF) + +#define GET_PLAYER_FROM_BITS(p) \ + (EL_PLAYER_1 + ((p) != PLAYER_BITS_ANY ? log_2(p) : 0)) + +#define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \ + ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \ + (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \ + (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \ + (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \ + (e) == EL_CURRENT_CE_VALUE ? (cv) : \ + (e) == EL_CURRENT_CE_SCORE ? (cs) : \ + (e) >= EL_PREV_CE_8 && (e) <= EL_NEXT_CE_8 ? \ + RESOLVED_REFERENCE_ELEMENT(be, e) : \ + (e)) + +#define CAN_GROW_INTO(e) \ + ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable)) + +#define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \ + (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \ + (condition))) + +#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))) + +#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)))) + +#define ELEMENT_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0) + +#define SATELLITE_CAN_ENTER_FIELD(x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0) + +#define ANDROID_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Feld[x][y] == EL_EMC_PLANT) + +#define ANDROID_CAN_CLONE_FIELD(x, y) \ + (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Feld[x][y]) || \ + CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT))) + +#define ENEMY_CAN_ENTER_FIELD(e, x, y) \ + ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0) + +#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 || \ + Feld[x][y] == EL_EM_EXIT_OPEN || \ + Feld[x][y] == EL_STEEL_EXIT_OPEN || \ + Feld[x][y] == EL_EM_STEEL_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) + +#define SPRING_CAN_BUMP_FROM_FIELD(x, y) \ + (IN_LEV_FIELD(x, y) && (Feld[x][y] == EL_EMC_SPRING_BUMPER || \ + Feld[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE)) + +#define MOVE_ENTER_EL(e) (element_info[e].move_enter_element) + +#define CE_ENTER_FIELD_COND(e, x, y) \ + (!IS_PLAYER(x, y) && \ + IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e))) + +#define CUSTOM_ELEMENT_CAN_ENTER_FIELD(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)) + +#define ACCESS_FROM(e, d) (element_info[e].access_direction &(d)) +#define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d)) +#define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d)) +#define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d)) + +/* game button identifiers */ +#define GAME_CTRL_ID_STOP 0 +#define GAME_CTRL_ID_PAUSE 1 +#define GAME_CTRL_ID_PLAY 2 +#define SOUND_CTRL_ID_MUSIC 3 +#define SOUND_CTRL_ID_LOOPS 4 +#define SOUND_CTRL_ID_SIMPLE 5 + +#define NUM_GAME_BUTTONS 6 + + +/* forward declaration for internal use */ + +static void CreateField(int, int, int); + +static void ResetGfxAnimation(int, int); + +static void SetPlayerWaiting(struct PlayerInfo *, boolean); +static void AdvanceFrameAndPlayerCounters(int); + +static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int); +static boolean MovePlayer(struct PlayerInfo *, int, int); +static void ScrollPlayer(struct PlayerInfo *, int); +static void ScrollScreen(struct PlayerInfo *, int); + +static int DigField(struct PlayerInfo *, int, int, int, int, int, int, int); +static boolean DigFieldByCE(int, int, int); +static boolean SnapField(struct PlayerInfo *, int, int); +static boolean DropElement(struct PlayerInfo *); + +static void InitBeltMovement(void); +static void CloseAllOpenTimegates(void); +static void CheckGravityMovement(struct PlayerInfo *); +static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *); +static void KillPlayerUnlessEnemyProtected(int, int); +static void KillPlayerUnlessExplosionProtected(int, int); + +static void TestIfPlayerTouchesCustomElement(int, int); +static void TestIfElementTouchesCustomElement(int, int); +static void TestIfElementHitsCustomElement(int, int, int); +#if 0 +static void TestIfElementSmashesCustomElement(int, int, int); +#endif + +static void HandleElementChange(int, int, int); +static void ExecuteCustomElementAction(int, int, int, int); +static boolean ChangeElement(int, int, int, int); + +static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int); +#define CheckTriggeredElementChange(x, y, e, ev) \ + CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1) +#define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \ + CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1) +#define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \ + CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1) +#define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \ + CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p) + +static boolean CheckElementChangeExt(int, int, int, int, int, int, int); +#define CheckElementChange(x, y, e, te, ev) \ + CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY) +#define CheckElementChangeByPlayer(x, y, e, ev, p, s) \ + CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s) +#define CheckElementChangeBySide(x, y, e, te, ev, s) \ + CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s) + +static void PlayLevelSound(int, int, int); +static void PlayLevelSoundNearest(int, int, int); +static void PlayLevelSoundAction(int, int, int); +static void PlayLevelSoundElementAction(int, int, int, int); +static void PlayLevelSoundElementActionIfLoop(int, int, int, int); +static void PlayLevelSoundActionIfLoop(int, int, int); +static void StopLevelSoundActionIfLoop(int, int, int); +static void PlayLevelMusic(); + +static void MapGameButtons(); +static void HandleGameButtons(struct GadgetInfo *); + +int AmoebeNachbarNr(int, int); +void AmoebeUmwandeln(int, int); +void ContinueMoving(int, int); +void Bang(int, int); +void InitMovDir(int, int); +void InitAmoebaNr(int, int); +int NewHiScore(void); + +void TestIfGoodThingHitsBadThing(int, int, int); +void TestIfBadThingHitsGoodThing(int, int, int); +void TestIfPlayerTouchesBadThing(int, int); +void TestIfPlayerRunsIntoBadThing(int, int, int); +void TestIfBadThingTouchesPlayer(int, int); +void TestIfBadThingRunsIntoPlayer(int, int, int); +void TestIfFriendTouchesBadThing(int, int); +void TestIfBadThingTouchesFriend(int, int); +void TestIfBadThingTouchesOtherBadThing(int, int); +void TestIfGoodThingGetsHitByBadThing(int, int, int); + +void KillPlayer(struct PlayerInfo *); +void BuryPlayer(struct PlayerInfo *); +void RemovePlayer(struct PlayerInfo *); + +static int getInvisibleActiveFromInvisibleElement(int); +static int getInvisibleFromInvisibleActiveElement(int); + +static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS]; + +/* for detection of endless loops, caused by custom element programming */ +/* (using maximal playfield width x 10 is just a rough approximation) */ +#define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10) + +#define RECURSION_LOOP_DETECTION_START(e, rc) \ +{ \ + if (recursion_loop_detected) \ + return (rc); \ + \ + if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \ + { \ + recursion_loop_detected = TRUE; \ + recursion_loop_element = (e); \ + } \ + \ + recursion_loop_depth++; \ +} + +#define RECURSION_LOOP_DETECTION_END() \ +{ \ + recursion_loop_depth--; \ +} + +static int recursion_loop_depth; +static boolean recursion_loop_detected; +static boolean recursion_loop_element; + +static int map_player_action[MAX_PLAYERS]; + + +/* ------------------------------------------------------------------------- */ +/* definition of elements that automatically change to other elements after */ +/* a specified time, eventually calling a function when changing */ +/* ------------------------------------------------------------------------- */ + +/* forward declaration for changer functions */ +static void InitBuggyBase(int, int); +static void WarnBuggyBase(int, int); + +static void InitTrap(int, int); +static void ActivateTrap(int, int); +static void ChangeActiveTrap(int, int); + +static void InitRobotWheel(int, int); +static void RunRobotWheel(int, int); +static void StopRobotWheel(int, int); + +static void InitTimegateWheel(int, int); +static void RunTimegateWheel(int, int); + +static void InitMagicBallDelay(int, int); +static void ActivateMagicBall(int, int); + +struct ChangingElementInfo +{ + int element; + int target_element; + int change_delay; + void (*pre_change_function)(int x, int y); + void (*change_function)(int x, int y); + void (*post_change_function)(int x, int y); +}; + +static struct ChangingElementInfo change_delay_list[] = +{ + { + EL_NUT_BREAKING, + EL_EMERALD, + 6, + NULL, + NULL, + NULL + }, + { + EL_PEARL_BREAKING, + EL_EMPTY, + 8, + NULL, + NULL, + NULL + }, + { + EL_EXIT_OPENING, + EL_EXIT_OPEN, + 29, + NULL, + NULL, + NULL + }, + { + EL_EXIT_CLOSING, + EL_EXIT_CLOSED, + 29, + NULL, + NULL, + NULL + }, + { + EL_STEEL_EXIT_OPENING, + EL_STEEL_EXIT_OPEN, + 29, + NULL, + NULL, + NULL + }, + { + EL_STEEL_EXIT_CLOSING, + EL_STEEL_EXIT_CLOSED, + 29, + NULL, + NULL, + NULL + }, + { + EL_EM_EXIT_OPENING, + EL_EM_EXIT_OPEN, + 29, + NULL, + NULL, + NULL + }, + { + EL_EM_EXIT_CLOSING, +#if 1 + EL_EMPTY, +#else + EL_EM_EXIT_CLOSED, +#endif + 29, + NULL, + NULL, + NULL + }, + { + EL_EM_STEEL_EXIT_OPENING, + EL_EM_STEEL_EXIT_OPEN, + 29, + NULL, + NULL, + NULL + }, + { + EL_EM_STEEL_EXIT_CLOSING, +#if 1 + EL_STEELWALL, +#else + EL_EM_STEEL_EXIT_CLOSED, +#endif + 29, + NULL, + 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, + 29, + NULL, + NULL, + NULL + }, + { + EL_SWITCHGATE_CLOSING, + EL_SWITCHGATE_CLOSED, + 29, + NULL, + NULL, + NULL + }, + { + EL_TIMEGATE_OPENING, + EL_TIMEGATE_OPEN, + 29, + NULL, + NULL, + NULL + }, + { + EL_TIMEGATE_CLOSING, + EL_TIMEGATE_CLOSED, + 29, + NULL, + NULL, + NULL + }, + + { + EL_ACID_SPLASH_LEFT, + EL_EMPTY, + 8, + NULL, + NULL, + NULL + }, + { + EL_ACID_SPLASH_RIGHT, + EL_EMPTY, + 8, + NULL, + NULL, + NULL + }, + { + EL_SP_BUGGY_BASE, + EL_SP_BUGGY_BASE_ACTIVATING, + 0, + InitBuggyBase, + NULL, + NULL + }, + { + EL_SP_BUGGY_BASE_ACTIVATING, + EL_SP_BUGGY_BASE_ACTIVE, + 0, + InitBuggyBase, + NULL, + NULL + }, + { + EL_SP_BUGGY_BASE_ACTIVE, + EL_SP_BUGGY_BASE, + 0, + InitBuggyBase, + WarnBuggyBase, + NULL + }, + { + EL_TRAP, + EL_TRAP_ACTIVE, + 0, + InitTrap, + NULL, + ActivateTrap + }, + { + EL_TRAP_ACTIVE, + EL_TRAP, + 31, + NULL, + ChangeActiveTrap, + NULL + }, + { + EL_ROBOT_WHEEL_ACTIVE, + EL_ROBOT_WHEEL, + 0, + InitRobotWheel, + RunRobotWheel, + StopRobotWheel + }, + { + EL_TIMEGATE_SWITCH_ACTIVE, + EL_TIMEGATE_SWITCH, + 0, + InitTimegateWheel, + RunTimegateWheel, + NULL + }, + { + EL_DC_TIMEGATE_SWITCH_ACTIVE, + EL_DC_TIMEGATE_SWITCH, + 0, + InitTimegateWheel, + RunTimegateWheel, + NULL + }, + { + EL_EMC_MAGIC_BALL_ACTIVE, + EL_EMC_MAGIC_BALL_ACTIVE, + 0, + InitMagicBallDelay, + NULL, + ActivateMagicBall + }, + { + EL_EMC_SPRING_BUMPER_ACTIVE, + EL_EMC_SPRING_BUMPER, + 8, + NULL, + NULL, + NULL + }, + { + EL_DIAGONAL_SHRINKING, + EL_UNDEFINED, + 0, + NULL, + NULL, + NULL + }, + { + EL_DIAGONAL_GROWING, + EL_UNDEFINED, + 0, + NULL, + NULL, + NULL, + }, + + { + EL_UNDEFINED, + EL_UNDEFINED, + -1, + NULL, + NULL, + NULL + } +}; + +struct +{ + int element; + int push_delay_fixed, push_delay_random; +} +push_delay_list[] = +{ + { EL_SPRING, 0, 0 }, + { EL_BALLOON, 0, 0 }, + + { EL_SOKOBAN_OBJECT, 2, 0 }, + { EL_SOKOBAN_FIELD_FULL, 2, 0 }, + { EL_SATELLITE, 2, 0 }, + { EL_SP_DISK_YELLOW, 2, 0 }, + + { EL_UNDEFINED, 0, 0 }, +}; + +struct +{ + int element; + int move_stepsize; +} +move_stepsize_list[] = +{ + { EL_AMOEBA_DROP, 2 }, + { EL_AMOEBA_DROPPING, 2 }, + { EL_QUICKSAND_FILLING, 1 }, + { EL_QUICKSAND_EMPTYING, 1 }, + { EL_QUICKSAND_FAST_FILLING, 2 }, + { EL_QUICKSAND_FAST_EMPTYING, 2 }, + { EL_MAGIC_WALL_FILLING, 2 }, + { EL_MAGIC_WALL_EMPTYING, 2 }, + { EL_BD_MAGIC_WALL_FILLING, 2 }, + { EL_BD_MAGIC_WALL_EMPTYING, 2 }, + { EL_DC_MAGIC_WALL_FILLING, 2 }, + { EL_DC_MAGIC_WALL_EMPTYING, 2 }, + + { EL_UNDEFINED, 0 }, +}; + +struct +{ + int element; + int count; +} +collect_count_list[] = +{ + { EL_EMERALD, 1 }, + { EL_BD_DIAMOND, 1 }, + { EL_EMERALD_YELLOW, 1 }, + { EL_EMERALD_RED, 1 }, + { EL_EMERALD_PURPLE, 1 }, + { EL_DIAMOND, 3 }, + { EL_SP_INFOTRON, 1 }, + { EL_PEARL, 5 }, + { EL_CRYSTAL, 8 }, + + { EL_UNDEFINED, 0 }, +}; + +struct +{ + int element; + int direction; +} +access_direction_list[] = +{ + { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }, + { EL_TUBE_VERTICAL, MV_UP | MV_DOWN }, + { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT }, + { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN }, + { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN }, + { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP }, + { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN }, + { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP }, + { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN }, + { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP }, + { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN }, + + { EL_SP_PORT_LEFT, MV_RIGHT }, + { EL_SP_PORT_RIGHT, MV_LEFT }, + { EL_SP_PORT_UP, MV_DOWN }, + { EL_SP_PORT_DOWN, MV_UP }, + { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT }, + { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN }, + { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }, + { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT }, + { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT }, + { EL_SP_GRAVITY_PORT_UP, MV_DOWN }, + { EL_SP_GRAVITY_PORT_DOWN, MV_UP }, + { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT }, + { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT }, + { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN }, + { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP }, + { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT }, + { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT }, + { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN }, + { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP }, + + { EL_UNDEFINED, MV_NONE } +}; + +static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS]; + +#define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY]) +#define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0) +#define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Feld[x][y]) || \ + IS_JUST_CHANGING(x, y)) + +#define CE_PAGE(e, ce) (element_info[e].event_page[ce]) + +/* static variables for playfield scan mode (scanning forward or backward) */ +static int playfield_scan_start_x = 0; +static int playfield_scan_start_y = 0; +static int playfield_scan_delta_x = 1; +static int playfield_scan_delta_y = 1; + +#define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \ + (y) >= 0 && (y) <= lev_fieldy - 1; \ + (y) += playfield_scan_delta_y) \ + for ((x) = playfield_scan_start_x; \ + (x) >= 0 && (x) <= lev_fieldx - 1; \ + (x) += playfield_scan_delta_x) + +#ifdef DEBUG +void DEBUG_SetMaximumDynamite() +{ + int i; + + for (i = 0; i < MAX_INVENTORY_SIZE; i++) + if (local_player->inventory_size < MAX_INVENTORY_SIZE) + local_player->inventory_element[local_player->inventory_size++] = + EL_DYNAMITE; +} +#endif + +static void InitPlayfieldScanModeVars() +{ + if (game.use_reverse_scan_direction) + { + playfield_scan_start_x = lev_fieldx - 1; + playfield_scan_start_y = lev_fieldy - 1; + + playfield_scan_delta_x = -1; + playfield_scan_delta_y = -1; + } + else + { + playfield_scan_start_x = 0; + playfield_scan_start_y = 0; + + playfield_scan_delta_x = 1; + playfield_scan_delta_y = 1; + } +} + +static void InitPlayfieldScanMode(int mode) +{ + game.use_reverse_scan_direction = + (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE); + + InitPlayfieldScanModeVars(); +} + +static int get_move_delay_from_stepsize(int move_stepsize) +{ + move_stepsize = + MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX); + + /* make sure that stepsize value is always a power of 2 */ + move_stepsize = (1 << log_2(move_stepsize)); + + return TILEX / move_stepsize; +} + +static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize, + boolean init_game) +{ + int player_nr = player->index_nr; + int move_delay = get_move_delay_from_stepsize(move_stepsize); + boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE); + + /* do no immediately change move delay -- the player might just be moving */ + player->move_delay_value_next = move_delay; + + /* information if player can move must be set separately */ + player->cannot_move = cannot_move; + + if (init_game) + { + player->move_delay = game.initial_move_delay[player_nr]; + player->move_delay_value = game.initial_move_delay_value[player_nr]; + + player->move_delay_value_next = -1; + + player->move_delay_reset_counter = 0; + } +} + +void GetPlayerConfig() +{ + GameFrameDelay = setup.game_frame_delay; + + if (!audio.sound_available) + setup.sound_simple = FALSE; + + if (!audio.loops_available) + setup.sound_loops = FALSE; + + if (!audio.music_available) + setup.sound_music = FALSE; + + if (!video.fullscreen_available) + setup.fullscreen = FALSE; + + setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music); + + SetAudioMode(setup.sound); + InitJoysticks(); +} + +int GetElementFromGroupElement(int element) +{ + if (IS_GROUP_ELEMENT(element)) + { + struct ElementGroupInfo *group = element_info[element].group; + int last_anim_random_frame = gfx.anim_random_frame; + int element_pos; + + if (group->choice_mode == ANIM_RANDOM) + gfx.anim_random_frame = RND(group->num_elements_resolved); + + element_pos = getAnimationFrame(group->num_elements_resolved, 1, + group->choice_mode, 0, + group->choice_pos); + + if (group->choice_mode == ANIM_RANDOM) + gfx.anim_random_frame = last_anim_random_frame; + + group->choice_pos++; + + element = group->element_resolved[element_pos]; + } + + return element; +} + +static void InitPlayerField(int x, int y, int element, boolean init_game) +{ + if (element == EL_SP_MURPHY) + { + if (init_game) + { + if (stored_player[0].present) + { + Feld[x][y] = EL_SP_MURPHY_CLONE; + + return; + } + else + { + stored_player[0].initial_element = element; + stored_player[0].use_murphy = TRUE; + + if (!level.use_artwork_element[0]) + stored_player[0].artwork_element = EL_SP_MURPHY; + } + + Feld[x][y] = EL_PLAYER_1; + } + } + + if (init_game) + { + struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_PLAYER_1]; + int jx = player->jx, jy = player->jy; + + player->present = TRUE; + + player->block_last_field = (element == EL_SP_MURPHY ? + level.sp_block_last_field : + level.block_last_field); + + /* ---------- initialize player's last field block delay --------------- */ + + /* always start with reliable default value (no adjustment needed) */ + player->block_delay_adjustment = 0; + + /* special case 1: in Supaplex, Murphy blocks last field one more frame */ + if (player->block_last_field && element == EL_SP_MURPHY) + player->block_delay_adjustment = 1; + + /* special case 2: in game engines before 3.1.1, blocking was different */ + if (game.use_block_last_field_bug) + player->block_delay_adjustment = (player->block_last_field ? -1 : 1); + + if (!options.network || player->connected) + { + player->active = TRUE; + + /* remove potentially duplicate players */ + if (StorePlayer[jx][jy] == Feld[x][y]) + StorePlayer[jx][jy] = 0; + + StorePlayer[x][y] = Feld[x][y]; + + if (options.debug) + { + printf("Player %d activated.\n", player->element_nr); + printf("[Local player is %d and currently %s.]\n", + local_player->element_nr, + local_player->active ? "active" : "not active"); + } + } + + Feld[x][y] = EL_EMPTY; + + player->jx = player->last_jx = x; + player->jy = player->last_jy = y; + } + +#if USE_PLAYER_REANIMATION + if (!init_game) + { + int player_nr = GET_PLAYER_NR(element); + struct PlayerInfo *player = &stored_player[player_nr]; + + if (player->active && player->killed) + player->reanimated = TRUE; /* if player was just killed, reanimate him */ + } +#endif +} + +static void InitField(int x, int y, boolean init_game) +{ + int element = Feld[x][y]; + + switch (element) + { + case EL_SP_MURPHY: + case EL_PLAYER_1: + case EL_PLAYER_2: + case EL_PLAYER_3: + case EL_PLAYER_4: + InitPlayerField(x, y, element, init_game); + break; + + case EL_SOKOBAN_FIELD_PLAYER: + element = Feld[x][y] = EL_PLAYER_1; + InitField(x, y, init_game); + + element = Feld[x][y] = EL_SOKOBAN_FIELD_EMPTY; + InitField(x, y, init_game); + break; + + case EL_SOKOBAN_FIELD_EMPTY: + local_player->sokobanfields_still_needed++; + break; + + case EL_STONEBLOCK: + if (x < lev_fieldx-1 && Feld[x+1][y] == EL_ACID) + Feld[x][y] = EL_ACID_POOL_TOPLEFT; + else if (x > 0 && Feld[x-1][y] == EL_ACID) + Feld[x][y] = EL_ACID_POOL_TOPRIGHT; + else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPLEFT) + Feld[x][y] = EL_ACID_POOL_BOTTOMLEFT; + else if (y > 0 && Feld[x][y-1] == EL_ACID) + Feld[x][y] = EL_ACID_POOL_BOTTOM; + else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPRIGHT) + Feld[x][y] = EL_ACID_POOL_BOTTOMRIGHT; + break; + + case EL_BUG: + case EL_BUG_RIGHT: + case EL_BUG_UP: + case EL_BUG_LEFT: + case EL_BUG_DOWN: + case EL_SPACESHIP: + case EL_SPACESHIP_RIGHT: + case EL_SPACESHIP_UP: + case EL_SPACESHIP_LEFT: + case EL_SPACESHIP_DOWN: + case EL_BD_BUTTERFLY: + case EL_BD_BUTTERFLY_RIGHT: + case EL_BD_BUTTERFLY_UP: + case EL_BD_BUTTERFLY_LEFT: + case EL_BD_BUTTERFLY_DOWN: + case EL_BD_FIREFLY: + case EL_BD_FIREFLY_RIGHT: + case EL_BD_FIREFLY_UP: + case EL_BD_FIREFLY_LEFT: + case EL_BD_FIREFLY_DOWN: + case EL_PACMAN_RIGHT: + case EL_PACMAN_UP: + case EL_PACMAN_LEFT: + case EL_PACMAN_DOWN: + case EL_YAMYAM: + case EL_YAMYAM_LEFT: + case EL_YAMYAM_RIGHT: + case EL_YAMYAM_UP: + case EL_YAMYAM_DOWN: + case EL_DARK_YAMYAM: + case EL_ROBOT: + case EL_PACMAN: + case EL_SP_SNIKSNAK: + case EL_SP_ELECTRON: + case EL_MOLE: + case EL_MOLE_LEFT: + case EL_MOLE_RIGHT: + case EL_MOLE_UP: + case EL_MOLE_DOWN: + InitMovDir(x, y); + break; + + case EL_AMOEBA_FULL: + case EL_BD_AMOEBA: + InitAmoebaNr(x, y); + break; + + case EL_AMOEBA_DROP: + if (y == lev_fieldy - 1) + { + Feld[x][y] = EL_AMOEBA_GROWING; + Store[x][y] = EL_AMOEBA_WET; + } + break; + + case EL_DYNAMITE_ACTIVE: + case EL_SP_DISK_RED_ACTIVE: + case EL_DYNABOMB_PLAYER_1_ACTIVE: + case EL_DYNABOMB_PLAYER_2_ACTIVE: + case EL_DYNABOMB_PLAYER_3_ACTIVE: + case EL_DYNABOMB_PLAYER_4_ACTIVE: + MovDelay[x][y] = 96; + break; + + case EL_EM_DYNAMITE_ACTIVE: + MovDelay[x][y] = 32; + break; + + case EL_LAMP: + local_player->lights_still_needed++; + break; + + case EL_PENGUIN: + local_player->friends_still_needed++; + break; + + case EL_PIG: + case EL_DRAGON: + GfxDir[x][y] = MovDir[x][y] = 1 << RND(4); + break; + + 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_2_SWITCH_LEFT: + case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE: + case EL_CONVEYOR_BELT_2_SWITCH_RIGHT: + case EL_CONVEYOR_BELT_3_SWITCH_LEFT: + case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE: + case EL_CONVEYOR_BELT_3_SWITCH_RIGHT: + case EL_CONVEYOR_BELT_4_SWITCH_LEFT: + case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE: + case EL_CONVEYOR_BELT_4_SWITCH_RIGHT: + if (init_game) + { + int belt_nr = getBeltNrFromBeltSwitchElement(Feld[x][y]); + int belt_dir = getBeltDirFromBeltSwitchElement(Feld[x][y]); + int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Feld[x][y]); -struct -{ - int element; - int direction; -} -access_direction_list[] = -{ - { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }, - { EL_TUBE_VERTICAL, MV_UP | MV_DOWN }, - { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT }, - { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN }, - { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN }, - { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP }, - { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN }, - { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP }, - { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN }, - { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP }, - { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN }, + if (game.belt_dir_nr[belt_nr] == 3) /* initial value */ + { + game.belt_dir[belt_nr] = belt_dir; + game.belt_dir_nr[belt_nr] = belt_dir_nr; + } + else /* more than one switch -- set it like the first switch */ + { + Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr]; + } + } + break; - { EL_SP_PORT_LEFT, MV_RIGHT }, - { EL_SP_PORT_RIGHT, MV_LEFT }, - { EL_SP_PORT_UP, MV_DOWN }, - { EL_SP_PORT_DOWN, MV_UP }, - { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT }, - { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN }, - { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }, - { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT }, - { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT }, - { EL_SP_GRAVITY_PORT_UP, MV_DOWN }, - { EL_SP_GRAVITY_PORT_DOWN, MV_UP }, - { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT }, - { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT }, - { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN }, - { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP }, - { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT }, - { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT }, - { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN }, - { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP }, +#if !USE_BOTH_SWITCHGATE_SWITCHES + case EL_SWITCHGATE_SWITCH_DOWN: /* always start with same switch pos */ + if (init_game) + Feld[x][y] = EL_SWITCHGATE_SWITCH_UP; + break; - { EL_UNDEFINED, MV_NONE } -}; + case EL_DC_SWITCHGATE_SWITCH_DOWN: /* always start with same switch pos */ + if (init_game) + Feld[x][y] = EL_DC_SWITCHGATE_SWITCH_UP; + break; +#endif -static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS]; + case EL_LIGHT_SWITCH_ACTIVE: + if (init_game) + game.light_time_left = level.time_light * FRAMES_PER_SECOND; + break; -#define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY]) -#define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0) -#define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Feld[x][y]) || \ - IS_JUST_CHANGING(x, y)) + case EL_INVISIBLE_STEELWALL: + case EL_INVISIBLE_WALL: + case EL_INVISIBLE_SAND: + if (game.light_time_left > 0 || + game.lenses_time_left > 0) + Feld[x][y] = getInvisibleActiveFromInvisibleElement(element); + break; -#define CE_PAGE(e, ce) (element_info[e].event_page[ce]) + case EL_EMC_MAGIC_BALL: + if (game.ball_state) + Feld[x][y] = EL_EMC_MAGIC_BALL_ACTIVE; + break; -/* static variables for playfield scan mode (scanning forward or backward) */ -static int playfield_scan_start_x = 0; -static int playfield_scan_start_y = 0; -static int playfield_scan_delta_x = 1; -static int playfield_scan_delta_y = 1; + case EL_EMC_MAGIC_BALL_SWITCH: + if (game.ball_state) + Feld[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE; + break; -#define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \ - (y) >= 0 && (y) <= lev_fieldy - 1; \ - (y) += playfield_scan_delta_y) \ - for ((x) = playfield_scan_start_x; \ - (x) >= 0 && (x) <= lev_fieldx - 1; \ - (x) += playfield_scan_delta_x) \ + case EL_TRIGGER_PLAYER: + case EL_TRIGGER_ELEMENT: + case EL_TRIGGER_CE_VALUE: + case EL_TRIGGER_CE_SCORE: + case EL_SELF: + case EL_ANY_ELEMENT: + case EL_CURRENT_CE_VALUE: + case EL_CURRENT_CE_SCORE: + case EL_PREV_CE_1: + case EL_PREV_CE_2: + case EL_PREV_CE_3: + case EL_PREV_CE_4: + case EL_PREV_CE_5: + case EL_PREV_CE_6: + case EL_PREV_CE_7: + case EL_PREV_CE_8: + case EL_NEXT_CE_1: + case EL_NEXT_CE_2: + case EL_NEXT_CE_3: + case EL_NEXT_CE_4: + case EL_NEXT_CE_5: + case EL_NEXT_CE_6: + case EL_NEXT_CE_7: + case EL_NEXT_CE_8: + /* reference elements should not be used on the playfield */ + Feld[x][y] = EL_EMPTY; + break; -#ifdef DEBUG -void DEBUG_SetMaximumDynamite() -{ - int i; + default: + if (IS_CUSTOM_ELEMENT(element)) + { + if (CAN_MOVE(element)) + InitMovDir(x, y); - for (i = 0; i < MAX_INVENTORY_SIZE; i++) - if (local_player->inventory_size < MAX_INVENTORY_SIZE) - local_player->inventory_element[local_player->inventory_size++] = - EL_DYNAMITE; -} +#if USE_NEW_CUSTOM_VALUE + if (!element_info[element].use_last_ce_value || init_game) + CustomValue[x][y] = GET_NEW_CE_VALUE(Feld[x][y]); #endif + } + else if (IS_GROUP_ELEMENT(element)) + { + Feld[x][y] = GetElementFromGroupElement(element); -static void InitPlayfieldScanModeVars() -{ - if (game.use_reverse_scan_direction) - { - playfield_scan_start_x = lev_fieldx - 1; - playfield_scan_start_y = lev_fieldy - 1; + InitField(x, y, init_game); + } - playfield_scan_delta_x = -1; - playfield_scan_delta_y = -1; + break; } - else - { - playfield_scan_start_x = 0; - playfield_scan_start_y = 0; - playfield_scan_delta_x = 1; - playfield_scan_delta_y = 1; - } + if (!init_game) + CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X); } -static void InitPlayfieldScanMode(int mode) +static inline void InitField_WithBug1(int x, int y, boolean init_game) { - game.use_reverse_scan_direction = - (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE); + InitField(x, y, init_game); - InitPlayfieldScanModeVars(); + /* not needed to call InitMovDir() -- already done by InitField()! */ + if (game.engine_version < VERSION_IDENT(3,1,0,0) && + CAN_MOVE(Feld[x][y])) + InitMovDir(x, y); } -static int get_move_delay_from_stepsize(int move_stepsize) +static inline void InitField_WithBug2(int x, int y, boolean init_game) { - move_stepsize = - MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX); - - /* make sure that stepsize value is always a power of 2 */ - move_stepsize = (1 << log_2(move_stepsize)); - - return TILEX / move_stepsize; -} + int old_element = Feld[x][y]; -static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize, - boolean init_game) -{ - int player_nr = player->index_nr; - int move_delay = get_move_delay_from_stepsize(move_stepsize); - boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE); + InitField(x, y, init_game); - /* do no immediately change move delay -- the player might just be moving */ - player->move_delay_value_next = move_delay; + /* not needed to call InitMovDir() -- already done by InitField()! */ + 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); - /* information if player can move must be set separately */ - player->cannot_move = cannot_move; + /* this case is in fact a combination of not less than three bugs: + first, it calls InitMovDir() for elements that can move, although this is + already done by InitField(); then, it checks the element that was at this + field _before_ the call to InitField() (which can change it); lastly, it + was not called for "mole with direction" elements, which were treated as + "cannot move" due to (fixed) wrong element initialization in "src/init.c" + */ +} - if (init_game) - { - player->move_delay = game.initial_move_delay[player_nr]; - player->move_delay_value = game.initial_move_delay_value[player_nr]; +#if 1 - player->move_delay_value_next = -1; +static int get_key_element_from_nr(int key_nr) +{ + int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS : + level.game_engine_type == GAME_ENGINE_TYPE_EM ? + EL_EM_KEY_1 : EL_KEY_1); - player->move_delay_reset_counter = 0; - } + return key_base_element + key_nr; } -void GetPlayerConfig() +static int get_next_dropped_element(struct PlayerInfo *player) { - if (!audio.sound_available) - setup.sound_simple = FALSE; - - if (!audio.loops_available) - setup.sound_loops = FALSE; + return (player->inventory_size > 0 ? + player->inventory_element[player->inventory_size - 1] : + player->inventory_infinite_element != EL_UNDEFINED ? + player->inventory_infinite_element : + player->dynabombs_left > 0 ? + EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr : + EL_UNDEFINED); +} - if (!audio.music_available) - setup.sound_music = FALSE; +static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos) +{ + /* pos >= 0: get element from bottom of the stack; + pos < 0: get element from top of the stack */ - if (!video.fullscreen_available) - setup.fullscreen = FALSE; + if (pos < 0) + { + int min_inventory_size = -pos; + int inventory_pos = player->inventory_size - min_inventory_size; + int min_dynabombs_left = min_inventory_size - player->inventory_size; - setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music); + return (player->inventory_size >= min_inventory_size ? + player->inventory_element[inventory_pos] : + player->inventory_infinite_element != EL_UNDEFINED ? + player->inventory_infinite_element : + player->dynabombs_left >= min_dynabombs_left ? + EL_DYNABOMB_PLAYER_1 + player->index_nr : + EL_UNDEFINED); + } + else + { + int min_dynabombs_left = pos + 1; + int min_inventory_size = pos + 1 - player->dynabombs_left; + int inventory_pos = pos - player->dynabombs_left; - SetAudioMode(setup.sound); - InitJoysticks(); + return (player->inventory_infinite_element != EL_UNDEFINED ? + player->inventory_infinite_element : + player->dynabombs_left >= min_dynabombs_left ? + EL_DYNABOMB_PLAYER_1 + player->index_nr : + player->inventory_size >= min_inventory_size ? + player->inventory_element[inventory_pos] : + EL_UNDEFINED); + } } -static int getBeltNrFromBeltElement(int element) +static int compareGamePanelOrderInfo(const void *object1, const void *object2) { - return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 : - element < EL_CONVEYOR_BELT_3_LEFT ? 1 : - element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3); -} + const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1; + const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2; + int compare_result; -static int getBeltNrFromBeltActiveElement(int element) -{ - return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 : - element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 : - element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3); -} + if (gpo1->sort_priority != gpo2->sort_priority) + compare_result = gpo1->sort_priority - gpo2->sort_priority; + else + compare_result = gpo1->nr - gpo2->nr; -static int getBeltNrFromBeltSwitchElement(int element) -{ - return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 : - element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 : - element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3); + return compare_result; } -static int getBeltDirNrFromBeltSwitchElement(int element) +void InitGameControlValues() { - static int belt_base_element[4] = + int i; + + for (i = 0; game_panel_controls[i].nr != -1; i++) { - EL_CONVEYOR_BELT_1_SWITCH_LEFT, - EL_CONVEYOR_BELT_2_SWITCH_LEFT, - EL_CONVEYOR_BELT_3_SWITCH_LEFT, - EL_CONVEYOR_BELT_4_SWITCH_LEFT - }; + struct GamePanelControlInfo *gpc = &game_panel_controls[i]; + struct GamePanelOrderInfo *gpo = &game_panel_order[i]; + struct TextPosInfo *pos = gpc->pos; + int nr = gpc->nr; + int type = gpc->type; - int belt_nr = getBeltNrFromBeltSwitchElement(element); - int belt_dir_nr = element - belt_base_element[belt_nr]; + if (nr != i) + { + Error(ERR_INFO, "'game_panel_controls' structure corrupted at %d", i); + Error(ERR_EXIT, "this should not happen -- please debug"); + } - return (belt_dir_nr % 3); -} + /* force update of game controls after initialization */ + gpc->value = gpc->last_value = -1; + gpc->frame = gpc->last_frame = -1; + gpc->gfx_frame = -1; -static int getBeltDirFromBeltSwitchElement(int element) -{ - static int belt_move_dir[3] = - { - MV_LEFT, - MV_NONE, - MV_RIGHT - }; + /* determine panel value width for later calculation of alignment */ + if (type == TYPE_INTEGER || type == TYPE_STRING) + { + pos->width = pos->size * getFontWidth(pos->font); + pos->height = getFontHeight(pos->font); + } + else if (type == TYPE_ELEMENT) + { + pos->width = pos->size; + pos->height = pos->size; + } - int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element); + /* fill structure for game panel draw order */ + gpo->nr = gpc->nr; + gpo->sort_priority = pos->sort_priority; + } - return belt_move_dir[belt_dir_nr]; + /* sort game panel controls according to sort_priority and control number */ + qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS, + sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo); } -static int get_element_from_group_element(int element) +void UpdatePlayfieldElementCount() { - if (IS_GROUP_ELEMENT(element)) - { - struct ElementGroupInfo *group = element_info[element].group; - int last_anim_random_frame = gfx.anim_random_frame; - int element_pos; - - if (group->choice_mode == ANIM_RANDOM) - gfx.anim_random_frame = RND(group->num_elements_resolved); + boolean use_element_count = FALSE; + int i, j, x, y; - element_pos = getAnimationFrame(group->num_elements_resolved, 1, - group->choice_mode, 0, - group->choice_pos); + /* first check if it is needed at all to calculate playfield element count */ + for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++) + if (!PANEL_DEACTIVATED(game_panel_controls[i].pos)) + use_element_count = TRUE; - if (group->choice_mode == ANIM_RANDOM) - gfx.anim_random_frame = last_anim_random_frame; + if (!use_element_count) + return; - group->choice_pos++; + for (i = 0; i < MAX_NUM_ELEMENTS; i++) + element_info[i].element_count = 0; - element = group->element_resolved[element_pos]; + SCAN_PLAYFIELD(x, y) + { + element_info[Feld[x][y]].element_count++; } - return element; + for (i = 0; i < NUM_GROUP_ELEMENTS; i++) + for (j = 0; j < MAX_NUM_ELEMENTS; j++) + if (IS_IN_GROUP(j, i)) + element_info[EL_GROUP_START + i].element_count += + element_info[j].element_count; } -static void InitPlayerField(int x, int y, int element, boolean init_game) +void UpdateGameControlValues() { - if (element == EL_SP_MURPHY) + int i, k; + int time = (local_player->LevelSolved ? + local_player->LevelSolved_CountingTime : + level.game_engine_type == GAME_ENGINE_TYPE_EM ? + level.native_em_level->lev->time : + level.time == 0 ? TimePlayed : TimeLeft); + int score = (local_player->LevelSolved ? + local_player->LevelSolved_CountingScore : + level.game_engine_type == GAME_ENGINE_TYPE_EM ? + level.native_em_level->lev->score : + local_player->score); + int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ? + level.native_em_level->lev->required : + local_player->gems_still_needed); + int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ? + level.native_em_level->lev->required > 0 : + local_player->gems_still_needed > 0 || + local_player->sokobanfields_still_needed > 0 || + local_player->lights_still_needed > 0); + + UpdatePlayfieldElementCount(); + + /* update game panel control values */ + + game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = level_nr; + game_panel_controls[GAME_PANEL_GEMS].value = gems; + + game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0; + for (i = 0; i < MAX_NUM_KEYS; i++) + game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY; + game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY; + game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0; + + if (game.centered_player_nr == -1) { - if (init_game) + for (i = 0; i < MAX_PLAYERS; i++) { - if (stored_player[0].present) + for (k = 0; k < MAX_NUM_KEYS; k++) { - Feld[x][y] = EL_SP_MURPHY_CLONE; - - return; + if (level.game_engine_type == GAME_ENGINE_TYPE_EM) + { + if (level.native_em_level->ply[i]->keys & (1 << k)) + game_panel_controls[GAME_PANEL_KEY_1 + k].value = + get_key_element_from_nr(k); + } + else if (stored_player[i].key[k]) + game_panel_controls[GAME_PANEL_KEY_1 + k].value = + get_key_element_from_nr(k); } + + if (level.game_engine_type == GAME_ENGINE_TYPE_EM) + game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value += + level.native_em_level->ply[i]->dynamite; else - { - stored_player[0].use_murphy = TRUE; + game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value += + stored_player[i].inventory_size; - if (!level.use_artwork_element[0]) - stored_player[0].artwork_element = EL_SP_MURPHY; - } + if (stored_player[i].num_white_keys > 0) + game_panel_controls[GAME_PANEL_KEY_WHITE].value = + EL_DC_KEY_WHITE; - Feld[x][y] = EL_PLAYER_1; + game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value += + stored_player[i].num_white_keys; } } + else + { + int player_nr = game.centered_player_nr; - if (init_game) + for (k = 0; k < MAX_NUM_KEYS; k++) + { + if (level.game_engine_type == GAME_ENGINE_TYPE_EM) + { + if (level.native_em_level->ply[player_nr]->keys & (1 << k)) + game_panel_controls[GAME_PANEL_KEY_1 + k].value = + get_key_element_from_nr(k); + } + else if (stored_player[player_nr].key[k]) + game_panel_controls[GAME_PANEL_KEY_1 + k].value = + get_key_element_from_nr(k); + } + + if (level.game_engine_type == GAME_ENGINE_TYPE_EM) + game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value += + level.native_em_level->ply[player_nr]->dynamite; + else + game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value += + stored_player[player_nr].inventory_size; + + if (stored_player[player_nr].num_white_keys > 0) + game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE; + + game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value += + stored_player[player_nr].num_white_keys; + } + + for (i = 0; i < NUM_PANEL_INVENTORY; i++) { - struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_PLAYER_1]; - int jx = player->jx, jy = player->jy; + game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value = + get_inventory_element_from_pos(local_player, i); + game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value = + get_inventory_element_from_pos(local_player, -i - 1); + } - player->present = TRUE; + game_panel_controls[GAME_PANEL_SCORE].value = score; + game_panel_controls[GAME_PANEL_HIGHSCORE].value = highscore[0].Score; - player->block_last_field = (element == EL_SP_MURPHY ? - level.sp_block_last_field : - level.block_last_field); + game_panel_controls[GAME_PANEL_TIME].value = time; - /* ---------- initialize player's last field block delay --------------- */ + game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600; + game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60; + game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60; - /* always start with reliable default value (no adjustment needed) */ - player->block_delay_adjustment = 0; + game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value = + (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE : + EL_EMPTY); + game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value = + local_player->shield_normal_time_left; + game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value = + (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE : + EL_EMPTY); + game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value = + local_player->shield_deadly_time_left; + + game_panel_controls[GAME_PANEL_EXIT].value = + (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN); + + game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value = + (game.ball_state ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL); + game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value = + (game.ball_state ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE : + EL_EMC_MAGIC_BALL_SWITCH); + + game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value = + (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH); + game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value = + game.light_time_left; + + game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value = + (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED); + game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value = + game.timegate_time_left; + + game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value = + EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos; + + game_panel_controls[GAME_PANEL_EMC_LENSES].value = + (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY); + game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value = + game.lenses_time_left; + + game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value = + (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY); + game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value = + game.magnify_time_left; + + game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value = + (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT : + game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT : + game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP : + game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN : + EL_BALLOON_SWITCH_NONE); + + game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value = + local_player->dynabomb_count; + game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value = + local_player->dynabomb_size; + game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value = + (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY); + + game_panel_controls[GAME_PANEL_PENGUINS].value = + local_player->friends_still_needed; + + game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value = + local_player->sokobanfields_still_needed; + game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value = + local_player->sokobanfields_still_needed; + + game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value = + (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL); - /* special case 1: in Supaplex, Murphy blocks last field one more frame */ - if (player->block_last_field && element == EL_SP_MURPHY) - player->block_delay_adjustment = 1; + for (i = 0; i < NUM_BELTS; i++) + { + game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value = + (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE : + EL_CONVEYOR_BELT_1_MIDDLE) + i; + game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value = + getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]); + } - /* special case 2: in game engines before 3.1.1, blocking was different */ - if (game.use_block_last_field_bug) - player->block_delay_adjustment = (player->block_last_field ? -1 : 1); + game_panel_controls[GAME_PANEL_MAGIC_WALL].value = + (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL); + game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value = + game.magic_wall_time_left; - if (!options.network || player->connected) - { - player->active = TRUE; +#if USE_PLAYER_GRAVITY + game_panel_controls[GAME_PANEL_GRAVITY_STATE].value = + local_player->gravity; +#else + game_panel_controls[GAME_PANEL_GRAVITY_STATE].value = game.gravity; +#endif - /* remove potentially duplicate players */ - if (StorePlayer[jx][jy] == Feld[x][y]) - StorePlayer[jx][jy] = 0; + for (i = 0; i < NUM_PANEL_GRAPHICS; i++) + game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i; - StorePlayer[x][y] = Feld[x][y]; + for (i = 0; i < NUM_PANEL_ELEMENTS; i++) + game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value = + (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ? + game.panel.element[i].id : EL_UNDEFINED); - if (options.debug) + for (i = 0; i < NUM_PANEL_ELEMENTS; i++) + game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value = + (IS_VALID_ELEMENT(game.panel.element_count[i].id) ? + element_info[game.panel.element_count[i].id].element_count : 0); + + for (i = 0; i < NUM_PANEL_CE_SCORE; i++) + game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value = + (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ? + element_info[game.panel.ce_score[i].id].collect_score : 0); + + for (i = 0; i < NUM_PANEL_CE_SCORE; i++) + game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value = + (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ? + element_info[game.panel.ce_score_element[i].id].collect_score : + EL_UNDEFINED); + + game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0; + game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0; + game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0; + + /* update game panel control frames */ + + for (i = 0; game_panel_controls[i].nr != -1; i++) + { + struct GamePanelControlInfo *gpc = &game_panel_controls[i]; + + if (gpc->type == TYPE_ELEMENT) + { + if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY) { - printf("Player %d activated.\n", player->element_nr); - printf("[Local player is %d and currently %s.]\n", - local_player->element_nr, - local_player->active ? "active" : "not active"); - } - } + int last_anim_random_frame = gfx.anim_random_frame; + int element = gpc->value; + int graphic = el2panelimg(element); - Feld[x][y] = EL_EMPTY; + if (gpc->value != gpc->last_value) + { + gpc->gfx_frame = 0; + gpc->gfx_random = INIT_GFX_RANDOM(); + } + else + { + gpc->gfx_frame++; - player->jx = player->last_jx = x; - player->jy = player->last_jy = y; + if (ANIM_MODE(graphic) == ANIM_RANDOM && + IS_NEXT_FRAME(gpc->gfx_frame, graphic)) + gpc->gfx_random = INIT_GFX_RANDOM(); + } + + if (ANIM_MODE(graphic) == ANIM_RANDOM) + gfx.anim_random_frame = gpc->gfx_random; + + if (ANIM_MODE(graphic) == ANIM_CE_SCORE) + gpc->gfx_frame = element_info[element].collect_score; + + gpc->frame = getGraphicAnimationFrame(el2panelimg(gpc->value), + gpc->gfx_frame); + + if (ANIM_MODE(graphic) == ANIM_RANDOM) + gfx.anim_random_frame = last_anim_random_frame; + } + } } } -static void InitField(int x, int y, boolean init_game) +void DisplayGameControlValues() { - int element = Feld[x][y]; + boolean redraw_panel = FALSE; + int i; - switch (element) + for (i = 0; game_panel_controls[i].nr != -1; i++) { - case EL_SP_MURPHY: - case EL_PLAYER_1: - case EL_PLAYER_2: - case EL_PLAYER_3: - case EL_PLAYER_4: - InitPlayerField(x, y, element, init_game); - break; + struct GamePanelControlInfo *gpc = &game_panel_controls[i]; - case EL_SOKOBAN_FIELD_PLAYER: - element = Feld[x][y] = EL_PLAYER_1; - InitField(x, y, init_game); + if (PANEL_DEACTIVATED(gpc->pos)) + continue; - element = Feld[x][y] = EL_SOKOBAN_FIELD_EMPTY; - InitField(x, y, init_game); - break; + if (gpc->value == gpc->last_value && + gpc->frame == gpc->last_frame) + continue; - case EL_SOKOBAN_FIELD_EMPTY: - local_player->sokobanfields_still_needed++; - break; + redraw_panel = TRUE; + } - case EL_STONEBLOCK: - if (x < lev_fieldx-1 && Feld[x+1][y] == EL_ACID) - Feld[x][y] = EL_ACID_POOL_TOPLEFT; - else if (x > 0 && Feld[x-1][y] == EL_ACID) - Feld[x][y] = EL_ACID_POOL_TOPRIGHT; - else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPLEFT) - Feld[x][y] = EL_ACID_POOL_BOTTOMLEFT; - else if (y > 0 && Feld[x][y-1] == EL_ACID) - Feld[x][y] = EL_ACID_POOL_BOTTOM; - else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPRIGHT) - Feld[x][y] = EL_ACID_POOL_BOTTOMRIGHT; - break; + if (!redraw_panel) + return; - case EL_BUG: - case EL_BUG_RIGHT: - case EL_BUG_UP: - case EL_BUG_LEFT: - case EL_BUG_DOWN: - case EL_SPACESHIP: - case EL_SPACESHIP_RIGHT: - case EL_SPACESHIP_UP: - case EL_SPACESHIP_LEFT: - case EL_SPACESHIP_DOWN: - case EL_BD_BUTTERFLY: - case EL_BD_BUTTERFLY_RIGHT: - case EL_BD_BUTTERFLY_UP: - case EL_BD_BUTTERFLY_LEFT: - case EL_BD_BUTTERFLY_DOWN: - case EL_BD_FIREFLY: - case EL_BD_FIREFLY_RIGHT: - case EL_BD_FIREFLY_UP: - case EL_BD_FIREFLY_LEFT: - case EL_BD_FIREFLY_DOWN: - case EL_PACMAN_RIGHT: - case EL_PACMAN_UP: - case EL_PACMAN_LEFT: - case EL_PACMAN_DOWN: - case EL_YAMYAM: - case EL_YAMYAM_LEFT: - case EL_YAMYAM_RIGHT: - case EL_YAMYAM_UP: - case EL_YAMYAM_DOWN: - case EL_DARK_YAMYAM: - case EL_ROBOT: - case EL_PACMAN: - case EL_SP_SNIKSNAK: - case EL_SP_ELECTRON: - case EL_MOLE: - case EL_MOLE_LEFT: - case EL_MOLE_RIGHT: - case EL_MOLE_UP: - case EL_MOLE_DOWN: - InitMovDir(x, y); - break; + /* copy default game door content to main double buffer */ + BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto, + DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY); - case EL_AMOEBA_FULL: - case EL_BD_AMOEBA: - InitAmoebaNr(x, y); - break; + /* redraw game control buttons */ +#if 1 + RedrawGameButtons(); +#else + UnmapGameButtons(); + MapGameButtons(); +#endif - case EL_AMOEBA_DROP: - if (y == lev_fieldy - 1) + game_status = GAME_MODE_PSEUDO_PANEL; + +#if 1 + for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++) +#else + for (i = 0; game_panel_controls[i].nr != -1; i++) +#endif + { +#if 1 + int nr = game_panel_order[i].nr; + struct GamePanelControlInfo *gpc = &game_panel_controls[nr]; +#else + struct GamePanelControlInfo *gpc = &game_panel_controls[i]; + int nr = gpc->nr; +#endif + struct TextPosInfo *pos = gpc->pos; + int type = gpc->type; + int value = gpc->value; + int frame = gpc->frame; +#if 0 + int last_value = gpc->last_value; + int last_frame = gpc->last_frame; +#endif + int size = pos->size; + int font = pos->font; + boolean draw_masked = pos->draw_masked; + int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE); + + if (PANEL_DEACTIVATED(pos)) + continue; + +#if 0 + if (value == last_value && frame == last_frame) + continue; +#endif + + gpc->last_value = value; + gpc->last_frame = frame; + +#if 0 + printf("::: value %d changed from %d to %d\n", nr, last_value, value); +#endif + + if (type == TYPE_INTEGER) + { + if (nr == GAME_PANEL_LEVEL_NUMBER || + nr == GAME_PANEL_TIME) { - Feld[x][y] = EL_AMOEBA_GROWING; - Store[x][y] = EL_AMOEBA_WET; - } - break; + boolean use_dynamic_size = (size == -1 ? TRUE : FALSE); - case EL_DYNAMITE_ACTIVE: - case EL_SP_DISK_RED_ACTIVE: - case EL_DYNABOMB_PLAYER_1_ACTIVE: - case EL_DYNABOMB_PLAYER_2_ACTIVE: - case EL_DYNABOMB_PLAYER_3_ACTIVE: - case EL_DYNABOMB_PLAYER_4_ACTIVE: - MovDelay[x][y] = 96; - break; + if (use_dynamic_size) /* use dynamic number of digits */ + { + int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000); + int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3); + int size2 = size1 + 1; + int font1 = pos->font; + int font2 = pos->font_alt; - case EL_EM_DYNAMITE_ACTIVE: - MovDelay[x][y] = 32; - break; + size = (value < value_change ? size1 : size2); + font = (value < value_change ? font1 : font2); - case EL_LAMP: - local_player->lights_still_needed++; - break; +#if 0 + /* clear background if value just changed its size (dynamic digits) */ + if ((last_value < value_change) != (value < value_change)) + { + int width1 = size1 * getFontWidth(font1); + int width2 = size2 * getFontWidth(font2); + int max_width = MAX(width1, width2); + int max_height = MAX(getFontHeight(font1), getFontHeight(font2)); - case EL_PENGUIN: - local_player->friends_still_needed++; - break; + pos->width = max_width; - case EL_PIG: - case EL_DRAGON: - GfxDir[x][y] = MovDir[x][y] = 1 << RND(4); - break; + ClearRectangleOnBackground(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos), + max_width, max_height); + } +#endif + } + } - 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_2_SWITCH_LEFT: - case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE: - case EL_CONVEYOR_BELT_2_SWITCH_RIGHT: - case EL_CONVEYOR_BELT_3_SWITCH_LEFT: - case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE: - case EL_CONVEYOR_BELT_3_SWITCH_RIGHT: - case EL_CONVEYOR_BELT_4_SWITCH_LEFT: - case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE: - case EL_CONVEYOR_BELT_4_SWITCH_RIGHT: - if (init_game) +#if 1 + /* correct text size if "digits" is zero or less */ + if (size <= 0) + size = strlen(int2str(value, size)); + + /* dynamically correct text alignment */ + pos->width = size * getFontWidth(font); +#endif + + DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos), + int2str(value, size), font, mask_mode); + } + else if (type == TYPE_ELEMENT) + { + int element, graphic; + Bitmap *src_bitmap; + int src_x, src_y; + int width, height; + int dst_x = PANEL_XPOS(pos); + int dst_y = PANEL_YPOS(pos); + +#if 1 + if (value != EL_UNDEFINED && value != EL_EMPTY) { - int belt_nr = getBeltNrFromBeltSwitchElement(Feld[x][y]); - int belt_dir = getBeltDirFromBeltSwitchElement(Feld[x][y]); - int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Feld[x][y]); + element = value; + graphic = el2panelimg(value); - if (game.belt_dir_nr[belt_nr] == 3) /* initial value */ + // printf("::: %d, '%s' [%d]\n", element, EL_NAME(element), size); + +#if 1 + if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0) + size = TILESIZE; +#endif + + getSizedGraphicSource(graphic, frame, size, &src_bitmap, + &src_x, &src_y); + + width = graphic_info[graphic].width * size / TILESIZE; + height = graphic_info[graphic].height * size / TILESIZE; + + if (draw_masked) { - game.belt_dir[belt_nr] = belt_dir; - game.belt_dir_nr[belt_nr] = belt_dir_nr; + SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc, + dst_x - src_x, dst_y - src_y); + BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height, + dst_x, dst_y); } - else /* more than one switch -- set it like the first switch */ + else { - Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr]; + BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height, + dst_x, dst_y); } } - break; - -#if !USE_BOTH_SWITCHGATE_SWITCHES - case EL_SWITCHGATE_SWITCH_DOWN: /* always start with same switch pos */ - if (init_game) - Feld[x][y] = EL_SWITCHGATE_SWITCH_UP; - break; -#endif +#else + if (value == EL_UNDEFINED || value == EL_EMPTY) + { + element = (last_value == EL_UNDEFINED ? EL_EMPTY : last_value); + graphic = el2panelimg(element); - case EL_LIGHT_SWITCH_ACTIVE: - if (init_game) - game.light_time_left = level.time_light * FRAMES_PER_SECOND; - break; + src_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap; + src_x = DOOR_GFX_PAGEX5 + ALIGNED_TEXT_XPOS(pos); + src_y = DOOR_GFX_PAGEY1 + ALIGNED_TEXT_YPOS(pos); + } + else + { + element = value; + graphic = el2panelimg(value); - case EL_INVISIBLE_STEELWALL: - case EL_INVISIBLE_WALL: - case EL_INVISIBLE_SAND: - if (game.light_time_left > 0 || - game.lenses_time_left > 0) - Feld[x][y] = getInvisibleActiveFromInvisibleElement(element); - break; + getSizedGraphicSource(graphic, frame, size, &src_bitmap, &src_x,&src_y); + } - case EL_EMC_MAGIC_BALL: - if (game.ball_state) - Feld[x][y] = EL_EMC_MAGIC_BALL_ACTIVE; - break; + width = graphic_info[graphic].width * size / TILESIZE; + height = graphic_info[graphic].height * size / TILESIZE; - case EL_EMC_MAGIC_BALL_SWITCH: - if (game.ball_state) - Feld[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE; - break; + BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height, dst_x, dst_y); +#endif + } + else if (type == TYPE_STRING) + { + boolean active = (value != 0); + char *state_normal = "off"; + char *state_active = "on"; + char *state = (active ? state_active : state_normal); + char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state : + nr == GAME_PANEL_PLAYER_NAME ? setup.player_name : + nr == GAME_PANEL_LEVEL_NAME ? level.name : + nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL); - default: -#if 1 - if (IS_CUSTOM_ELEMENT(element)) + if (nr == GAME_PANEL_GRAVITY_STATE) { - if (CAN_MOVE(element)) - InitMovDir(x, y); + int font1 = pos->font; /* (used for normal state) */ + int font2 = pos->font_alt; /* (used for active state) */ +#if 0 + int size1 = strlen(state_normal); + int size2 = strlen(state_active); + int width1 = size1 * getFontWidth(font1); + int width2 = size2 * getFontWidth(font2); + int max_width = MAX(width1, width2); + int max_height = MAX(getFontHeight(font1), getFontHeight(font2)); -#if USE_NEW_CUSTOM_VALUE - if (!element_info[element].use_last_ce_value || init_game) - CustomValue[x][y] = GET_NEW_CE_VALUE(Feld[x][y]); + pos->width = max_width; + + /* clear background for values that may have changed its size */ + ClearRectangleOnBackground(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos), + max_width, max_height); #endif + + font = (active ? font2 : font1); } -#else - if (IS_CUSTOM_ELEMENT(element) && CAN_MOVE(element)) - InitMovDir(x, y); -#endif - else if (IS_GROUP_ELEMENT(element)) + + if (s != NULL) { + char *s_cut; + #if 1 - Feld[x][y] = get_element_from_group_element(element); + if (size <= 0) + { + /* don't truncate output if "chars" is zero or less */ + size = strlen(s); - InitField(x, y, init_game); -#else - struct ElementGroupInfo *group = element_info[element].group; - int last_anim_random_frame = gfx.anim_random_frame; - int element_pos; + /* dynamically correct text alignment */ + pos->width = size * getFontWidth(font); + } +#endif - if (group->choice_mode == ANIM_RANDOM) - gfx.anim_random_frame = RND(group->num_elements_resolved); + s_cut = getStringCopyN(s, size); - element_pos = getAnimationFrame(group->num_elements_resolved, 1, - group->choice_mode, 0, - group->choice_pos); + DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos), + s_cut, font, mask_mode); - if (group->choice_mode == ANIM_RANDOM) - gfx.anim_random_frame = last_anim_random_frame; + free(s_cut); + } + } - group->choice_pos++; + redraw_mask |= REDRAW_DOOR_1; + } - Feld[x][y] = group->element_resolved[element_pos]; + game_status = GAME_MODE_PLAYING; +} - InitField(x, y, init_game); -#endif - } +void UpdateAndDisplayGameControlValues() +{ + if (tape.warp_forward) + return; - break; - } + UpdateGameControlValues(); + DisplayGameControlValues(); +} +void DrawGameValue_Emeralds(int value) +{ + struct TextPosInfo *pos = &game.panel.gems; #if 1 - if (!init_game) - CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X); + int font_nr = pos->font; +#else + int font_nr = FONT_TEXT_2; #endif + int font_width = getFontWidth(font_nr); + int chars = pos->size; -#if 0 +#if 1 + return; /* !!! USE NEW STUFF !!! */ +#endif -#if USE_NEW_CUSTOM_VALUE + if (PANEL_DEACTIVATED(pos)) + return; + + pos->width = chars * font_width; + + DrawText(PANEL_XPOS(pos), PANEL_YPOS(pos), int2str(value, chars), font_nr); +} +void DrawGameValue_Dynamite(int value) +{ + struct TextPosInfo *pos = &game.panel.inventory_count; #if 1 - CustomValue[x][y] = GET_NEW_CE_VALUE(Feld[x][y]); + int font_nr = pos->font; #else - CustomValue[x][y] = element_info[Feld[x][y]].custom_value_initial; + int font_nr = FONT_TEXT_2; #endif + int font_width = getFontWidth(font_nr); + int chars = pos->size; +#if 1 + return; /* !!! USE NEW STUFF !!! */ #endif -#endif -} + if (PANEL_DEACTIVATED(pos)) + return; -static inline void InitField_WithBug1(int x, int y, boolean init_game) -{ - InitField(x, y, init_game); + pos->width = chars * font_width; - /* not needed to call InitMovDir() -- already done by InitField()! */ - if (game.engine_version < VERSION_IDENT(3,1,0,0) && - CAN_MOVE(Feld[x][y])) - InitMovDir(x, y); + DrawText(PANEL_XPOS(pos), PANEL_YPOS(pos), int2str(value, chars), font_nr); } -static inline void InitField_WithBug2(int x, int y, boolean init_game) +void DrawGameValue_Score(int value) { - int old_element = Feld[x][y]; + struct TextPosInfo *pos = &game.panel.score; +#if 1 + int font_nr = pos->font; +#else + int font_nr = FONT_TEXT_2; +#endif + int font_width = getFontWidth(font_nr); + int chars = pos->size; - InitField(x, y, init_game); +#if 1 + return; /* !!! USE NEW STUFF !!! */ +#endif - /* not needed to call InitMovDir() -- already done by InitField()! */ - 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); + if (PANEL_DEACTIVATED(pos)) + return; - /* this case is in fact a combination of not less than three bugs: - first, it calls InitMovDir() for elements that can move, although this is - already done by InitField(); then, it checks the element that was at this - field _before_ the call to InitField() (which can change it); lastly, it - was not called for "mole with direction" elements, which were treated as - "cannot move" due to (fixed) wrong element initialization in "src/init.c" - */ + pos->width = chars * font_width; + + DrawText(PANEL_XPOS(pos), PANEL_YPOS(pos), int2str(value, chars), font_nr); } -inline void DrawGameValue_Emeralds(int value) +void DrawGameValue_Time(int value) { - int xpos = (3 * 14 - 3 * getFontWidth(FONT_TEXT_2)) / 2; + struct TextPosInfo *pos = &game.panel.time; + static int last_value = -1; + int chars1 = 3; + int chars2 = 4; + int chars = pos->size; +#if 1 + int font1_nr = pos->font; + int font2_nr = pos->font_alt; +#else + int font1_nr = FONT_TEXT_2; + int font2_nr = FONT_TEXT_1; +#endif + int font_nr = font1_nr; + boolean use_dynamic_chars = (chars == -1 ? TRUE : FALSE); - if (PANEL_DEACTIVATED(game.panel.gems)) +#if 1 + return; /* !!! USE NEW STUFF !!! */ +#endif + + if (PANEL_DEACTIVATED(pos)) return; - DrawText(DX_EMERALDS + xpos, DY_EMERALDS, int2str(value, 3), FONT_TEXT_2); + if (use_dynamic_chars) /* use dynamic number of chars */ + { + chars = (value < 1000 ? chars1 : chars2); + font_nr = (value < 1000 ? font1_nr : font2_nr); + } + + /* clear background if value just changed its size (dynamic chars only) */ + if (use_dynamic_chars && (last_value < 1000) != (value < 1000)) + { + int width1 = chars1 * getFontWidth(font1_nr); + int width2 = chars2 * getFontWidth(font2_nr); + int max_width = MAX(width1, width2); + int max_height = MAX(getFontHeight(font1_nr), getFontHeight(font2_nr)); + + pos->width = max_width; + + ClearRectangleOnBackground(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos), + max_width, max_height); + } + + pos->width = chars * getFontWidth(font_nr); + + DrawText(PANEL_XPOS(pos), PANEL_YPOS(pos), int2str(value, chars), font_nr); + + last_value = value; } -inline void DrawGameValue_Dynamite(int value) +void DrawGameValue_Level(int value) { - int xpos = (3 * 14 - 3 * getFontWidth(FONT_TEXT_2)) / 2; + struct TextPosInfo *pos = &game.panel.level_number; + int chars1 = 2; + int chars2 = 3; + int chars = pos->size; +#if 1 + int font1_nr = pos->font; + int font2_nr = pos->font_alt; +#else + int font1_nr = FONT_TEXT_2; + int font2_nr = FONT_TEXT_1; +#endif + int font_nr = font1_nr; + boolean use_dynamic_chars = (chars == -1 ? TRUE : FALSE); + +#if 1 + return; /* !!! USE NEW STUFF !!! */ +#endif - if (PANEL_DEACTIVATED(game.panel.inventory)) + if (PANEL_DEACTIVATED(pos)) return; - DrawText(DX_DYNAMITE + xpos, DY_DYNAMITE, int2str(value, 3), FONT_TEXT_2); + if (use_dynamic_chars) /* use dynamic number of chars */ + { + chars = (level_nr < 100 ? chars1 : chars2); + font_nr = (level_nr < 100 ? font1_nr : font2_nr); + } + + pos->width = chars * getFontWidth(font_nr); + + DrawText(PANEL_XPOS(pos), PANEL_YPOS(pos), int2str(value, chars), font_nr); } -inline void DrawGameValue_Keys(int key[MAX_NUM_KEYS]) +void DrawGameValue_Keys(int key[MAX_NUM_KEYS]) { +#if 0 + struct TextPosInfo *pos = &game.panel.keys; +#endif +#if 0 int base_key_graphic = EL_KEY_1; +#endif int i; - if (PANEL_DEACTIVATED(game.panel.keys)) +#if 1 + return; /* !!! USE NEW STUFF !!! */ +#endif + +#if 0 + if (PANEL_DEACTIVATED(pos)) return; +#endif +#if 0 if (level.game_engine_type == GAME_ENGINE_TYPE_EM) base_key_graphic = EL_EM_KEY_1; +#endif + +#if 0 + pos->width = 4 * MINI_TILEX; +#endif +#if 1 + for (i = 0; i < MAX_NUM_KEYS; i++) +#else /* currently only 4 of 8 possible keys are displayed */ for (i = 0; i < STD_NUM_KEYS; i++) +#endif { - int x = XX_KEYS + i * MINI_TILEX; - int y = YY_KEYS; +#if 1 + struct TextPosInfo *pos = &game.panel.key[i]; +#endif + int src_x = DOOR_GFX_PAGEX5 + 18 + (i % 4) * MINI_TILEX; + int src_y = DOOR_GFX_PAGEY1 + 123; +#if 1 + int dst_x = PANEL_XPOS(pos); + int dst_y = PANEL_YPOS(pos); +#else + int dst_x = PANEL_XPOS(pos) + i * MINI_TILEX; + int dst_y = PANEL_YPOS(pos); +#endif + +#if 1 + int element = (i >= STD_NUM_KEYS ? EL_EMC_KEY_5 - 4 : + level.game_engine_type == GAME_ENGINE_TYPE_EM ? EL_EM_KEY_1 : + EL_KEY_1) + i; + int graphic = el2edimg(element); +#endif + +#if 1 + if (PANEL_DEACTIVATED(pos)) + continue; +#endif + +#if 0 + /* masked blit with tiles from half-size scaled bitmap does not work yet + (no mask bitmap created for these sizes after loading and scaling) -- + solution: load without creating mask, scale, then create final mask */ + + BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto, src_x, src_y, + MINI_TILEX, MINI_TILEY, dst_x, dst_y); if (key[i]) - DrawMiniGraphicExt(drawto, DX + x,DY + y, el2edimg(base_key_graphic + i)); + { +#if 0 + int graphic = el2edimg(base_key_graphic + i); +#endif + Bitmap *src_bitmap; + int src_x, src_y; + + getMiniGraphicSource(graphic, &src_bitmap, &src_x, &src_y); + + SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc, + dst_x - src_x, dst_y - src_y); + BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, MINI_TILEX, MINI_TILEY, + dst_x, dst_y); + } +#else +#if 1 + if (key[i]) + DrawMiniGraphicExt(drawto, dst_x, dst_y, graphic); else - BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto, - DOOR_GFX_PAGEX5 + x, y, MINI_TILEX, MINI_TILEY, DX + x,DY + y); + BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto, src_x, src_y, + MINI_TILEX, MINI_TILEY, dst_x, dst_y); +#else + if (key[i]) + DrawMiniGraphicExt(drawto, dst_x, dst_y, el2edimg(base_key_graphic + i)); + else + BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto, src_x, src_y, + MINI_TILEX, MINI_TILEY, dst_x, dst_y); +#endif +#endif } } -inline void DrawGameValue_Score(int value) +#else + +void DrawGameValue_Emeralds(int value) +{ + int font_nr = FONT_TEXT_2; + int xpos = (3 * 14 - 3 * getFontWidth(font_nr)) / 2; + + if (PANEL_DEACTIVATED(game.panel.gems)) + return; + + DrawText(DX_EMERALDS + xpos, DY_EMERALDS, int2str(value, 3), font_nr); +} + +void DrawGameValue_Dynamite(int value) +{ + int font_nr = FONT_TEXT_2; + int xpos = (3 * 14 - 3 * getFontWidth(font_nr)) / 2; + + if (PANEL_DEACTIVATED(game.panel.inventory_count)) + return; + + DrawText(DX_DYNAMITE + xpos, DY_DYNAMITE, int2str(value, 3), font_nr); +} + +void DrawGameValue_Score(int value) { - int xpos = (5 * 14 - 5 * getFontWidth(FONT_TEXT_2)) / 2; + int font_nr = FONT_TEXT_2; + int xpos = (5 * 14 - 5 * getFontWidth(font_nr)) / 2; if (PANEL_DEACTIVATED(game.panel.score)) return; - DrawText(DX_SCORE + xpos, DY_SCORE, int2str(value, 5), FONT_TEXT_2); + DrawText(DX_SCORE + xpos, DY_SCORE, int2str(value, 5), font_nr); } -inline void DrawGameValue_Time(int value) +void DrawGameValue_Time(int value) { - int xpos3 = (3 * 14 - 3 * getFontWidth(FONT_TEXT_2)) / 2; - int xpos4 = (4 * 10 - 4 * getFontWidth(FONT_LEVEL_NUMBER)) / 2; + int font1_nr = FONT_TEXT_2; +#if 1 + int font2_nr = FONT_TEXT_1; +#else + int font2_nr = FONT_LEVEL_NUMBER; +#endif + int xpos3 = (3 * 14 - 3 * getFontWidth(font1_nr)) / 2; + int xpos4 = (4 * 10 - 4 * getFontWidth(font2_nr)) / 2; if (PANEL_DEACTIVATED(game.panel.time)) return; @@ -1360,48 +3061,67 @@ inline void DrawGameValue_Time(int value) ClearRectangleOnBackground(drawto, DX_TIME1, DY_TIME, 14 * 3, 14); if (value < 1000) - DrawText(DX_TIME1 + xpos3, DY_TIME, int2str(value, 3), FONT_TEXT_2); + DrawText(DX_TIME1 + xpos3, DY_TIME, int2str(value, 3), font1_nr); else - DrawText(DX_TIME2 + xpos4, DY_TIME, int2str(value, 4), FONT_LEVEL_NUMBER); + DrawText(DX_TIME2 + xpos4, DY_TIME, int2str(value, 4), font2_nr); } -inline void DrawGameValue_Level(int value) +void DrawGameValue_Level(int value) { + int font1_nr = FONT_TEXT_2; +#if 1 + int font2_nr = FONT_TEXT_1; +#else + int font2_nr = FONT_LEVEL_NUMBER; +#endif + if (PANEL_DEACTIVATED(game.panel.level)) return; if (level_nr < 100) - DrawText(DX_LEVEL1, DY_LEVEL, int2str(value, 2), FONT_TEXT_2); + DrawText(DX_LEVEL1, DY_LEVEL, int2str(value, 2), font1_nr); else -#if 1 - DrawText(DX_LEVEL2, DY_LEVEL, int2str(value, 3), FONT_LEVEL_NUMBER); -#else - { - /* misuse area for displaying emeralds to draw bigger level number */ - DrawTextExt(drawto, DX_EMERALDS, DY_EMERALDS, - int2str(value, 3), FONT_LEVEL_NUMBER, BLIT_OPAQUE); + DrawText(DX_LEVEL2, DY_LEVEL, int2str(value, 3), font2_nr); +} + +void DrawGameValue_Keys(int key[MAX_NUM_KEYS]) +{ + int base_key_graphic = EL_KEY_1; + int i; + + if (PANEL_DEACTIVATED(game.panel.keys)) + return; - /* now copy it to the area for displaying level number */ - BlitBitmap(drawto, drawto, - DX_EMERALDS, DY_EMERALDS + 1, - getFontWidth(FONT_LEVEL_NUMBER) * 3, - getFontHeight(FONT_LEVEL_NUMBER) - 1, - DX_LEVEL - 1, DY_LEVEL + 1); + if (level.game_engine_type == GAME_ENGINE_TYPE_EM) + base_key_graphic = EL_EM_KEY_1; - /* restore the area for displaying emeralds */ - DrawGameValue_Emeralds(local_player->gems_still_needed); + /* currently only 4 of 8 possible keys are displayed */ + for (i = 0; i < STD_NUM_KEYS; i++) + { + int x = XX_KEYS + i * MINI_TILEX; + int y = YY_KEYS; - /* yes, this is all really ugly :-) */ + if (key[i]) + DrawMiniGraphicExt(drawto, DX + x,DY + y, el2edimg(base_key_graphic + i)); + else + BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto, + DOOR_GFX_PAGEX5 + x, y, MINI_TILEX, MINI_TILEY, DX + x,DY + y); } -#endif } +#endif + void DrawAllGameValues(int emeralds, int dynamite, int score, int time, int key_bits) { int key[MAX_NUM_KEYS]; int i; + /* prevent EM engine from updating time/score values parallel to GameWon() */ + if (level.game_engine_type == GAME_ENGINE_TYPE_EM && + local_player->LevelSolved) + return; + for (i = 0; i < MAX_NUM_KEYS; i++) key[i] = key_bits & (1 << i); @@ -1415,10 +3135,23 @@ void DrawAllGameValues(int emeralds, int dynamite, int score, int time, DrawGameValue_Keys(key); } +void UpdateGameDoorValues() +{ + UpdateGameControlValues(); +} + void DrawGameDoorValues() +{ + DisplayGameControlValues(); +} + +void DrawGameDoorValues_OLD() { int time_value = (level.time == 0 ? TimePlayed : TimeLeft); - int dynamite_state = 0; + int dynamite_value = 0; + int score_value = (local_player->LevelSolved ? local_player->score_final : + local_player->score); + int gems_value = local_player->gems_still_needed; int key_bits = 0; int i, j; @@ -1429,16 +3162,6 @@ void DrawGameDoorValues() return; } -#if 0 - DrawGameValue_Level(level_nr); - - DrawGameValue_Emeralds(local_player->gems_still_needed); - DrawGameValue_Dynamite(local_player->inventory_size); - DrawGameValue_Score(local_player->score); - DrawGameValue_Time(TimeLeft); - -#else - if (game.centered_player_nr == -1) { for (i = 0; i < MAX_PLAYERS; i++) @@ -1447,12 +3170,8 @@ void DrawGameDoorValues() if (stored_player[i].key[j]) key_bits |= (1 << j); - dynamite_state += stored_player[i].inventory_size; + dynamite_value += stored_player[i].inventory_size; } - -#if 0 - DrawGameValue_Keys(stored_player[i].key); -#endif } else { @@ -1462,71 +3181,13 @@ void DrawGameDoorValues() if (stored_player[player_nr].key[i]) key_bits |= (1 << i); - dynamite_state = stored_player[player_nr].inventory_size; - } - - DrawAllGameValues(local_player->gems_still_needed, dynamite_state, - local_player->score, time_value, key_bits); -#endif -} - -#if 0 -static void resolve_group_element(int group_element, int recursion_depth) -{ - static int group_nr; - static struct ElementGroupInfo *group; - struct ElementGroupInfo *actual_group = element_info[group_element].group; - int i; - - if (recursion_depth > NUM_GROUP_ELEMENTS) /* recursion too deep */ - { - Error(ERR_WARN, "recursion too deep when resolving group element %d", - group_element - EL_GROUP_START + 1); - - /* replace element which caused too deep recursion by question mark */ - group->element_resolved[group->num_elements_resolved++] = EL_UNKNOWN; - - return; - } - - if (recursion_depth == 0) /* initialization */ - { - group = element_info[group_element].group; - group_nr = group_element - EL_GROUP_START; - - group->num_elements_resolved = 0; - group->choice_pos = 0; + dynamite_value = stored_player[player_nr].inventory_size; } - for (i = 0; i < actual_group->num_elements; i++) - { - int element = actual_group->element[i]; - - if (group->num_elements_resolved == NUM_FILE_ELEMENTS) - break; - - if (IS_GROUP_ELEMENT(element)) - resolve_group_element(element, recursion_depth + 1); - else - { - group->element_resolved[group->num_elements_resolved++] = element; - element_info[element].in_group[group_nr] = TRUE; - } - } + DrawAllGameValues(gems_value, dynamite_value, score_value, time_value, + key_bits); } -#endif -#if 0 -static void replace_reference_element(int base_element, int *element) -{ - if (*element >= EL_LAST_CE_8 && *element <= EL_NEXT_CE_8) - { - *element = base_element + *element - EL_SELF; - *element = (*element < EL_CUSTOM_START ? EL_CUSTOM_START : - *element > EL_CUSTOM_END ? EL_CUSTOM_END : *element); - } -} -#endif /* ============================================================================= @@ -1658,29 +3319,12 @@ static void InitGameEngine() printf(" => game.engine_version == %06d\n", game.engine_version); #endif -#if 0 - /* ---------- recursively resolve group elements ------------------------- */ - - for (i = 0; i < MAX_NUM_ELEMENTS; i++) - for (j = 0; j < NUM_GROUP_ELEMENTS; j++) - element_info[i].in_group[j] = FALSE; - - for (i = 0; i < NUM_GROUP_ELEMENTS; i++) - resolve_group_element(EL_GROUP_START + i, 0); -#endif - /* ---------- initialize player's initial move delay --------------------- */ -#if 1 /* dynamically adjust player properties according to level information */ for (i = 0; i < MAX_PLAYERS; i++) game.initial_move_delay_value[i] = get_move_delay_from_stepsize(level.initial_player_stepsize[i]); -#else - /* dynamically adjust player properties according to level information */ - game.initial_move_delay_value = - (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED); -#endif /* dynamically adjust player properties according to game engine version */ for (i = 0; i < MAX_PLAYERS; i++) @@ -1743,7 +3387,7 @@ static void InitGameEngine() SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE); } - /* ---------- initialize internal run-time variables ------------- */ + /* ---------- initialize internal run-time variables --------------------- */ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++) { @@ -1781,6 +3425,27 @@ static void InitGameEngine() } } +#if 1 + /* ---------- initialize reference elements in change conditions --------- */ + + for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++) + { + int element = EL_CUSTOM_START + i; + struct ElementInfo *ei = &element_info[element]; + + for (j = 0; j < ei->num_change_pages; j++) + { + int trigger_element = ei->change_page[j].initial_trigger_element; + + if (trigger_element >= EL_PREV_CE_8 && + trigger_element <= EL_NEXT_CE_8) + trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element); + + ei->change_page[j].trigger_element = trigger_element; + } + } +#endif + /* ---------- initialize run-time trigger player and element ------------- */ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++) @@ -1790,7 +3455,8 @@ static void InitGameEngine() 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; + ei->change_page[j].actual_trigger_player = EL_EMPTY; + ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE; ei->change_page[j].actual_trigger_side = CH_SIDE_NONE; ei->change_page[j].actual_trigger_ce_value = 0; ei->change_page[j].actual_trigger_ce_score = 0; @@ -1830,11 +3496,9 @@ static void InitGameEngine() for (l = 0; l < group->num_elements_resolved; l++) trigger_events[group->element_resolved[l]][k] = TRUE; } -#if 1 else if (trigger_element == EL_ANY_ELEMENT) for (l = 0; l < MAX_NUM_ELEMENTS; l++) trigger_events[l][k] = TRUE; -#endif else trigger_events[trigger_element][k] = TRUE; } @@ -1850,7 +3514,6 @@ static void InitGameEngine() { if (!IS_CUSTOM_ELEMENT(i)) { -#if 1 /* set default push delay values (corrected since version 3.0.7-1) */ if (game.engine_version < VERSION_IDENT(3,0,7,1)) { @@ -1862,10 +3525,6 @@ static void InitGameEngine() element_info[i].push_delay_fixed = 8; element_info[i].push_delay_random = 8; } -#else - element_info[i].push_delay_fixed = game.default_push_delay_fixed; - element_info[i].push_delay_random = game.default_push_delay_random; -#endif } } @@ -1973,28 +3632,17 @@ static void InitGameEngine() } } -#if 0 - /* ---------- initialize reference elements ------------------------------- */ - for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++) - { - int element = EL_CUSTOM_START + i; - struct ElementInfo *ei = &element_info[element]; - - for (y = 0; y < 3; y++) for (x = 0; x < 3; x++) - replace_reference_element(element, &ei->content.e[x][y]); - - for (j = 0; j < ei->num_change_pages; j++) - { - struct ElementChangeInfo *change = &ei->change_page[j]; + /* ---------- initialize recursion detection ------------------------------ */ + recursion_loop_depth = 0; + recursion_loop_detected = FALSE; + recursion_loop_element = EL_UNDEFINED; - replace_reference_element(element, &change->target_element); - replace_reference_element(element, &change->trigger_element); - - for (y = 0; y < 3; y++) for (x = 0; x < 3; x++) - replace_reference_element(element, &change->target_content.e[x][y]); - } - } -#endif + /* ---------- initialize graphics engine ---------------------------------- */ + game.scroll_delay_value = + (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value : + setup.scroll_delay ? setup.scroll_delay_value : 0); + game.scroll_delay_value = + MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY); } int get_num_special_action(int element, int action_first, int action_last) @@ -2017,13 +3665,10 @@ int get_num_special_action(int element, int action_first, int action_last) break; } -#if 0 - printf("::: %d->%d: %d\n", action_first, action_last, num_special_action); -#endif - return num_special_action; } + /* ============================================================================= InitGame() @@ -2037,12 +3682,20 @@ void InitGame() boolean emulate_bd = TRUE; /* unless non-BOULDERDASH elements found */ boolean emulate_sb = TRUE; /* unless non-SOKOBAN elements found */ boolean emulate_sp = TRUE; /* unless non-SUPAPLEX elements found */ +#if 0 boolean do_fading = (game_status == GAME_MODE_MAIN); +#endif +#if 1 + int initial_move_dir = MV_DOWN; +#else + int initial_move_dir = MV_NONE; +#endif int i, j, x, y; game_status = GAME_MODE_PLAYING; InitGameEngine(); + InitGameControlValues(); /* don't play tapes over network */ network_playing = (options.network && !tape.playing); @@ -2057,12 +3710,18 @@ void InitGame() player->present = FALSE; player->active = FALSE; + player->mapped = FALSE; + + player->killed = FALSE; + player->reanimated = FALSE; player->action = 0; player->effective_action = 0; player->programmed_action = 0; player->score = 0; + player->score_final = 0; + player->gems_still_needed = level.gems_needed; player->sokobanfields_still_needed = 0; player->lights_still_needed = 0; @@ -2071,23 +3730,26 @@ void InitGame() for (j = 0; j < MAX_NUM_KEYS; j++) player->key[j] = FALSE; + player->num_white_keys = 0; + player->dynabomb_count = 0; player->dynabomb_size = 1; player->dynabombs_left = 0; player->dynabomb_xl = FALSE; - player->MovDir = MV_NONE; + player->MovDir = initial_move_dir; player->MovPos = 0; player->GfxPos = 0; - player->GfxDir = MV_NONE; + player->GfxDir = initial_move_dir; player->GfxAction = ACTION_DEFAULT; player->Frame = 0; player->StepFrame = 0; - player->use_murphy = FALSE; + player->initial_element = player->element_nr; player->artwork_element = (level.use_artwork_element[i] ? level.artwork_element[i] : player->element_nr); + player->use_murphy = FALSE; player->block_last_field = FALSE; /* initialized in InitPlayerField() */ player->block_delay_adjustment = 0; /* initialized in InitPlayerField() */ @@ -2100,7 +3762,7 @@ void InitGame() player->step_counter = 0; - player->last_move_dir = MV_NONE; + player->last_move_dir = initial_move_dir; player->is_active = FALSE; @@ -2124,24 +3786,12 @@ void InitGame() player->anim_delay_counter = 0; player->post_delay_counter = 0; - player->dir_waiting = MV_NONE; + player->dir_waiting = initial_move_dir; player->action_waiting = ACTION_DEFAULT; player->last_action_waiting = ACTION_DEFAULT; player->special_action_bored = ACTION_DEFAULT; player->special_action_sleeping = ACTION_DEFAULT; -#if 1 - /* cannot be set here -- could be modified in Init[Player]Field() below */ -#else - /* set number of special actions for bored and sleeping animation */ - player->num_special_action_bored = - get_num_special_action(player->artwork_element, - ACTION_BORING_1, ACTION_BORING_LAST); - player->num_special_action_sleeping = - get_num_special_action(player->artwork_element, - ACTION_SLEEPING_1, ACTION_SLEEPING_LAST); -#endif - player->switch_x = -1; player->switch_y = -1; @@ -2150,18 +3800,7 @@ void InitGame() player->show_envelope = 0; -#if 1 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE); -#else - player->move_delay = game.initial_move_delay; - player->move_delay_value = game.initial_move_delay_value; - - player->move_delay_value_next = -1; - - player->move_delay_reset_counter = 0; - - player->cannot_move = FALSE; -#endif player->push_delay = -1; /* initialized when pushing starts */ player->push_delay_value = game.initial_push_delay_value; @@ -2169,8 +3808,10 @@ void InitGame() player->drop_delay = 0; player->drop_pressed_delay = 0; - player->last_jx = player->last_jy = 0; - player->jx = player->jy = 0; + player->last_jx = -1; + player->last_jy = -1; + player->jx = -1; + player->jy = -1; player->shield_normal_time_left = 0; player->shield_deadly_time_left = 0; @@ -2178,15 +3819,41 @@ void InitGame() player->inventory_infinite_element = EL_UNDEFINED; player->inventory_size = 0; + if (level.use_initial_inventory[i]) + { + for (j = 0; j < level.initial_inventory_size[i]; j++) + { + int element = level.initial_inventory_content[i][j]; + int collect_count = element_info[element].collect_count_initial; + int k; + + if (!IS_CUSTOM_ELEMENT(element)) + collect_count = 1; + + if (collect_count == 0) + player->inventory_infinite_element = element; + else + for (k = 0; k < collect_count; k++) + if (player->inventory_size < MAX_INVENTORY_SIZE) + player->inventory_element[player->inventory_size++] = element; + } + } + DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH); SnapField(player, 0, 0); player->LevelSolved = FALSE; player->GameOver = FALSE; + player->LevelSolved_GameWon = FALSE; player->LevelSolved_GameEnd = FALSE; + player->LevelSolved_PanelOff = FALSE; player->LevelSolved_SaveTape = FALSE; player->LevelSolved_SaveScore = FALSE; + player->LevelSolved_CountingTime = 0; + player->LevelSolved_CountingScore = 0; + + map_player_action[i] = i; } network_player_action_received = FALSE; @@ -2215,6 +3882,7 @@ void InitGame() AllPlayersGone = FALSE; game.yamyam_content_nr = 0; + game.robot_wheel_active = FALSE; game.magic_wall_active = FALSE; game.magic_wall_time_left = 0; game.light_time_left = 0; @@ -2223,11 +3891,7 @@ void InitGame() game.wind_direction = level.wind_direction_initial; #if !USE_PLAYER_GRAVITY -#if 1 game.gravity = FALSE; -#else - game.gravity = level.initial_gravity; -#endif game.explosions_delayed = TRUE; #endif @@ -2251,11 +3915,6 @@ void InitGame() tape.set_centered_player = TRUE; } -#if 0 - printf("::: focus set to player %d [%d]\n", - game.centered_player_nr, local_player->index_nr); -#endif - for (i = 0; i < NUM_BELTS; i++) { game.belt_dir[i] = MV_NONE; @@ -2265,11 +3924,7 @@ void InitGame() for (i = 0; i < MAX_NUM_AMOEBA; i++) AmoebaCnt[i] = AmoebaCnt2[i] = 0; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (x = 0; x < lev_fieldx; x++) for (y = 0; y < lev_fieldy; y++) -#endif { Feld[x][y] = level.field[x][y]; MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0; @@ -2283,6 +3938,7 @@ void InitGame() WasJustMoving[x][y] = 0; WasJustFalling[x][y] = 0; CheckCollision[x][y] = 0; + CheckImpact[x][y] = 0; Stop[x][y] = FALSE; Pushed[x][y] = FALSE; @@ -2301,13 +3957,10 @@ void InitGame() GfxElement[x][y] = EL_UNDEFINED; GfxAction[x][y] = ACTION_DEFAULT; GfxDir[x][y] = MV_NONE; + GfxRedraw[x][y] = GFX_REDRAW_NONE; } -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y])) emulate_bd = FALSE; @@ -2317,6 +3970,8 @@ void InitGame() emulate_sp = FALSE; InitField(x, y, TRUE); + + ResetGfxAnimation(x, y); } InitBeltMovement(); @@ -2325,7 +3980,6 @@ void InitGame() { struct PlayerInfo *player = &stored_player[i]; -#if 1 /* set number of special actions for bored and sleeping animation */ player->num_special_action_bored = get_num_special_action(player->artwork_element, @@ -2333,66 +3987,182 @@ void InitGame() player->num_special_action_sleeping = get_num_special_action(player->artwork_element, ACTION_SLEEPING_1, ACTION_SLEEPING_LAST); + } + + game.emulation = (emulate_bd ? EMU_BOULDERDASH : + emulate_sb ? EMU_SOKOBAN : + emulate_sp ? EMU_SUPAPLEX : EMU_NONE); + +#if USE_NEW_ALL_SLIPPERY + /* initialize type of slippery elements */ + for (i = 0; i < MAX_NUM_ELEMENTS; i++) + { + if (!IS_CUSTOM_ELEMENT(i)) + { + /* default: elements slip down either to the left or right randomly */ + element_info[i].slippery_type = SLIPPERY_ANY_RANDOM; + + /* SP style elements prefer to slip down on the left side */ + if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i)) + element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT; + + /* BD style elements prefer to slip down on the left side */ + if (game.emulation == EMU_BOULDERDASH) + element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT; + } + } +#endif + + /* initialize explosion and ignition delay */ + for (i = 0; i < MAX_NUM_ELEMENTS; i++) + { + if (!IS_CUSTOM_ELEMENT(i)) + { + 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 - 1; + element_info[i].ignition_delay = half_phase; + + if (i == EL_BLACK_ORB) + element_info[i].ignition_delay = 1; + } + +#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 < NUM_BELTS; i++) + if (game.belt_dir[i] == MV_NONE) + game.belt_dir_nr[i] = 3; /* not moving, next moving left */ + +#if USE_NEW_PLAYER_ASSIGNMENTS + /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */ + /* choose default local player */ + local_player = &stored_player[0]; + + for (i = 0; i < MAX_PLAYERS; i++) + stored_player[i].connected = FALSE; + + local_player->connected = TRUE; + /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */ + + if (tape.playing) + { + /* try to guess locally connected team mode players (needed for correct + assignment of player figures from level to locally playing players) */ + + for (i = 0; i < MAX_PLAYERS; i++) + if (tape.player_participates[i]) + stored_player[i].connected = TRUE; + } + else if (setup.team_mode && !options.network) + { + /* try to guess locally connected team mode players (needed for correct + assignment of player figures from level to locally playing players) */ + + for (i = 0; i < MAX_PLAYERS; i++) + if (setup.input[i].use_joystick || + setup.input[i].key.left != KSYM_UNDEFINED) + stored_player[i].connected = TRUE; + } + +#if 0 + for (i = 0; i < MAX_PLAYERS; i++) + printf("::: player %d: %s\n", i, + (stored_player[i].connected ? "connected" : "not connected")); + + for (i = 0; i < MAX_PLAYERS; i++) + printf("::: player %d: %s\n", i, + (stored_player[i].present ? "present" : "not present")); +#endif + + /* check if any connected player was not found in playfield */ + for (i = 0; i < MAX_PLAYERS; i++) + { + struct PlayerInfo *player = &stored_player[i]; + + if (player->connected && !player->present) + { + struct PlayerInfo *field_player = NULL; + +#if 0 + printf("::: looking for field player for player %d ...\n", i); +#endif + + /* assign first free player found that is present in the playfield */ + + /* first try: look for unmapped playfield player that is not connected */ + if (field_player == NULL) + for (j = 0; j < MAX_PLAYERS; j++) + if (stored_player[j].present && + !stored_player[j].mapped && + !stored_player[j].connected) + field_player = &stored_player[j]; + + /* second try: look for *any* unmapped playfield player */ + if (field_player == NULL) + for (j = 0; j < MAX_PLAYERS; j++) + if (stored_player[j].present && + !stored_player[j].mapped) + field_player = &stored_player[j]; + + if (field_player != NULL) + { + int jx = field_player->jx, jy = field_player->jy; + +#if 0 + printf("::: found player figure %d\n", field_player->index_nr); #endif - } + player->present = FALSE; + player->active = FALSE; - game.emulation = (emulate_bd ? EMU_BOULDERDASH : - emulate_sb ? EMU_SOKOBAN : - emulate_sp ? EMU_SUPAPLEX : EMU_NONE); + field_player->present = TRUE; + field_player->active = TRUE; -#if USE_NEW_ALL_SLIPPERY - /* initialize type of slippery elements */ - for (i = 0; i < MAX_NUM_ELEMENTS; i++) - { - if (!IS_CUSTOM_ELEMENT(i)) - { - /* default: elements slip down either to the left or right randomly */ - element_info[i].slippery_type = SLIPPERY_ANY_RANDOM; + /* + player->initial_element = field_player->initial_element; + player->artwork_element = field_player->artwork_element; - /* SP style elements prefer to slip down on the left side */ - if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i)) - element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT; + player->block_last_field = field_player->block_last_field; + player->block_delay_adjustment = field_player->block_delay_adjustment; + */ - /* BD style elements prefer to slip down on the left side */ - if (game.emulation == EMU_BOULDERDASH) - element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT; - } - } -#endif + StorePlayer[jx][jy] = field_player->element_nr; - /* initialize explosion and ignition delay */ - for (i = 0; i < MAX_NUM_ELEMENTS; i++) - { - if (!IS_CUSTOM_ELEMENT(i)) - { - 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; + field_player->jx = field_player->last_jx = jx; + field_player->jy = field_player->last_jy = jy; - element_info[i].explosion_delay = last_phase - 1; - element_info[i].ignition_delay = half_phase; + if (local_player == player) + local_player = field_player; - if (i == EL_BLACK_ORB) - element_info[i].ignition_delay = 1; - } + map_player_action[field_player->index_nr] = i; -#if 0 - if (element_info[i].explosion_delay < 1) /* !!! check again !!! */ - element_info[i].explosion_delay = 1; + field_player->mapped = TRUE; - if (element_info[i].ignition_delay < 1) /* !!! check again !!! */ - element_info[i].ignition_delay = 1; +#if 0 + printf("::: map_player_action[%d] == %d\n", + field_player->index_nr, i); #endif + } + } + + if (player->connected && player->present) + player->mapped = TRUE; } - /* correct non-moving belts to start moving left */ - for (i = 0; i < NUM_BELTS; i++) - if (game.belt_dir[i] == MV_NONE) - game.belt_dir_nr[i] = 3; /* not moving, next moving left */ +#else /* check if any connected player was not found in playfield */ for (i = 0; i < MAX_PLAYERS; i++) @@ -2403,28 +4173,26 @@ void InitGame() { for (j = 0; j < MAX_PLAYERS; j++) { - struct PlayerInfo *some_player = &stored_player[j]; - int jx = some_player->jx, jy = some_player->jy; + struct PlayerInfo *field_player = &stored_player[j]; + int jx = field_player->jx, jy = field_player->jy; /* assign first free player found that is present in the playfield */ - if (some_player->present && !some_player->connected) + if (field_player->present && !field_player->connected) { player->present = TRUE; player->active = TRUE; - some_player->present = FALSE; - some_player->active = FALSE; - -#if 0 - player->element_nr = some_player->element_nr; -#endif + field_player->present = FALSE; + field_player->active = FALSE; - player->artwork_element = some_player->artwork_element; + player->initial_element = field_player->initial_element; + player->artwork_element = field_player->artwork_element; - player->block_last_field = some_player->block_last_field; - player->block_delay_adjustment = some_player->block_delay_adjustment; + player->block_last_field = field_player->block_last_field; + player->block_delay_adjustment = field_player->block_delay_adjustment; StorePlayer[jx][jy] = player->element_nr; + player->jx = player->last_jx = jx; player->jy = player->last_jy = jy; @@ -2433,11 +4201,31 @@ void InitGame() } } } +#endif + +#if 0 + printf("::: local_player->present == %d\n", local_player->present); +#endif if (tape.playing) { /* when playing a tape, eliminate all players who do not participate */ +#if USE_NEW_PLAYER_ASSIGNMENTS + for (i = 0; i < MAX_PLAYERS; i++) + { + if (stored_player[i].active && + !tape.player_participates[map_player_action[i]]) + { + struct PlayerInfo *player = &stored_player[i]; + int jx = player->jx, jy = player->jy; + + player->active = FALSE; + StorePlayer[jx][jy] = 0; + Feld[jx][jy] = EL_EMPTY; + } + } +#else for (i = 0; i < MAX_PLAYERS; i++) { if (stored_player[i].active && !tape.player_participates[i]) @@ -2450,6 +4238,7 @@ void InitGame() Feld[jx][jy] = EL_EMPTY; } } +#endif } else if (!options.network && !setup.team_mode) /* && !tape.playing */ { @@ -2480,9 +4269,15 @@ void InitGame() /* when recording the game, store which players take part in the game */ if (tape.recording) { +#if USE_NEW_PLAYER_ASSIGNMENTS + for (i = 0; i < MAX_PLAYERS; i++) + if (stored_player[i].connected) + tape.player_participates[i] = TRUE; +#else for (i = 0; i < MAX_PLAYERS; i++) if (stored_player[i].active) tape.player_participates[i] = TRUE; +#endif } if (options.debug) @@ -2531,11 +4326,7 @@ void InitGame() int found_element = EL_UNDEFINED; int player_nr = local_player->index_nr; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { int element = Feld[x][y]; int content; @@ -2564,7 +4355,8 @@ void InitGame() content = element_info[element].change_page[i].target_element; is_player = ELEM_IS_PLAYER(content); - if (is_player && (found_rating < 3 || element < found_element)) + if (is_player && (found_rating < 3 || + (found_rating == 3 && element < found_element))) { start_x = x; start_y = y; @@ -2581,7 +4373,8 @@ void InitGame() content = element_info[element].content.e[xx][yy]; is_player = ELEM_IS_PLAYER(content); - if (is_player && (found_rating < 2 || element < found_element)) + if (is_player && (found_rating < 2 || + (found_rating == 2 && element < found_element))) { start_x = x + xx - 1; start_y = y + yy - 1; @@ -2601,7 +4394,8 @@ void InitGame() is_player = ELEM_IS_PLAYER(content); - if (is_player && (found_rating < 1 || element < found_element)) + if (is_player && (found_rating < 1 || + (found_rating == 1 && element < found_element))) { start_x = x + xx - 1; start_y = y + yy - 1; @@ -2632,18 +4426,46 @@ void InitGame() local_player->jy - MIDPOSY); } +#if 0 + /* do not use PLAYING mask for fading out from main screen */ + game_status = GAME_MODE_MAIN; +#endif + StopAnimation(); if (!game.restart_level) CloseDoor(DOOR_CLOSE_1); +#if 1 + if (level_editor_test_game) + FadeSkipNextFadeIn(); + else + FadeSetEnterScreen(); +#else + if (level_editor_test_game) + fading = fading_none; + else + fading = menu.destination; +#endif + +#if 1 + FadeOut(REDRAW_FIELD); +#else if (do_fading) FadeOut(REDRAW_FIELD); +#endif + +#if 0 + game_status = GAME_MODE_PLAYING; +#endif /* !!! FIX THIS (START) !!! */ if (level.game_engine_type == GAME_ENGINE_TYPE_EM) { InitGameEngine_EM(); + + /* blit playfield from scroll buffer to normal back buffer for fading in */ + BlitScreenToBitmap_EM(backbuffer); } else { @@ -2654,20 +4476,23 @@ void InitGame() if (game.timegate_time_left == 0) CloseAllOpenTimegates(); + /* blit playfield from scroll buffer to normal back buffer for fading in */ if (setup.soft_scrolling) BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY); redraw_mask |= REDRAW_FROM_BACKBUFFER; - -#if 0 - FadeToFront(); -#endif } /* !!! FIX THIS (END) !!! */ +#if 1 + FadeIn(REDRAW_FIELD); +#else if (do_fading) FadeIn(REDRAW_FIELD); + BackToFront(); +#endif + if (!game.restart_level) { /* copy default game door content to main double buffer */ @@ -2675,12 +4500,15 @@ void InitGame() DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY); } -#if 1 SetPanelBackground(); SetDrawBackgroundMask(REDRAW_DOOR_1); -#endif +#if 1 + UpdateAndDisplayGameControlValues(); +#else + UpdateGameDoorValues(); DrawGameDoorValues(); +#endif if (!game.restart_level) { @@ -2698,7 +4526,7 @@ void InitGame() OpenDoor(DOOR_OPEN_ALL); - PlaySoundStereo(SND_GAME_STARTING, SOUND_MIDDLE); + PlaySound(SND_GAME_STARTING); if (setup.sound_music) PlayLevelMusic(); @@ -2713,6 +4541,13 @@ void InitGame() } } +#if 1 + UnmapAllGadgets(); + + MapGameButtons(); + MapTapeButtons(); +#endif + game.restart_level = FALSE; } @@ -2742,7 +4577,7 @@ void InitMovDir(int x, int y) { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN } }; - switch(element) + switch (element) { case EL_BUG_RIGHT: case EL_BUG_UP: @@ -2923,311 +4758,238 @@ void InitAmoebaNr(int x, int y) AmoebaCnt2[group_nr]++; } -#if USE_NEW_GAME_WON +static void PlayerWins(struct PlayerInfo *player) +{ + player->LevelSolved = TRUE; + player->GameOver = TRUE; + + player->score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ? + level.native_em_level->lev->score : player->score); + + player->LevelSolved_CountingTime = (level.time == 0 ? TimePlayed : TimeLeft); + player->LevelSolved_CountingScore = player->score_final; +} void GameWon() { - static boolean score_done = FALSE; - static boolean player_done = FALSE; - static int game_over_delay = 0; - int game_over_delay_value = 50; + static int time, time_final; + static int score, score_final; + static int game_over_delay_1 = 0; + static int game_over_delay_2 = 0; + int game_over_delay_value_1 = 50; + int game_over_delay_value_2 = 50; - /* do not start end game actions before the player stops moving (to exit) */ - if (local_player->MovPos) - return; + if (!local_player->LevelSolved_GameWon) + { + int i; - if (tape.auto_play) /* tape might already be stopped here */ - tape.auto_play_level_solved = TRUE; + /* do not start end game actions before the player stops moving (to exit) */ + if (local_player->MovPos) + return; - if (!local_player->LevelSolved_GameEnd) - { - local_player->LevelSolved_GameEnd = TRUE; + local_player->LevelSolved_GameWon = TRUE; local_player->LevelSolved_SaveTape = tape.recording; local_player->LevelSolved_SaveScore = !tape.playing; - score_done = FALSE; - player_done = FALSE; - game_over_delay = 0; - } - - PlaySoundStereo(SND_GAME_WINNING, SOUND_MIDDLE); - - if (TimeLeft > 0) - { - if (!tape.playing) - { - if (setup.sound_loops) - PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE, - SND_CTRL_PLAY_LOOP); - else - PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE); - } - - if (TimeLeft > 100 && TimeLeft % 10 == 0) - { - TimeLeft -= 10; - RaiseScore(level.score[SC_TIME_BONUS] * 10); - } - else - { - TimeLeft--; - RaiseScore(level.score[SC_TIME_BONUS]); - } - - DrawGameValue_Time(TimeLeft); + if (tape.auto_play) /* tape might already be stopped here */ + tape.auto_play_level_solved = TRUE; -#if 0 - if (!tape.playing) - Delay(10); +#if 1 + TapeStop(); #endif - if (TimeLeft <= 0 && !tape.playing && setup.sound_loops) - StopSound(SND_GAME_LEVELTIME_BONUS); - } - else if (level.time == 0 && TimePlayed < 999) /* level without time limit */ - { - if (!tape.playing) - { - if (setup.sound_loops) - PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE, - SND_CTRL_PLAY_LOOP); - else - PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE); - } + game_over_delay_1 = game_over_delay_value_1; + game_over_delay_2 = game_over_delay_value_2; + + time = time_final = (level.time == 0 ? TimePlayed : TimeLeft); + score = score_final = local_player->score_final; - if (TimePlayed < 900 && TimePlayed % 10 == 0) + if (TimeLeft > 0) { - TimePlayed += 10; - RaiseScore(level.score[SC_TIME_BONUS] * 10); + time_final = 0; + score_final += TimeLeft * level.score[SC_TIME_BONUS]; } - else + else if (level.time == 0 && TimePlayed < 999) { - TimePlayed++; - RaiseScore(level.score[SC_TIME_BONUS]); + time_final = 999; + score_final += (999 - TimePlayed) * level.score[SC_TIME_BONUS]; } - DrawGameValue_Time(TimePlayed); - - if (TimePlayed >= 999 && !tape.playing && setup.sound_loops) - StopSound(SND_GAME_LEVELTIME_BONUS); - } - else - { - score_done = TRUE; - } - - /* close exit door after last player */ - if (AllPlayersGone && ExitX >= 0 && ExitY >= 0 && - (Feld[ExitX][ExitY] == EL_EXIT_OPEN || - Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN)) - { - int element = Feld[ExitX][ExitY]; - - Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING : - EL_SP_EXIT_CLOSING); - - PlayLevelSoundElementAction(ExitX, ExitY, element, ACTION_CLOSING); - } - - /* player disappears */ - if (ExitX >= 0 && ExitY >= 0 && !player_done) - { - DrawLevelField(ExitX, ExitY); - - player_done = TRUE; - } - - game_over_delay++; - - if (game_over_delay < game_over_delay_value || !score_done) - return; -} - -void GameEnd() -{ - int hi_pos; - boolean raise_level = FALSE; - - CloseDoor(DOOR_CLOSE_1); - - if (local_player->LevelSolved_SaveTape) - { - TapeStop(); - - SaveTape(tape.level_nr); /* Ask to save tape */ - } - - if (!local_player->LevelSolved_SaveScore) - { - FadeOut(REDRAW_FIELD); - - game_status = GAME_MODE_MAIN; - - DrawAndFadeInMainMenu(REDRAW_FIELD); - - return; - } - - if (level_nr == leveldir_current->handicap_level) - { - leveldir_current->handicap_level++; - SaveLevelSetup_SeriesInfo(); - } + local_player->score_final = score_final; - if (level_editor_test_game) - local_player->score = -1; /* no highscore when playing from editor */ - else if (level_nr < leveldir_current->last_level) - raise_level = TRUE; /* advance to next level */ + if (level_editor_test_game) + { + time = time_final; + score = score_final; - if ((hi_pos = NewHiScore()) >= 0) - { - game_status = GAME_MODE_SCORES; +#if 1 + local_player->LevelSolved_CountingTime = time; + local_player->LevelSolved_CountingScore = score; - DrawHallOfFame(hi_pos); + game_panel_controls[GAME_PANEL_TIME].value = time; + game_panel_controls[GAME_PANEL_SCORE].value = score; - if (raise_level) - { - level_nr++; - TapeErase(); + DisplayGameControlValues(); +#else + DrawGameValue_Time(time); + DrawGameValue_Score(score); +#endif } - } - else - { - FadeOut(REDRAW_FIELD); - game_status = GAME_MODE_MAIN; - - if (raise_level) + if (level.game_engine_type == GAME_ENGINE_TYPE_RND) { - level_nr++; - TapeErase(); - } + if (ExitX >= 0 && ExitY >= 0) /* local player has left the level */ + { + /* close exit door after last player */ + if ((AllPlayersGone && + (Feld[ExitX][ExitY] == EL_EXIT_OPEN || + Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN || + Feld[ExitX][ExitY] == EL_STEEL_EXIT_OPEN)) || + Feld[ExitX][ExitY] == EL_EM_EXIT_OPEN || + Feld[ExitX][ExitY] == EL_EM_STEEL_EXIT_OPEN) + { + int element = Feld[ExitX][ExitY]; - DrawAndFadeInMainMenu(REDRAW_FIELD); - } +#if 0 + if (element == EL_EM_EXIT_OPEN || + element == EL_EM_STEEL_EXIT_OPEN) + { + Bang(ExitX, ExitY); + } + else +#endif + { + Feld[ExitX][ExitY] = + (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING : + element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING : + element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING: + element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING: + EL_EM_STEEL_EXIT_CLOSING); + + PlayLevelSoundElementAction(ExitX, ExitY, element, ACTION_CLOSING); + } + } - local_player->LevelSolved_SaveScore = FALSE; -} + /* player disappears */ + DrawLevelField(ExitX, ExitY); + } -#else + for (i = 0; i < MAX_PLAYERS; i++) + { + struct PlayerInfo *player = &stored_player[i]; -void GameWon() -{ - int hi_pos; - boolean raise_level = FALSE; + if (player->present) + { + RemovePlayer(player); - if (local_player->MovPos) - return; + /* player disappears */ + DrawLevelField(player->jx, player->jy); + } + } + } - if (tape.auto_play) /* tape might already be stopped here */ - tape.auto_play_level_solved = TRUE; + PlaySound(SND_GAME_WINNING); + } - local_player->LevelSolved = FALSE; + if (game_over_delay_1 > 0) + { + game_over_delay_1--; - PlaySoundStereo(SND_GAME_WINNING, SOUND_MIDDLE); + return; + } - if (TimeLeft) + if (time != time_final) { - if (!tape.playing && setup.sound_loops) - PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE, - SND_CTRL_PLAY_LOOP); - - while (TimeLeft > 0) - { - if (!tape.playing && !setup.sound_loops) - PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE); + int time_to_go = ABS(time_final - time); + int time_count_dir = (time < time_final ? +1 : -1); + int time_count_steps = (time_to_go > 100 && time_to_go % 10 == 0 ? 10 : 1); - if (TimeLeft > 100 && TimeLeft % 10 == 0) - { - TimeLeft -= 10; - RaiseScore(level.score[SC_TIME_BONUS] * 10); - } - else - { - TimeLeft--; - RaiseScore(level.score[SC_TIME_BONUS]); - } + time += time_count_steps * time_count_dir; + score += time_count_steps * level.score[SC_TIME_BONUS]; - DrawGameValue_Time(TimeLeft); +#if 1 + local_player->LevelSolved_CountingTime = time; + local_player->LevelSolved_CountingScore = score; - BackToFront(); + game_panel_controls[GAME_PANEL_TIME].value = time; + game_panel_controls[GAME_PANEL_SCORE].value = score; - if (!tape.playing) - Delay(10); - } + DisplayGameControlValues(); +#else + DrawGameValue_Time(time); + DrawGameValue_Score(score); +#endif - if (!tape.playing && setup.sound_loops) + if (time == time_final) StopSound(SND_GAME_LEVELTIME_BONUS); + else if (setup.sound_loops) + PlaySoundLoop(SND_GAME_LEVELTIME_BONUS); + else + PlaySound(SND_GAME_LEVELTIME_BONUS); + + return; } - else if (level.time == 0) /* level without time limit */ + + local_player->LevelSolved_PanelOff = TRUE; + + if (game_over_delay_2 > 0) { - if (!tape.playing && setup.sound_loops) - PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE, - SND_CTRL_PLAY_LOOP); + game_over_delay_2--; - while (TimePlayed < 999) - { - if (!tape.playing && !setup.sound_loops) - PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE); + return; + } - if (TimePlayed < 900 && TimePlayed % 10 == 0) - { - TimePlayed += 10; - RaiseScore(level.score[SC_TIME_BONUS] * 10); - } - else - { - TimePlayed++; - RaiseScore(level.score[SC_TIME_BONUS]); - } +#if 1 + GameEnd(); +#endif +} - DrawGameValue_Time(TimePlayed); +void GameEnd() +{ + int hi_pos; + boolean raise_level = FALSE; - BackToFront(); + local_player->LevelSolved_GameEnd = TRUE; - if (!tape.playing) - Delay(10); - } + CloseDoor(DOOR_CLOSE_1); - if (!tape.playing && setup.sound_loops) - StopSound(SND_GAME_LEVELTIME_BONUS); + if (local_player->LevelSolved_SaveTape) + { +#if 0 + TapeStop(); +#endif + +#if 1 + SaveTapeChecked(tape.level_nr); /* ask to save tape */ +#else + SaveTape(tape.level_nr); /* ask to save tape */ +#endif } - /* close exit door after last player */ - if (AllPlayersGone && ExitX >= 0 && ExitY >= 0 && - (Feld[ExitX][ExitY] == EL_EXIT_OPEN || - Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN)) + if (level_editor_test_game) { - int element = Feld[ExitX][ExitY]; + game_status = GAME_MODE_MAIN; - Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING : - EL_SP_EXIT_CLOSING); +#if 1 + DrawAndFadeInMainMenu(REDRAW_FIELD); +#else + DrawMainMenu(); +#endif - PlayLevelSoundElementAction(ExitX, ExitY, element, ACTION_CLOSING); + return; } - /* player disappears */ - if (ExitX >= 0 && ExitY >= 0) - DrawLevelField(ExitX, ExitY); - - BackToFront(); - -#if 0 - if (tape.playing) - printf("::: TAPE PLAYING -> DO NOT SAVE SCORE\n"); - else - printf("::: NO TAPE PLAYING -> SAVING SCORE\n"); + if (!local_player->LevelSolved_SaveScore) + { +#if 1 + FadeOut(REDRAW_FIELD); #endif - if (tape.playing) - return; + game_status = GAME_MODE_MAIN; - CloseDoor(DOOR_CLOSE_1); + DrawAndFadeInMainMenu(REDRAW_FIELD); - if (tape.recording) - { - TapeStop(); - SaveTape(tape.level_nr); /* Ask to save tape */ + return; } if (level_nr == leveldir_current->handicap_level) @@ -3236,15 +4998,15 @@ void GameWon() SaveLevelSetup_SeriesInfo(); } - if (level_editor_test_game) - local_player->score = -1; /* no highscore when playing from editor */ - else if (level_nr < leveldir_current->last_level) - raise_level = TRUE; /* advance to next level */ + if (level_nr < leveldir_current->last_level) + raise_level = TRUE; /* advance to next level */ if ((hi_pos = NewHiScore()) >= 0) { game_status = GAME_MODE_SCORES; + DrawHallOfFame(hi_pos); + if (raise_level) { level_nr++; @@ -3253,20 +5015,22 @@ void GameWon() } else { +#if 1 + FadeOut(REDRAW_FIELD); +#endif + game_status = GAME_MODE_MAIN; + if (raise_level) { level_nr++; TapeErase(); } - DrawMainMenu(); - } - BackToFront(); + DrawAndFadeInMainMenu(REDRAW_FIELD); + } } -#endif - int NewHiScore() { int k, l; @@ -3275,12 +5039,12 @@ int NewHiScore() LoadScore(level_nr); if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) || - local_player->score < highscore[MAX_SCORE_ENTRIES - 1].Score) + local_player->score_final < highscore[MAX_SCORE_ENTRIES - 1].Score) return -1; for (k = 0; k < MAX_SCORE_ENTRIES; k++) { - if (local_player->score > highscore[k].Score) + if (local_player->score_final > highscore[k].Score) { /* player has made it to the hall of fame */ @@ -3308,7 +5072,7 @@ int NewHiScore() #endif strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN); highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0'; - highscore[k].Score = local_player->score; + highscore[k].Score = local_player->score_final; position = k; break; } @@ -3327,10 +5091,9 @@ int NewHiScore() return position; } -inline static int getElementMoveStepsize(int x, int y) +inline static int getElementMoveStepsizeExt(int x, int y, int direction) { int element = Feld[x][y]; - int direction = MovDir[x][y]; int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0); int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0); int horiz_move = (dx != 0); @@ -3340,24 +5103,21 @@ inline static int getElementMoveStepsize(int x, int y) /* special values for move stepsize for spring and things on conveyor belt */ if (horiz_move) { -#if 0 - if (element == EL_SPRING) - step = sign * MOVE_STEPSIZE_NORMAL * 2; - else if (CAN_FALL(element) && !CAN_MOVE(element) && - y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1])) - step = sign * MOVE_STEPSIZE_NORMAL / 2; -#else if (CAN_FALL(element) && y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1])) step = sign * MOVE_STEPSIZE_NORMAL / 2; else if (element == EL_SPRING) step = sign * MOVE_STEPSIZE_NORMAL * 2; -#endif } return step; } +inline static int getElementMoveStepsize(int x, int y) +{ + return getElementMoveStepsizeExt(x, y, MovDir[x][y]); +} + void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir) { if (player->GfxAction != action || player->GfxDir != dir) @@ -3397,28 +5157,10 @@ static void ResetGfxFrame(int x, int y, boolean redraw) static void ResetGfxAnimation(int x, int y) { -#if 0 - int element, graphic; -#endif - GfxAction[x][y] = ACTION_DEFAULT; GfxDir[x][y] = MovDir[x][y]; GfxFrame[x][y] = 0; -#if 0 - element = Feld[x][y]; - graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); - - if (graphic_info[graphic].anim_global_sync) - GfxFrame[x][y] = FrameCounter; - else if (ANIM_MODE(graphic) == ANIM_CE_VALUE) - GfxFrame[x][y] = CustomValue[x][y]; - else if (ANIM_MODE(graphic) == ANIM_CE_SCORE) - GfxFrame[x][y] = element_info[element].collect_score; - else if (ANIM_MODE(graphic) == ANIM_CE_DELAY) - GfxFrame[x][y] = ChangeDelay[x][y]; -#endif - #if USE_GFX_RESET_GFX_ANIMATION ResetGfxFrame(x, y, FALSE); #endif @@ -3432,38 +5174,60 @@ static void ResetRandomAnimationValue(int x, int y) void InitMovingField(int x, int y, int direction) { int element = Feld[x][y]; -#if 0 - int graphic; -#endif int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0); int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0); int newx = x + dx; int newy = y + dy; + boolean is_moving_before, is_moving_after; +#if 0 + boolean continues_moving = (WasJustMoving[x][y] && direction == MovDir[x][y]); +#endif + + /* check if element was/is moving or being moved before/after mode change */ +#if 1 +#if 1 + is_moving_before = (WasJustMoving[x][y] != 0); +#else + /* (!!! this does not work -- WasJustMoving is NOT a boolean value !!!) */ + is_moving_before = WasJustMoving[x][y]; +#endif +#else + is_moving_before = (getElementMoveStepsizeExt(x, y, MovDir[x][y]) != 0); +#endif + is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0); - if (!WasJustMoving[x][y] || direction != MovDir[x][y]) + /* reset animation only for moving elements which change direction of moving + or which just started or stopped moving + (else CEs with property "can move" / "not moving" are reset each frame) */ +#if USE_GFX_RESET_ONLY_WHEN_MOVING +#if 1 + if (is_moving_before != is_moving_after || + direction != MovDir[x][y]) + ResetGfxAnimation(x, y); +#else + if ((is_moving_before || is_moving_after) && !continues_moving) + ResetGfxAnimation(x, y); +#endif +#else + if (!continues_moving) ResetGfxAnimation(x, y); +#endif MovDir[x][y] = direction; GfxDir[x][y] = direction; + +#if USE_GFX_RESET_ONLY_WHEN_MOVING + GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING : + direction == MV_DOWN && CAN_FALL(element) ? + ACTION_FALLING : ACTION_MOVING); +#else GfxAction[x][y] = (direction == MV_DOWN && CAN_FALL(element) ? ACTION_FALLING : ACTION_MOVING); - -#if 0 - graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); - - if (graphic_info[graphic].anim_global_sync) - GfxFrame[x][y] = FrameCounter; - else if (ANIM_MODE(graphic) == ANIM_CE_VALUE) - GfxFrame[x][y] = CustomValue[x][y]; - else if (ANIM_MODE(graphic) == ANIM_CE_SCORE) - GfxFrame[x][y] = element_info[element].collect_score; - else if (ANIM_MODE(graphic) == ANIM_CE_DELAY) - GfxFrame[x][y] = ChangeDelay[x][y]; #endif /* this is needed for CEs with property "can move" / "not moving" */ - if (getElementMoveStepsize(x, y) != 0) /* moving or being moved */ + if (is_moving_after) { if (Feld[newx][newy] == EL_EMPTY) Feld[newx][newy] = EL_BLOCKED; @@ -3484,13 +5248,8 @@ void InitMovingField(int x, int y, int direction) void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y) { int direction = MovDir[x][y]; -#if 1 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0); int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0); -#else - int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0); - int newy = y + (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0); -#endif *goes_to_x = newx; *goes_to_y = newy; @@ -3576,6 +5335,10 @@ static void RemoveField(int x, int y) GfxElement[x][y] = EL_UNDEFINED; GfxAction[x][y] = ACTION_DEFAULT; GfxDir[x][y] = MV_NONE; +#if 0 + /* !!! this would prevent the removed tile from being redrawn !!! */ + GfxRedraw[x][y] = GFX_REDRAW_NONE; +#endif } void RemoveMovingField(int x, int y) @@ -3601,7 +5364,7 @@ void RemoveMovingField(int x, int y) Store[oldx][oldy] = Store2[oldx][oldy] = 0; - DrawLevelField(oldx, oldy); + TEST_DrawLevelField(oldx, oldy); return; } @@ -3615,8 +5378,10 @@ void RemoveMovingField(int x, int y) if (element == EL_BLOCKED && (Feld[oldx][oldy] == EL_QUICKSAND_EMPTYING || + Feld[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING || Feld[oldx][oldy] == EL_MAGIC_WALL_EMPTYING || Feld[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING || + Feld[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING || Feld[oldx][oldy] == EL_AMOEBA_DROPPING)) next_element = get_next_element(Feld[oldx][oldy]); @@ -3628,8 +5393,8 @@ void RemoveMovingField(int x, int y) if (next_element != EL_UNDEFINED) Feld[oldx][oldy] = next_element; - DrawLevelField(oldx, oldy); - DrawLevelField(newx, newy); + TEST_DrawLevelField(oldx, oldy); + TEST_DrawLevelField(newx, newy); } void DrawDynamite(int x, int y) @@ -3677,8 +5442,6 @@ void CheckDynamite(int x, int y) Bang(x, y); } -#if 1 - static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2) { boolean num_checked_players = 0; @@ -3729,35 +5492,8 @@ static void setScreenCenteredToAllPlayers(int *sx, int *sy) *sy = (sy1 + sy2) / 2; } -#if 0 -static void setMaxCenterDistanceForAllPlayers(int *max_dx, int *max_dy, - int center_x, int center_y) -{ - int sx1 = center_x, sy1 = center_y, sx2 = center_x, sy2 = center_y; - - setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2); - - *max_dx = MAX(ABS(sx1 - center_x), ABS(sx2 - center_x)); - *max_dy = MAX(ABS(sy1 - center_y), ABS(sy2 - center_y)); -} - -static boolean checkIfAllPlayersAreVisible(int center_x, int center_y) -{ - int max_dx, max_dy; - - setMaxCenterDistanceForAllPlayers(&max_dx, &max_dy, center_x, center_y); - - return (max_dx <= SCR_FIELDX / 2 && - max_dy <= SCR_FIELDY / 2); -} -#endif - -#endif - -#if 1 - -void DrawRelocateScreen(int x, int y, int move_dir, boolean center_screen, - boolean quick_relocation) +void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir, + boolean center_screen, boolean quick_relocation) { boolean ffwd_delay = (tape.playing && tape.fast_forward); boolean no_delay = (tape.warp_forward); @@ -3766,25 +5502,50 @@ void DrawRelocateScreen(int x, int y, int move_dir, boolean center_screen, if (quick_relocation) { - int offset = (setup.scroll_delay ? 3 : 0); - -#if 0 - if (center_screen) - offset = 0; -#endif + int offset = game.scroll_delay_value; if (!IN_VIS_FIELD(SCREENX(x), SCREENY(y)) || center_screen) { - scroll_x = (x < SBX_Left + MIDPOSX ? SBX_Left : - x > SBX_Right + MIDPOSX ? SBX_Right : - x - MIDPOSX); + if (!level.shifted_relocation || center_screen) + { + /* quick relocation (without scrolling), with centering of screen */ + + scroll_x = (x < SBX_Left + MIDPOSX ? SBX_Left : + x > SBX_Right + MIDPOSX ? SBX_Right : + x - MIDPOSX); + + 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); - scroll_y = (y < SBY_Upper + MIDPOSY ? SBY_Upper : - y > SBY_Lower + MIDPOSY ? SBY_Lower : - 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); + + scroll_y = (offset_y < SBY_Upper + MIDPOSY ? SBY_Upper : + offset_y > SBY_Lower + MIDPOSY ? SBY_Lower : + offset_y - MIDPOSY); + } } else { + /* quick relocation (without scrolling), inside visible screen area */ + if ((move_dir == MV_LEFT && scroll_x > x - MIDPOSX + offset) || (move_dir == MV_RIGHT && scroll_x < x - MIDPOSX - offset)) scroll_x = x - MIDPOSX + (scroll_x < x - MIDPOSX ? -offset : +offset); @@ -3806,107 +5567,57 @@ void DrawRelocateScreen(int x, int y, int move_dir, boolean center_screen, } else { - int scroll_xx = (x < SBX_Left + MIDPOSX ? SBX_Left : - x > SBX_Right + MIDPOSX ? SBX_Right : - x - MIDPOSX); - - int scroll_yy = (y < SBY_Upper + MIDPOSY ? SBY_Upper : - y > SBY_Lower + MIDPOSY ? SBY_Lower : - y - MIDPOSY); - - ScrollScreen(NULL, SCROLL_GO_ON); /* scroll last frame to full tile */ +#if 1 + int scroll_xx, scroll_yy; - while (scroll_x != scroll_xx || scroll_y != scroll_yy) + if (!level.shifted_relocation || center_screen) { - int dx = 0, dy = 0; - int fx = FX, fy = FY; - - 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 (dx == 0 && dy == 0) /* no scrolling needed at all */ - break; - - 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); - } - - DrawAllPlayers(); - BackToFront(); - Delay(wait_delay_value); - } -} - -#else - -void DrawRelocatePlayer(struct PlayerInfo *player, boolean quick_relocation) -{ - boolean ffwd_delay = (tape.playing && tape.fast_forward); - 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 jx = player->jx; - int jy = player->jy; + /* visible relocation (with scrolling), with centering of screen */ - if (quick_relocation) - { - int offset = (setup.scroll_delay ? 3 : 0); - - if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy))) - { - scroll_x = (player->jx < SBX_Left + MIDPOSX ? SBX_Left : - player->jx > SBX_Right + MIDPOSX ? SBX_Right : - player->jx - MIDPOSX); + scroll_xx = (x < SBX_Left + MIDPOSX ? SBX_Left : + x > SBX_Right + MIDPOSX ? SBX_Right : + x - MIDPOSX); - scroll_y = (player->jy < SBY_Upper + MIDPOSY ? SBY_Upper : - player->jy > SBY_Lower + MIDPOSY ? SBY_Lower : - player->jy - MIDPOSY); + scroll_yy = (y < SBY_Upper + MIDPOSY ? SBY_Upper : + y > SBY_Lower + MIDPOSY ? SBY_Lower : + y - 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); + /* visible relocation (with scrolling), but do not center screen */ - 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); + int center_scroll_x = (old_x < SBX_Left + MIDPOSX ? SBX_Left : + old_x > SBX_Right + MIDPOSX ? SBX_Right : + old_x - MIDPOSX); - /* 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); + int center_scroll_y = (old_y < SBY_Upper + MIDPOSY ? SBY_Upper : + old_y > SBY_Lower + MIDPOSY ? SBY_Lower : + old_y - MIDPOSY); - /* 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); + int offset_x = x + (scroll_x - center_scroll_x); + int offset_y = y + (scroll_y - center_scroll_y); + + scroll_xx = (offset_x < SBX_Left + MIDPOSX ? SBX_Left : + offset_x > SBX_Right + MIDPOSX ? SBX_Right : + offset_x - MIDPOSX); + + scroll_yy = (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 = (player->jx < SBX_Left + MIDPOSX ? SBX_Left : - player->jx > SBX_Right + MIDPOSX ? SBX_Right : - player->jx - MIDPOSX); +#else + + /* visible relocation (with scrolling), with centering of screen */ + + int scroll_xx = (x < SBX_Left + MIDPOSX ? SBX_Left : + x > SBX_Right + MIDPOSX ? SBX_Right : + x - MIDPOSX); - int scroll_yy = (player->jy < SBY_Upper + MIDPOSY ? SBY_Upper : - player->jy > SBY_Lower + MIDPOSY ? SBY_Lower : - player->jy - MIDPOSY); + int scroll_yy = (y < SBY_Upper + MIDPOSY ? SBY_Upper : + y > SBY_Lower + MIDPOSY ? SBY_Lower : + y - MIDPOSY); +#endif ScrollScreen(NULL, SCROLL_GO_ON); /* scroll last frame to full tile */ @@ -3940,14 +5651,12 @@ void DrawRelocatePlayer(struct PlayerInfo *player, boolean quick_relocation) Delay(wait_delay_value); } - DrawPlayer(player); + DrawAllPlayers(); BackToFront(); Delay(wait_delay_value); } } -#endif - void RelocatePlayer(int jx, int jy, int el_player_raw) { int el_player = GET_PLAYER_ELEMENT(el_player_raw); @@ -4023,19 +5732,9 @@ void RelocatePlayer(int jx, int jy, int el_player_raw) InitField(jx, jy, FALSE); } -#if 1 /* only visually relocate centered player */ -#if 1 - DrawRelocateScreen(player->jx, player->jy, player->MovDir, FALSE, - level.instant_relocation); -#else - if (player->index_nr == game.centered_player_nr) - DrawRelocatePlayer(player, level.instant_relocation); -#endif -#else - if (player == local_player) /* only visually relocate local player */ - DrawRelocatePlayer(player, level.instant_relocation); -#endif + DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir, + FALSE, level.instant_relocation); TestIfPlayerTouchesBadThing(jx, jy); TestIfPlayerTouchesCustomElement(jx, jy); @@ -4046,6 +5745,21 @@ void RelocatePlayer(int jx, int jy, int el_player_raw) CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X, player->index_bit, enter_side); + +#if 1 + if (player->is_switching) + { + /* ensure that relocation while still switching an element does not cause + a new element to be treated as also switched directly after relocation + (this is important for teleporter switches that teleport the player to + a place where another teleporter switch is in the same direction, which + would then incorrectly be treated as immediately switched before the + direction key that caused the switch was released) */ + + player->switch_x += jx - old_jx; + player->switch_y += jy - old_jy; + } +#endif } void Explode(int ex, int ey, int phase, int mode) @@ -4121,11 +5835,7 @@ void Explode(int ex, int ey, int phase, int mode) PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING); #endif -#if 1 last_phase = element_info[explosion_element].explosion_delay + 1; -#else - last_phase = element_info[center_element].explosion_delay + 1; -#endif for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++) { @@ -4198,33 +5908,14 @@ void Explode(int ex, int ey, int phase, int mode) if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey)) { -#if 1 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1; Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr; -#else - switch(StorePlayer[ex][ey]) - { - case EL_PLAYER_2: - Store[x][y] = EL_PLAYER_IS_EXPLODING_2; - break; - case EL_PLAYER_3: - Store[x][y] = EL_PLAYER_IS_EXPLODING_3; - break; - case EL_PLAYER_4: - Store[x][y] = EL_PLAYER_IS_EXPLODING_4; - break; - case EL_PLAYER_1: - default: - Store[x][y] = EL_PLAYER_IS_EXPLODING_1; - break; - } -#endif if (PLAYERINFO(ex, ey)->use_murphy) Store[x][y] = EL_EMPTY; } -#if 1 + /* !!! check this case -- currently needed for rnd_rado_negundo_v, !!! levels 015 018 019 020 021 022 023 026 027 028 !!! */ else if (ELEM_IS_PLAYER(center_element)) @@ -4245,45 +5936,6 @@ void Explode(int ex, int ey, int phase, int mode) #endif else Store[x][y] = EL_EMPTY; -#else - else if (center_element == EL_MOLE) - Store[x][y] = EL_EMERALD_RED; - else if (center_element == EL_PENGUIN) - Store[x][y] = EL_EMERALD_PURPLE; - else if (center_element == EL_BUG) - Store[x][y] = ((x == ex && y == ey) ? EL_DIAMOND : EL_EMERALD); - else if (center_element == EL_BD_BUTTERFLY) - Store[x][y] = EL_BD_DIAMOND; - else if (center_element == EL_SP_ELECTRON) - Store[x][y] = EL_SP_INFOTRON; - else if (center_element == EL_AMOEBA_TO_DIAMOND) - Store[x][y] = level.amoeba_content; - else if (center_element == EL_YAMYAM) - Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy]; - else if (IS_CUSTOM_ELEMENT(center_element) && - element_info[center_element].content.e[xx][yy] != EL_EMPTY) - Store[x][y] = element_info[center_element].content.e[xx][yy]; - else if (element == EL_WALL_EMERALD) - Store[x][y] = EL_EMERALD; - else if (element == EL_WALL_DIAMOND) - Store[x][y] = EL_DIAMOND; - else if (element == EL_WALL_BD_DIAMOND) - Store[x][y] = EL_BD_DIAMOND; - else if (element == EL_WALL_EMERALD_YELLOW) - Store[x][y] = EL_EMERALD_YELLOW; - else if (element == EL_WALL_EMERALD_RED) - Store[x][y] = EL_EMERALD_RED; - else if (element == EL_WALL_EMERALD_PURPLE) - Store[x][y] = EL_EMERALD_PURPLE; - else if (element == EL_WALL_PEARL) - Store[x][y] = EL_PEARL; - else if (element == EL_WALL_CRYSTAL) - Store[x][y] = EL_CRYSTAL; - else if (IS_CUSTOM_ELEMENT(element) && !CAN_EXPLODE(element)) - Store[x][y] = element_info[element].content.e[1][1]; - else - Store[x][y] = EL_EMPTY; -#endif if (x != ex || y != ey || mode == EX_TYPE_BORDER || center_element == EL_AMOEBA_TO_DIAMOND) @@ -4292,11 +5944,6 @@ void Explode(int ex, int ey, int phase, int mode) Feld[x][y] = EL_EXPLOSION; GfxElement[x][y] = artwork_element; -#if 0 - printf(":: setting gfx(%d,%d) to %d ['%s']\n", - x, y, artwork_element, EL_NAME(artwork_element)); -#endif - ExplodePhase[x][y] = 1; ExplodeDelay[x][y] = last_phase; @@ -4425,12 +6072,12 @@ void Explode(int ex, int ey, int phase, int mode) InitField_WithBug2(x, y, FALSE); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); TestIfElementTouchesCustomElement(x, y); if (GFX_CRUMBLED(element)) - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present) StorePlayer[x][y] = 0; @@ -4444,7 +6091,7 @@ void Explode(int ex, int ey, int phase, int mode) int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]); if (phase == delay) - DrawLevelFieldCrumbledSand(x, y); + TEST_DrawLevelFieldCrumbledSand(x, y); if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY) { @@ -4521,8 +6168,12 @@ void Bang(int x, int y) { struct PlayerInfo *player = PLAYERINFO(x, y); +#if USE_FIX_CE_ACTION_WITH_PLAYER + element = Feld[x][y] = player->initial_element; +#else element = Feld[x][y] = (player->use_murphy ? EL_SP_MURPHY : player->element_nr); +#endif if (level.use_explosion_element[player->index_nr]) { @@ -4535,7 +6186,7 @@ void Bang(int x, int y) } } - switch(element) + switch (element) { case EL_BUG: case EL_SPACESHIP: @@ -4559,6 +6210,14 @@ void Bang(int x, int y) explosion_type = EX_TYPE_DYNA; break; + case EL_DC_LANDMINE: +#if 0 + case EL_EM_EXIT_OPEN: + case EL_EM_STEEL_EXIT_OPEN: +#endif + explosion_type = EX_TYPE_CENTER; + break; + case EL_PENGUIN: case EL_LAMP: case EL_LAMP_ACTIVE: @@ -4625,20 +6284,23 @@ static void InitBeltMovement() for (j = 0; j < NUM_BELT_PARTS; j++) { int element = belt_base_active_element[belt_nr] + j; - int graphic = el2img(element); + int graphic_1 = el2img(element); + int graphic_2 = el2panelimg(element); if (game.belt_dir[i] == MV_LEFT) - graphic_info[graphic].anim_mode &= ~ANIM_REVERSE; + { + graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE; + graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE; + } else - graphic_info[graphic].anim_mode |= ANIM_REVERSE; + { + graphic_info[graphic_1].anim_mode |= ANIM_REVERSE; + graphic_info[graphic_2].anim_mode |= ANIM_REVERSE; + } } } -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { int element = Feld[x][y]; @@ -4710,19 +6372,22 @@ static void ToggleBeltSwitch(int x, int y) for (i = 0; i < NUM_BELT_PARTS; i++) { int element = belt_base_active_element[belt_nr] + i; - int graphic = el2img(element); + int graphic_1 = el2img(element); + int graphic_2 = el2panelimg(element); if (belt_dir == MV_LEFT) - graphic_info[graphic].anim_mode &= ~ANIM_REVERSE; + { + graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE; + graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE; + } else - graphic_info[graphic].anim_mode |= ANIM_REVERSE; + { + graphic_info[graphic_1].anim_mode |= ANIM_REVERSE; + graphic_info[graphic_2].anim_mode |= ANIM_REVERSE; + } } -#if 1 SCAN_PLAYFIELD(xx, yy) -#else - for (yy = 0; yy < lev_fieldy; yy++) for (xx = 0; xx < lev_fieldx; xx++) -#endif { int element = Feld[xx][yy]; @@ -4733,7 +6398,7 @@ static void ToggleBeltSwitch(int x, int y) if (e_belt_nr == belt_nr) { Feld[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); } } else if (IS_BELT(element) && belt_dir != MV_NONE) @@ -4745,7 +6410,7 @@ static void ToggleBeltSwitch(int x, int y) int belt_part = Feld[xx][yy] - belt_base_element[belt_nr]; Feld[xx][yy] = belt_base_active_element[belt_nr] + belt_part; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); } } else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE) @@ -4757,7 +6422,7 @@ static void ToggleBeltSwitch(int x, int y) int belt_part = Feld[xx][yy] - belt_base_active_element[belt_nr]; Feld[xx][yy] = belt_base_element[belt_nr] + belt_part; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); } } } @@ -4769,11 +6434,7 @@ static void ToggleSwitchgateSwitch(int x, int y) game.switchgate_pos = !game.switchgate_pos; -#if 1 SCAN_PLAYFIELD(xx, yy) -#else - for (yy = 0; yy < lev_fieldy; yy++) for (xx = 0; xx < lev_fieldx; xx++) -#endif { int element = Feld[xx][yy]; @@ -4782,18 +6443,34 @@ static void ToggleSwitchgateSwitch(int x, int y) element == EL_SWITCHGATE_SWITCH_DOWN) { Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); + } + else if (element == EL_DC_SWITCHGATE_SWITCH_UP || + element == EL_DC_SWITCHGATE_SWITCH_DOWN) + { + Feld[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP + game.switchgate_pos; + TEST_DrawLevelField(xx, yy); } #else if (element == EL_SWITCHGATE_SWITCH_UP) { Feld[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); } else if (element == EL_SWITCHGATE_SWITCH_DOWN) { Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); + } + else if (element == EL_DC_SWITCHGATE_SWITCH_UP) + { + Feld[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN; + TEST_DrawLevelField(xx, yy); + } + else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN) + { + Feld[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP; + TEST_DrawLevelField(xx, yy); } #endif else if (element == EL_SWITCHGATE_OPEN || @@ -4833,11 +6510,7 @@ static void RedrawAllLightSwitchesAndInvisibleElements() { int x, y; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { int element = Feld[x][y]; @@ -4845,25 +6518,25 @@ static void RedrawAllLightSwitchesAndInvisibleElements() game.light_time_left > 0) { Feld[x][y] = EL_LIGHT_SWITCH_ACTIVE; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_LIGHT_SWITCH_ACTIVE && game.light_time_left == 0) { Feld[x][y] = EL_LIGHT_SWITCH; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_EMC_DRIPPER && game.light_time_left > 0) { Feld[x][y] = EL_EMC_DRIPPER_ACTIVE; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_EMC_DRIPPER_ACTIVE && game.light_time_left == 0) { Feld[x][y] = EL_EMC_DRIPPER; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_INVISIBLE_STEELWALL || element == EL_INVISIBLE_WALL || @@ -4872,11 +6545,11 @@ static void RedrawAllLightSwitchesAndInvisibleElements() if (game.light_time_left > 0) Feld[x][y] = getInvisibleActiveFromInvisibleElement(element); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); /* uncrumble neighbour fields, if needed */ if (element == EL_INVISIBLE_SAND) - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); } else if (element == EL_INVISIBLE_STEELWALL_ACTIVE || element == EL_INVISIBLE_WALL_ACTIVE || @@ -4885,11 +6558,11 @@ static void RedrawAllLightSwitchesAndInvisibleElements() if (game.light_time_left == 0) Feld[x][y] = getInvisibleFromInvisibleActiveElement(element); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); /* re-crumble neighbour fields, if needed */ if (element == EL_INVISIBLE_SAND) - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); } } } @@ -4898,11 +6571,7 @@ static void RedrawAllInvisibleElementsForLenses() { int x, y; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { int element = Feld[x][y]; @@ -4910,13 +6579,13 @@ static void RedrawAllInvisibleElementsForLenses() game.lenses_time_left > 0) { Feld[x][y] = EL_EMC_DRIPPER_ACTIVE; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_EMC_DRIPPER_ACTIVE && game.lenses_time_left == 0) { Feld[x][y] = EL_EMC_DRIPPER; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_INVISIBLE_STEELWALL || element == EL_INVISIBLE_WALL || @@ -4925,11 +6594,11 @@ static void RedrawAllInvisibleElementsForLenses() if (game.lenses_time_left > 0) Feld[x][y] = getInvisibleActiveFromInvisibleElement(element); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); /* uncrumble neighbour fields, if needed */ if (element == EL_INVISIBLE_SAND) - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); } else if (element == EL_INVISIBLE_STEELWALL_ACTIVE || element == EL_INVISIBLE_WALL_ACTIVE || @@ -4938,11 +6607,11 @@ static void RedrawAllInvisibleElementsForLenses() if (game.lenses_time_left == 0) Feld[x][y] = getInvisibleFromInvisibleActiveElement(element); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); /* re-crumble neighbour fields, if needed */ if (element == EL_INVISIBLE_SAND) - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); } } } @@ -4951,11 +6620,7 @@ static void RedrawAllInvisibleElementsForMagnifier() { int x, y; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { int element = Feld[x][y]; @@ -4963,13 +6628,13 @@ static void RedrawAllInvisibleElementsForMagnifier() game.magnify_time_left > 0) { Feld[x][y] = EL_EMC_FAKE_GRASS_ACTIVE; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_EMC_FAKE_GRASS_ACTIVE && game.magnify_time_left == 0) { Feld[x][y] = EL_EMC_FAKE_GRASS; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (IS_GATE_GRAY(element) && game.magnify_time_left > 0) @@ -4980,8 +6645,10 @@ static void RedrawAllInvisibleElementsForMagnifier() element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE : IS_EMC_GATE_GRAY(element) ? element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE : + IS_DC_GATE_GRAY(element) ? + EL_DC_GATE_WHITE_GRAY_ACTIVE : element); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (IS_GATE_GRAY_ACTIVE(element) && game.magnify_time_left == 0) @@ -4992,8 +6659,10 @@ static void RedrawAllInvisibleElementsForMagnifier() element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY : IS_EMC_GATE_GRAY_ACTIVE(element) ? element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY : + IS_DC_GATE_GRAY_ACTIVE(element) ? + EL_DC_GATE_WHITE_GRAY : element); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } } } @@ -5015,11 +6684,7 @@ static void ActivateTimegateSwitch(int x, int y) game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND; -#if 1 SCAN_PLAYFIELD(xx, yy) -#else - for (yy = 0; yy < lev_fieldy; yy++) for (xx = 0; xx < lev_fieldx; xx++) -#endif { int element = Feld[xx][yy]; @@ -5027,20 +6692,25 @@ static void ActivateTimegateSwitch(int x, int y) element == EL_TIMEGATE_CLOSING) { Feld[xx][yy] = EL_TIMEGATE_OPENING; - PlayLevelSound(xx, yy, SND_TIMEGATE_OPENING); + PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING); } /* else if (element == EL_TIMEGATE_SWITCH_ACTIVE) { Feld[xx][yy] = EL_TIMEGATE_SWITCH; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); } */ } +#if 1 + Feld[x][y] = (Feld[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE : + EL_DC_TIMEGATE_SWITCH_ACTIVE); +#else Feld[x][y] = EL_TIMEGATE_SWITCH_ACTIVE; +#endif } void Impact(int x, int y) @@ -5071,7 +6741,17 @@ void Impact(int x, int y) RemoveMovingField(x, y + 1); Feld[x][y + 1] = EL_QUICKSAND_EMPTY; Feld[x][y + 2] = EL_ROCK; - DrawLevelField(x, y + 2); + TEST_DrawLevelField(x, y + 2); + + object_hit = TRUE; + } + + if (Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE) + { + RemoveMovingField(x, y + 1); + Feld[x][y + 1] = EL_QUICKSAND_FAST_EMPTY; + Feld[x][y + 2] = EL_ROCK; + TEST_DrawLevelField(x, y + 2); object_hit = TRUE; } @@ -5095,7 +6775,7 @@ void Impact(int x, int y) el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element)) { ResetGfxAnimation(x, y); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } if (impact && CAN_EXPLODE_IMPACT(element)) @@ -5103,7 +6783,8 @@ void Impact(int x, int y) Bang(x, y); return; } - else if (impact && element == EL_PEARL) + else if (impact && element == EL_PEARL && + smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE) { ResetGfxAnimation(x, y); @@ -5136,30 +6817,33 @@ void Impact(int x, int y) if (object_hit) /* check which object was hit */ { - if (CAN_PASS_MAGIC_WALL(element) && - (smashed == EL_MAGIC_WALL || - smashed == EL_BD_MAGIC_WALL)) + if ((CAN_PASS_MAGIC_WALL(element) && + (smashed == EL_MAGIC_WALL || + smashed == EL_BD_MAGIC_WALL)) || + (CAN_PASS_DC_MAGIC_WALL(element) && + smashed == EL_DC_MAGIC_WALL)) { int xx, yy; int activated_magic_wall = (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE : - EL_BD_MAGIC_WALL_ACTIVE); + smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE : + EL_DC_MAGIC_WALL_ACTIVE); /* activate magic wall / mill */ -#if 1 SCAN_PLAYFIELD(xx, yy) -#else - for (yy = 0; yy < lev_fieldy; yy++) for (xx = 0; xx < lev_fieldx; xx++) -#endif + { if (Feld[xx][yy] == smashed) Feld[xx][yy] = activated_magic_wall; + } game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND; game.magic_wall_active = TRUE; PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ? SND_MAGIC_WALL_ACTIVATING : - SND_BD_MAGIC_WALL_ACTIVATING)); + smashed == EL_BD_MAGIC_WALL ? + SND_BD_MAGIC_WALL_ACTIVATING : + SND_DC_MAGIC_WALL_ACTIVATING)); } if (IS_PLAYER(x, y + 1)) @@ -5239,7 +6923,9 @@ void Impact(int x, int y) ToggleBeltSwitch(x, y + 1); } else if (smashed == EL_SWITCHGATE_SWITCH_UP || - smashed == EL_SWITCHGATE_SWITCH_DOWN) + smashed == EL_SWITCHGATE_SWITCH_DOWN || + smashed == EL_DC_SWITCHGATE_SWITCH_UP || + smashed == EL_DC_SWITCHGATE_SWITCH_DOWN) { ToggleSwitchgateSwitch(x, y + 1); } @@ -5272,12 +6958,15 @@ void Impact(int x, int y) /* play sound of magic wall / mill */ if (!last_line && (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE || - Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) + Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE || + Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)) { if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE) PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING); else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE) PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING); + else if (Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE) + PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING); return; } @@ -5560,7 +7249,7 @@ inline static void TurnRoundExt(int x, int y) { Feld[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE; ResetGfxAnimation(move_x, move_y); - DrawLevelField(move_x, move_y); + TEST_DrawLevelField(move_x, move_y); MovDir[x][y] = back_dir; } @@ -5634,7 +7323,10 @@ inline static void TurnRoundExt(int x, int y) int ex = x + xy[i][0]; int ey = y + xy[i][1]; - if (IN_LEV_FIELD(ex, ey) && Feld[ex][ey] == EL_EXIT_OPEN) + if (IN_LEV_FIELD(ex, ey) && (Feld[ex][ey] == EL_EXIT_OPEN || + Feld[ex][ey] == EL_EM_EXIT_OPEN || + Feld[ex][ey] == EL_STEEL_EXIT_OPEN || + Feld[ex][ey] == EL_EM_STEEL_EXIT_OPEN)) { attr_x = ex; attr_y = ey; @@ -6101,9 +7793,6 @@ inline static void TurnRoundExt(int x, int y) static void TurnRound(int x, int y) { int direction = MovDir[x][y]; -#if 0 - int element, graphic; -#endif TurnRoundExt(x, y); @@ -6115,21 +7804,7 @@ static void TurnRound(int x, int y) if (MovDelay[x][y]) GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction); -#if 1 ResetGfxFrame(x, y, FALSE); -#else - element = Feld[x][y]; - graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); - - if (graphic_info[graphic].anim_global_sync) - GfxFrame[x][y] = FrameCounter; - else if (ANIM_MODE(graphic) == ANIM_CE_VALUE) - GfxFrame[x][y] = CustomValue[x][y]; - else if (ANIM_MODE(graphic) == ANIM_CE_SCORE) - GfxFrame[x][y] = element_info[element].collect_score; - else if (ANIM_MODE(graphic) == ANIM_CE_DELAY) - GfxFrame[x][y] = ChangeDelay[x][y]; -#endif } static boolean JustBeingPushed(int x, int y) @@ -6191,16 +7866,123 @@ void StartMoving(int x, int y) else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY) { if (!MovDelay[x][y]) + { + MovDelay[x][y] = TILEY + 1; + + ResetGfxAnimation(x, y); + ResetGfxAnimation(x, y + 1); + } + + if (MovDelay[x][y]) + { + DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING); + DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING); + + MovDelay[x][y]--; + if (MovDelay[x][y]) + return; + } + + Feld[x][y] = EL_QUICKSAND_EMPTY; + Feld[x][y + 1] = EL_QUICKSAND_FULL; + Store[x][y + 1] = Store[x][y]; + Store[x][y] = 0; + + PlayLevelSoundAction(x, y, ACTION_FILLING); + } + else if (Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTY) + { + if (!MovDelay[x][y]) + { MovDelay[x][y] = TILEY + 1; + ResetGfxAnimation(x, y); + ResetGfxAnimation(x, y + 1); + } + if (MovDelay[x][y]) { + DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING); + DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING); + MovDelay[x][y]--; if (MovDelay[x][y]) return; } Feld[x][y] = EL_QUICKSAND_EMPTY; + Feld[x][y + 1] = EL_QUICKSAND_FAST_FULL; + Store[x][y + 1] = Store[x][y]; + Store[x][y] = 0; + + PlayLevelSoundAction(x, y, ACTION_FILLING); + } + } + else if (element == EL_QUICKSAND_FAST_FULL) + { + if (IS_FREE(x, y + 1)) + { + InitMovingField(x, y, MV_DOWN); + started_moving = TRUE; + + Feld[x][y] = EL_QUICKSAND_FAST_EMPTYING; +#if USE_QUICKSAND_BD_ROCK_BUGFIX + if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK) + Store[x][y] = EL_ROCK; +#else + Store[x][y] = EL_ROCK; +#endif + + PlayLevelSoundAction(x, y, ACTION_EMPTYING); + } + else if (Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTY) + { + if (!MovDelay[x][y]) + { + MovDelay[x][y] = TILEY + 1; + + ResetGfxAnimation(x, y); + ResetGfxAnimation(x, y + 1); + } + + if (MovDelay[x][y]) + { + DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING); + DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING); + + MovDelay[x][y]--; + if (MovDelay[x][y]) + return; + } + + Feld[x][y] = EL_QUICKSAND_FAST_EMPTY; + Feld[x][y + 1] = EL_QUICKSAND_FAST_FULL; + Store[x][y + 1] = Store[x][y]; + Store[x][y] = 0; + + PlayLevelSoundAction(x, y, ACTION_FILLING); + } + else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY) + { + if (!MovDelay[x][y]) + { + MovDelay[x][y] = TILEY + 1; + + ResetGfxAnimation(x, y); + ResetGfxAnimation(x, y + 1); + } + + if (MovDelay[x][y]) + { + DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING); + DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING); + + MovDelay[x][y]--; + if (MovDelay[x][y]) + return; + } + + Feld[x][y] = EL_QUICKSAND_FAST_EMPTY; Feld[x][y + 1] = EL_QUICKSAND_FULL; Store[x][y + 1] = Store[x][y]; Store[x][y] = 0; @@ -6219,6 +8001,17 @@ void StartMoving(int x, int y) PlayLevelSoundAction(x, y, ACTION_FILLING); } + else if ((element == EL_ROCK || element == EL_BD_ROCK) && + Feld[x][y + 1] == EL_QUICKSAND_FAST_EMPTY) + { + InitMovingField(x, y, MV_DOWN); + started_moving = TRUE; + + Feld[x][y] = EL_QUICKSAND_FAST_FILLING; + Store[x][y] = element; + + PlayLevelSoundAction(x, y, ACTION_FILLING); + } else if (element == EL_MAGIC_WALL_FULL) { if (IS_FREE(x, y + 1)) @@ -6226,10 +8019,38 @@ void StartMoving(int x, int y) InitMovingField(x, y, MV_DOWN); started_moving = TRUE; - Feld[x][y] = EL_MAGIC_WALL_EMPTYING; - Store[x][y] = EL_CHANGED(Store[x][y]); + Feld[x][y] = EL_MAGIC_WALL_EMPTYING; + Store[x][y] = EL_CHANGED(Store[x][y]); + } + else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE) + { + if (!MovDelay[x][y]) + MovDelay[x][y] = TILEY/4 + 1; + + if (MovDelay[x][y]) + { + MovDelay[x][y]--; + if (MovDelay[x][y]) + return; + } + + Feld[x][y] = EL_MAGIC_WALL_ACTIVE; + Feld[x][y + 1] = EL_MAGIC_WALL_FULL; + Store[x][y + 1] = EL_CHANGED(Store[x][y]); + Store[x][y] = 0; + } + } + else if (element == EL_BD_MAGIC_WALL_FULL) + { + if (IS_FREE(x, y + 1)) + { + InitMovingField(x, y, MV_DOWN); + started_moving = TRUE; + + Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING; + Store[x][y] = EL_CHANGED_BD(Store[x][y]); } - else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE) + else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE) { if (!MovDelay[x][y]) MovDelay[x][y] = TILEY/4 + 1; @@ -6241,23 +8062,23 @@ void StartMoving(int x, int y) return; } - Feld[x][y] = EL_MAGIC_WALL_ACTIVE; - Feld[x][y + 1] = EL_MAGIC_WALL_FULL; - Store[x][y + 1] = EL_CHANGED(Store[x][y]); + Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE; + Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL; + Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]); Store[x][y] = 0; } } - else if (element == EL_BD_MAGIC_WALL_FULL) + else if (element == EL_DC_MAGIC_WALL_FULL) { if (IS_FREE(x, y + 1)) { InitMovingField(x, y, MV_DOWN); started_moving = TRUE; - Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING; - Store[x][y] = EL_CHANGED2(Store[x][y]); + Feld[x][y] = EL_DC_MAGIC_WALL_EMPTYING; + Store[x][y] = EL_CHANGED_DC(Store[x][y]); } - else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE) + else if (Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE) { if (!MovDelay[x][y]) MovDelay[x][y] = TILEY/4 + 1; @@ -6269,22 +8090,26 @@ void StartMoving(int x, int y) return; } - Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE; - Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL; - Store[x][y + 1] = EL_CHANGED2(Store[x][y]); + Feld[x][y] = EL_DC_MAGIC_WALL_ACTIVE; + Feld[x][y + 1] = EL_DC_MAGIC_WALL_FULL; + Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]); Store[x][y] = 0; } } - else if (CAN_PASS_MAGIC_WALL(element) && - (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE || - Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) + else if ((CAN_PASS_MAGIC_WALL(element) && + (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE || + Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) || + (CAN_PASS_DC_MAGIC_WALL(element) && + (Feld[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))) + { InitMovingField(x, y, MV_DOWN); started_moving = TRUE; Feld[x][y] = (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING : - EL_BD_MAGIC_WALL_FILLING); + Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING : + EL_DC_MAGIC_WALL_FILLING); Store[x][y] = element; } else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID) @@ -6296,9 +8121,14 @@ void StartMoving(int x, int y) Store[x][y] = EL_ACID; } - else if ((game.engine_version >= VERSION_IDENT(3,1,0,0) && + else if ( +#if USE_FIX_IMPACT_COLLISION + (game.engine_version >= VERSION_IDENT(3,1,0,0) && + CheckImpact[x][y] && !IS_FREE(x, y + 1)) || +#else + (game.engine_version >= VERSION_IDENT(3,1,0,0) && CheckCollision[x][y] && !IS_FREE(x, y + 1)) || - +#endif (game.engine_version >= VERSION_IDENT(3,0,7,0) && CAN_FALL(element) && WasJustFalling[x][y] && (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) || @@ -6318,6 +8148,7 @@ void StartMoving(int x, int y) simply not covered here... :-/ ) */ CheckCollision[x][y] = 0; + CheckImpact[x][y] = 0; Impact(x, y); } @@ -6523,7 +8354,7 @@ void StartMoving(int x, int y) element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON || element == EL_MOLE)) - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } } @@ -6557,7 +8388,7 @@ void StartMoving(int x, int y) if (IS_PLAYER(x, y)) DrawPlayerField(x, y); else - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING); @@ -6597,7 +8428,7 @@ void StartMoving(int x, int y) if (IN_SCR_FIELD(sx, sy)) { - DrawLevelFieldCrumbledSand(xx, yy); + TEST_DrawLevelFieldCrumbledSand(xx, yy); DrawGraphic(sx, sy, flame_graphic, frame); } } @@ -6605,7 +8436,7 @@ void StartMoving(int x, int y) { if (Feld[xx][yy] == EL_FLAMES) Feld[xx][yy] = EL_EMPTY; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); } } } @@ -6642,10 +8473,13 @@ void StartMoving(int x, int y) } else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy)) { - if (Feld[newx][newy] == EL_EXIT_OPEN) + if (Feld[newx][newy] == EL_EXIT_OPEN || + Feld[newx][newy] == EL_EM_EXIT_OPEN || + Feld[newx][newy] == EL_STEEL_EXIT_OPEN || + Feld[newx][newy] == EL_EM_STEEL_EXIT_OPEN) { RemoveField(x, y); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); PlayLevelSound(newx, newy, SND_PENGUIN_PASSING); if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy))) @@ -6654,14 +8488,14 @@ void StartMoving(int x, int y) local_player->friends_still_needed--; if (!local_player->friends_still_needed && !local_player->GameOver && AllPlayersGone) - local_player->LevelSolved = local_player->GameOver = TRUE; + PlayerWins(local_player); return; } else if (IS_FOOD_PENGUIN(Feld[newx][newy])) { if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING) - DrawLevelField(newx, newy); + TEST_DrawLevelField(newx, newy); else GfxDir[x][y] = MovDir[x][y] = MV_NONE; } @@ -6672,7 +8506,7 @@ void StartMoving(int x, int y) if (IS_PLAYER(x, y)) DrawPlayerField(x, y); else - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); return; } @@ -6686,7 +8520,7 @@ void StartMoving(int x, int y) else { Feld[newx][newy] = EL_EMPTY; - DrawLevelField(newx, newy); + TEST_DrawLevelField(newx, newy); } PlayLevelSound(x, y, SND_PIG_DIGGING); @@ -6696,7 +8530,7 @@ void StartMoving(int x, int y) if (IS_PLAYER(x, y)) DrawPlayerField(x, y); else - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); return; } @@ -6775,7 +8609,7 @@ void StartMoving(int x, int y) else { Feld[newx][newy] = EL_EMPTY; - DrawLevelField(newx, newy); + TEST_DrawLevelField(newx, newy); PlayLevelSoundAction(x, y, ACTION_DIGGING); } @@ -6786,7 +8620,7 @@ void StartMoving(int x, int y) if (IS_PLAYER(x, y)) DrawPlayerField(x, y); else - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); #endif return; @@ -6795,6 +8629,10 @@ void StartMoving(int x, int y) else if (IS_CUSTOM_ELEMENT(element) && CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy)) { +#if 1 + if (!DigFieldByCE(newx, newy, element)) + return; +#else int new_element = Feld[newx][newy]; if (!IS_FREE(newx, newy)) @@ -6823,7 +8661,7 @@ void StartMoving(int x, int y) else { RemoveField(newx, newy); - DrawLevelField(newx, newy); + TEST_DrawLevelField(newx, newy); } /* if digged element was about to explode, prevent the explosion */ @@ -6833,6 +8671,7 @@ void StartMoving(int x, int y) } Store[newx][newy] = EL_EMPTY; + #if 1 /* this makes it possible to leave the removed element again */ if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element))) @@ -6846,6 +8685,8 @@ void StartMoving(int x, int y) Store[newx][newy] = (move_leave_element == EL_TRIGGER_ELEMENT ? new_element : move_leave_element); } +#endif + #endif if (move_pattern & MV_MAZE_RUNNER_STYLE) @@ -6861,7 +8702,7 @@ void StartMoving(int x, int y) if (IS_PLAYER(x, y)) DrawPlayerField(x, y); else - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); return; } @@ -6888,7 +8729,7 @@ void StartMoving(int x, int y) if (IS_PLAYER(x, y)) DrawPlayerField(x, y); else - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); PlayLevelSound(x, y, SND_DRAGON_ATTACKING); @@ -6926,7 +8767,7 @@ void StartMoving(int x, int y) else { Feld[newx][newy] = EL_EMPTY; - DrawLevelField(newx, newy); + TEST_DrawLevelField(newx, newy); } PlayLevelSound(x, y, SND_YAMYAM_DIGGING); @@ -6957,7 +8798,7 @@ void StartMoving(int x, int y) else { Feld[newx][newy] = EL_EMPTY; - DrawLevelField(newx, newy); + TEST_DrawLevelField(newx, newy); } PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING); @@ -6980,7 +8821,7 @@ void StartMoving(int x, int y) ResetGfxAnimation(x, y); GfxAction[x][y] = ACTION_DIGGING; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); MovDelay[newx][newy] = 0; /* start amoeba shrinking delay */ @@ -6989,7 +8830,7 @@ void StartMoving(int x, int y) else /* element == EL_PACMAN */ { Feld[newx][newy] = EL_EMPTY; - DrawLevelField(newx, newy); + TEST_DrawLevelField(newx, newy); PlayLevelSound(x, y, SND_PACMAN_DIGGING); } } @@ -7060,7 +8901,18 @@ void ContinueMoving(int x, int y) if (ABS(MovPos[x][y]) < TILEX) { - DrawLevelField(x, y); +#if 0 + int ee = Feld[x][y]; + int gg = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); + int ff = getGraphicAnimationFrame(gg, GfxFrame[x][y]); + + printf("::: %d.%d: moving %d ... [%d, %d, %d] [%d, %d, %d]\n", + x, y, ABS(MovPos[x][y]), + ee, gg, ff, + GfxAction[x][y], GfxDir[x][y], GfxFrame[x][y]); +#endif + + TEST_DrawLevelField(x, y); return; /* element is still moving */ } @@ -7079,7 +8931,7 @@ void ContinueMoving(int x, int y) { Feld[x][y] = EL_SAND; - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); } else if (element == EL_QUICKSAND_FILLING) { @@ -7091,6 +8943,16 @@ void ContinueMoving(int x, int y) Feld[x][y] = get_next_element(element); element = Feld[newx][newy] = Store[x][y]; } + else if (element == EL_QUICKSAND_FAST_FILLING) + { + element = Feld[newx][newy] = get_next_element(element); + Store[newx][newy] = Store[x][y]; + } + else if (element == EL_QUICKSAND_FAST_EMPTYING) + { + Feld[x][y] = get_next_element(element); + element = Feld[newx][newy] = Store[x][y]; + } else if (element == EL_MAGIC_WALL_FILLING) { element = Feld[newx][newy] = get_next_element(element); @@ -7123,6 +8985,24 @@ void ContinueMoving(int x, int y) Feld[x][y] = EL_BD_MAGIC_WALL_DEAD; element = Feld[newx][newy] = Store[x][y]; +#if USE_NEW_CUSTOM_VALUE + InitField(newx, newy, FALSE); +#endif + } + else if (element == EL_DC_MAGIC_WALL_FILLING) + { + element = Feld[newx][newy] = get_next_element(element); + if (!game.magic_wall_active) + element = Feld[newx][newy] = EL_DC_MAGIC_WALL_DEAD; + Store[newx][newy] = Store[x][y]; + } + else if (element == EL_DC_MAGIC_WALL_EMPTYING) + { + Feld[x][y] = get_next_element(element); + if (!game.magic_wall_active) + Feld[x][y] = EL_DC_MAGIC_WALL_DEAD; + element = Feld[newx][newy] = Store[x][y]; + #if USE_NEW_CUSTOM_VALUE InitField(newx, newy, FALSE); #endif @@ -7150,29 +9030,17 @@ void ContinueMoving(int x, int y) MovDelay[newx][newy] = 0; -#if 1 if (CAN_CHANGE_OR_HAS_ACTION(element)) -#else - if (CAN_CHANGE(element)) -#endif { /* copy element change control values to new field */ ChangeDelay[newx][newy] = ChangeDelay[x][y]; ChangePage[newx][newy] = ChangePage[x][y]; ChangeCount[newx][newy] = ChangeCount[x][y]; ChangeEvent[newx][newy] = ChangeEvent[x][y]; - -#if 0 -#if USE_NEW_CUSTOM_VALUE - CustomValue[newx][newy] = CustomValue[x][y]; -#endif -#endif } -#if 1 #if USE_NEW_CUSTOM_VALUE - CustomValue[newx][newy] = CustomValue[x][y]; -#endif + CustomValue[newx][newy] = CustomValue[x][y]; #endif ChangeDelay[x][y] = 0; @@ -7230,7 +9098,7 @@ void ContinueMoving(int x, int y) InitField(x, y, FALSE); if (GFX_CRUMBLED(Feld[x][y])) - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); if (ELEM_IS_PLAYER(move_leave_element)) RelocatePlayer(x, y, move_leave_element); @@ -7246,8 +9114,8 @@ void ContinueMoving(int x, int y) element_info[element].move_pattern == MV_WHEN_DROPPED))) GfxDir[x][y] = MovDir[newx][newy] = 0; - DrawLevelField(x, y); - DrawLevelField(newx, newy); + TEST_DrawLevelField(x, y); + TEST_DrawLevelField(newx, newy); Stop[newx][newy] = TRUE; /* ignore this element until the next frame */ @@ -7274,6 +9142,11 @@ void ContinueMoving(int x, int y) if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again) CheckCollision[newx][newy] = CHECK_DELAY_COLLISION; + +#if USE_FIX_IMPACT_COLLISION + if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again) + CheckImpact[newx][newy] = CHECK_DELAY_IMPACT; +#endif } if (DONT_TOUCH(element)) /* object may be nasty to player or others */ @@ -7287,6 +9160,11 @@ void ContinueMoving(int x, int y) else if (element == EL_PENGUIN) TestIfFriendTouchesBadThing(newx, newy); + if (DONT_GET_HIT_BY(element)) + { + TestIfGoodThingGetsHitByBadThing(newx, newy, direction); + } + /* give the player one last chance (one more frame) to move away */ if (CAN_FALL(element) && direction == MV_DOWN && (last_line || (!IS_FREE(x, newy + 1) && @@ -7338,12 +9216,10 @@ void ContinueMoving(int x, int y) TestIfPlayerTouchesCustomElement(newx, newy); TestIfElementTouchesCustomElement(newx, newy); -#if 1 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY && IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element)) CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X, - MV_DIR_OPPOSITE(direction)); -#endif + MV_DIR_OPPOSITE(direction)); } int AmoebeNachbarNr(int ax, int ay) @@ -7412,11 +9288,7 @@ void AmoebenVereinigen(int ax, int ay) AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr]; AmoebaCnt2[old_group_nr] = 0; -#if 1 SCAN_PLAYFIELD(xx, yy) -#else - for (yy = 0; yy < lev_fieldy; yy++) for (xx = 0; xx < lev_fieldx; xx++) -#endif { if (AmoebaNr[xx][yy] == old_group_nr) AmoebaNr[xx][yy] = new_group_nr; @@ -7442,11 +9314,7 @@ void AmoebeUmwandeln(int ax, int ay) } #endif -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr) { @@ -7504,11 +9372,7 @@ void AmoebeUmwandelnBD(int ax, int ay, int new_element) } #endif -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { if (AmoebaNr[x][y] == group_nr && (Feld[x][y] == EL_AMOEBA_DEAD || @@ -7518,7 +9382,7 @@ void AmoebeUmwandelnBD(int ax, int ay, int new_element) AmoebaNr[x][y] = 0; Feld[x][y] = new_element; InitField(x, y, FALSE); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); done = TRUE; } } @@ -7560,7 +9424,7 @@ void AmoebeWaechst(int x, int y) { Feld[x][y] = Store[x][y]; Store[x][y] = 0; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } } } @@ -7592,7 +9456,7 @@ void AmoebaDisappearing(int x, int y) if (!MovDelay[x][y]) { Feld[x][y] = EL_EMPTY; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); /* don't let mole enter this field in this cycle; (give priority to objects falling to this field from above) */ @@ -7619,7 +9483,7 @@ void AmoebeAbleger(int ax, int ay) if (!level.amoeba_speed && element != EL_EMC_DRIPPER) { Feld[ax][ay] = EL_AMOEBA_DEAD; - DrawLevelField(ax, ay); + TEST_DrawLevelField(ax, ay); return; } @@ -7647,7 +9511,8 @@ void AmoebeAbleger(int ax, int ay) if (IS_FREE(x, y) || CAN_GROW_INTO(Feld[x][y]) || - Feld[x][y] == EL_QUICKSAND_EMPTY) + Feld[x][y] == EL_QUICKSAND_EMPTY || + Feld[x][y] == EL_QUICKSAND_FAST_EMPTY) { newax = x; neway = y; @@ -7672,7 +9537,8 @@ void AmoebeAbleger(int ax, int ay) if (IS_FREE(x, y) || CAN_GROW_INTO(Feld[x][y]) || - Feld[x][y] == EL_QUICKSAND_EMPTY) + Feld[x][y] == EL_QUICKSAND_EMPTY || + Feld[x][y] == EL_QUICKSAND_FAST_EMPTY) { newax = x; neway = y; @@ -7687,7 +9553,7 @@ void AmoebeAbleger(int ax, int ay) if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA)) { Feld[ax][ay] = EL_AMOEBA_DEAD; - DrawLevelField(ax, ay); + TEST_DrawLevelField(ax, ay); AmoebaCnt[AmoebaNr[ax][ay]]--; if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) /* amoeba is completely dead */ @@ -7751,15 +9617,12 @@ void AmoebeAbleger(int ax, int ay) return; } - DrawLevelField(newax, neway); + TEST_DrawLevelField(newax, neway); } void Life(int ax, int ay) { int x1, y1, x2, y2; -#if 0 - static int life[4] = { 2, 3, 3, 3 }; /* parameters for "game of life" */ -#endif int life_time = 40; int element = Feld[ax][ay]; int graphic = el2img(element); @@ -7812,7 +9675,7 @@ void Life(int ax, int ay) { Feld[xx][yy] = EL_EMPTY; if (!Stop[xx][yy]) - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); Stop[xx][yy] = TRUE; changed = TRUE; } @@ -7825,7 +9688,7 @@ void Life(int ax, int ay) Feld[xx][yy] = element; MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1); if (!Stop[xx][yy]) - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); Stop[xx][yy] = TRUE; changed = TRUE; } @@ -7850,7 +9713,11 @@ static void RunRobotWheel(int x, int y) static void StopRobotWheel(int x, int y) { if (ZX == x && ZY == y) + { ZX = ZY = -1; + + game.robot_wheel_active = FALSE; + } } static void InitTimegateWheel(int x, int y) @@ -7860,7 +9727,7 @@ static void InitTimegateWheel(int x, int y) static void RunTimegateWheel(int x, int y) { - PlayLevelSound(x, y, SND_TIMEGATE_SWITCH_ACTIVE); + PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE); } static void InitMagicBallDelay(int x, int y) @@ -7904,13 +9771,6 @@ static void ActivateMagicBall(int bx, int by) game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents; } -static void InitDiagonalMovingElement(int x, int y) -{ -#if 0 - MovDelay[x][y] = level.android_move_time; -#endif -} - void CheckExit(int x, int y) { if (local_player->gems_still_needed > 0 || @@ -7934,6 +9794,75 @@ void CheckExit(int x, int y) PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING); } +void CheckExitEM(int x, int y) +{ + if (local_player->gems_still_needed > 0 || + local_player->sokobanfields_still_needed > 0 || + local_player->lights_still_needed > 0) + { + int element = Feld[x][y]; + int graphic = el2img(element); + + if (IS_ANIMATED(graphic)) + DrawLevelGraphicAnimationIfNeeded(x, y, graphic); + + return; + } + + if (AllPlayersGone) /* do not re-open exit door closed after last player */ + return; + + Feld[x][y] = EL_EM_EXIT_OPENING; + + PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING); +} + +void CheckExitSteel(int x, int y) +{ + if (local_player->gems_still_needed > 0 || + local_player->sokobanfields_still_needed > 0 || + local_player->lights_still_needed > 0) + { + int element = Feld[x][y]; + int graphic = el2img(element); + + if (IS_ANIMATED(graphic)) + DrawLevelGraphicAnimationIfNeeded(x, y, graphic); + + return; + } + + if (AllPlayersGone) /* do not re-open exit door closed after last player */ + return; + + Feld[x][y] = EL_STEEL_EXIT_OPENING; + + PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING); +} + +void CheckExitSteelEM(int x, int y) +{ + if (local_player->gems_still_needed > 0 || + local_player->sokobanfields_still_needed > 0 || + local_player->lights_still_needed > 0) + { + int element = Feld[x][y]; + int graphic = el2img(element); + + if (IS_ANIMATED(graphic)) + DrawLevelGraphicAnimationIfNeeded(x, y, graphic); + + return; + } + + if (AllPlayersGone) /* do not re-open exit door closed after last player */ + return; + + Feld[x][y] = EL_EM_STEEL_EXIT_OPENING; + + PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING); +} + void CheckExitSP(int x, int y) { if (local_player->gems_still_needed > 0) @@ -7959,11 +9888,7 @@ static void CloseAllOpenTimegates() { int x, y; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { int element = Feld[x][y]; @@ -7976,7 +9901,7 @@ static void CloseAllOpenTimegates() } } -void EdelsteinFunkeln(int x, int y) +void DrawTwinkleOnField(int x, int y) { if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y)) return; @@ -7985,15 +9910,12 @@ void EdelsteinFunkeln(int x, int y) return; if (MovDelay[x][y] == 0) /* next animation frame */ - MovDelay[x][y] = 11 * !SimpleRND(500); + MovDelay[x][y] = 11 * !GetSimpleRandom(500); if (MovDelay[x][y] != 0) /* wait some time before next frame */ { MovDelay[x][y]--; - if (setup.direct_draw && MovDelay[x][y]) - SetDrawtoField(DRAW_BUFFERED); - DrawLevelElementAnimation(x, y, Feld[x][y]); if (MovDelay[x][y] != 0) @@ -8002,18 +9924,6 @@ void EdelsteinFunkeln(int x, int y) 10 - MovDelay[x][y]); DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame); - - if (setup.direct_draw) - { - int dest_x, dest_y; - - dest_x = FX + SCREENX(x) * TILEX; - dest_y = FY + SCREENY(y) * TILEY; - - BlitBitmap(drawto_field, window, - dest_x, dest_y, TILEX, TILEY, dest_x, dest_y); - SetDrawtoField(DRAW_DIRECT); - } } } } @@ -8042,28 +9952,28 @@ void MauerWaechst(int x, int y) if (MovDir[x][y] == MV_LEFT) { if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y])) - DrawLevelField(x - 1, y); + TEST_DrawLevelField(x - 1, y); } else if (MovDir[x][y] == MV_RIGHT) { if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y])) - DrawLevelField(x + 1, y); + TEST_DrawLevelField(x + 1, y); } else if (MovDir[x][y] == MV_UP) { if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1])) - DrawLevelField(x, y - 1); + TEST_DrawLevelField(x, y - 1); } else { if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1])) - DrawLevelField(x, y + 1); + TEST_DrawLevelField(x, y + 1); } Feld[x][y] = Store[x][y]; Store[x][y] = 0; GfxDir[x][y] = MovDir[x][y] = MV_NONE; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } } } @@ -8137,25 +10047,128 @@ void MauerAbleger(int ax, int ay) GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT; if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay))) DrawGraphic(SCREENX(ax - 1), SCREENY(ay), - IMG_EXPANDABLE_WALL_GROWING_LEFT, 0); + IMG_EXPANDABLE_WALL_GROWING_LEFT, 0); + new_wall = TRUE; + } + + if (rechts_frei) + { + Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING; + Store[ax+1][ay] = element; + GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT; + if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay))) + DrawGraphic(SCREENX(ax + 1), SCREENY(ay), + IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0); + new_wall = TRUE; + } + } + + if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei)) + TEST_DrawLevelField(ax, ay); + + if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1])) + oben_massiv = TRUE; + if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1])) + unten_massiv = TRUE; + if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay])) + links_massiv = TRUE; + if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay])) + rechts_massiv = TRUE; + + if (((oben_massiv && unten_massiv) || + element == EL_EXPANDABLE_WALL_HORIZONTAL || + element == EL_EXPANDABLE_WALL) && + ((links_massiv && rechts_massiv) || + element == EL_EXPANDABLE_WALL_VERTICAL)) + Feld[ax][ay] = EL_WALL; + + if (new_wall) + PlayLevelSoundAction(ax, ay, ACTION_GROWING); +} + +void MauerAblegerStahl(int ax, int ay) +{ + int element = Feld[ax][ay]; + int graphic = el2img(element); + boolean oben_frei = FALSE, unten_frei = FALSE; + boolean links_frei = FALSE, rechts_frei = FALSE; + boolean oben_massiv = FALSE, unten_massiv = FALSE; + boolean links_massiv = FALSE, rechts_massiv = FALSE; + boolean new_wall = FALSE; + + if (IS_ANIMATED(graphic)) + DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic); + + if (!MovDelay[ax][ay]) /* start building new wall */ + MovDelay[ax][ay] = 6; + + if (MovDelay[ax][ay]) /* wait some time before building new wall */ + { + MovDelay[ax][ay]--; + if (MovDelay[ax][ay]) + return; + } + + if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1)) + oben_frei = TRUE; + if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1)) + unten_frei = TRUE; + if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay)) + links_frei = TRUE; + if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay)) + rechts_frei = TRUE; + + if (element == EL_EXPANDABLE_STEELWALL_VERTICAL || + element == EL_EXPANDABLE_STEELWALL_ANY) + { + if (oben_frei) + { + Feld[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING; + Store[ax][ay-1] = element; + GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP; + if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1))) + DrawGraphic(SCREENX(ax), SCREENY(ay - 1), + IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0); + new_wall = TRUE; + } + if (unten_frei) + { + Feld[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING; + Store[ax][ay+1] = element; + GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN; + if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1))) + DrawGraphic(SCREENX(ax), SCREENY(ay + 1), + IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0); + new_wall = TRUE; + } + } + + if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL || + element == EL_EXPANDABLE_STEELWALL_ANY) + { + if (links_frei) + { + Feld[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING; + Store[ax-1][ay] = element; + GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT; + if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay))) + DrawGraphic(SCREENX(ax - 1), SCREENY(ay), + IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0); new_wall = TRUE; } if (rechts_frei) { - Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING; + Feld[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING; Store[ax+1][ay] = element; GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT; if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay))) DrawGraphic(SCREENX(ax + 1), SCREENY(ay), - IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0); + IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0); new_wall = TRUE; } } - if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei)) - DrawLevelField(ax, ay); - if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1])) oben_massiv = TRUE; if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1])) @@ -8166,11 +10179,10 @@ void MauerAbleger(int ax, int ay) rechts_massiv = TRUE; if (((oben_massiv && unten_massiv) || - element == EL_EXPANDABLE_WALL_HORIZONTAL || - element == EL_EXPANDABLE_WALL) && + element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) && ((links_massiv && rechts_massiv) || - element == EL_EXPANDABLE_WALL_VERTICAL)) - Feld[ax][ay] = EL_WALL; + element == EL_EXPANDABLE_STEELWALL_VERTICAL)) + Feld[ax][ay] = EL_STEELWALL; if (new_wall) PlayLevelSoundAction(ax, ay, ACTION_GROWING); @@ -8216,7 +10228,7 @@ void CheckForDragon(int x, int y) if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES) { Feld[xx][yy] = EL_EMPTY; - DrawLevelField(xx, yy); + TEST_DrawLevelField(xx, yy); } else break; @@ -8280,7 +10292,7 @@ static void ChangeActiveTrap(int x, int y) /* if new animation frame was drawn, correct crumbled sand border */ if (IS_NEW_FRAME(GfxFrame[x][y], graphic)) - DrawLevelFieldCrumbledSand(x, y); + TEST_DrawLevelFieldCrumbledSand(x, y); } static int getSpecialActionElement(int element, int number, int base_element) @@ -8314,6 +10326,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) int action_type = change->action_type; int action_mode = change->action_mode; int action_arg = change->action_arg; + int action_element = change->action_element; int i; if (!change->has_action) @@ -8325,11 +10338,21 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) (level.time > 0 ? TimeLeft : TimePlayed); - int action_arg_element = + int action_arg_element_raw = (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player : action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element : action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element : + action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element : + action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element: + action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element : + action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element : EL_EMPTY); + int action_arg_element = GetElementFromGroupElement(action_arg_element_raw); + +#if 0 + if (action_arg_element_raw == EL_GROUP_START) + printf("::: %d,%d: %d ('%s')\n", x, y, element, EL_NAME(element)); +#endif int action_arg_direction = (action_arg >= CA_ARG_DIRECTION_LEFT && @@ -8358,7 +10381,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) action_type == CA_SET_LEVEL_GEMS ? level.gems_needed : action_type == CA_SET_LEVEL_TIME ? level.time : action_type == CA_SET_LEVEL_SCORE ? 0 : -#if 1 +#if USE_NEW_CUSTOM_VALUE action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) : #else action_type == CA_SET_CE_VALUE ? ei->custom_value_initial : @@ -8386,10 +10409,13 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? local_player->score : action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element): action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value: + action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element): action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) : action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score: + action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) : action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element : action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element : + action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element : -1); int action_arg_number_old = @@ -8405,21 +10431,28 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) action_mode, action_arg_number, action_arg_number_min, action_arg_number_max); +#if 1 + int trigger_player_bits = + (change->actual_trigger_player_bits != CH_PLAYER_NONE ? + change->actual_trigger_player_bits : change->trigger_player); +#else int trigger_player_bits = (change->actual_trigger_player >= EL_PLAYER_1 && change->actual_trigger_player <= EL_PLAYER_4 ? (1 << (change->actual_trigger_player - EL_PLAYER_1)) : PLAYER_BITS_ANY); +#endif int action_arg_player_bits = (action_arg >= CA_ARG_PLAYER_1 && action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER : action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits : + action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) : PLAYER_BITS_ANY); /* ---------- execute action -------------------------------------------- */ - switch(action_type) + switch (action_type) { case CA_NO_ACTION: { @@ -8452,7 +10485,13 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) { TimeLeft = action_arg_number_new; +#if 1 + game_panel_controls[GAME_PANEL_TIME].value = TimeLeft; + + DisplayGameControlValues(); +#else DrawGameValue_Time(TimeLeft); +#endif if (!TimeLeft && setup.time_limit) for (i = 0; i < MAX_PLAYERS; i++) @@ -8466,7 +10505,13 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) { local_player->score = action_arg_number_new; +#if 1 + game_panel_controls[GAME_PANEL_SCORE].value = local_player->score; + + DisplayGameControlValues(); +#else DrawGameValue_Score(local_player->score); +#endif break; } @@ -8475,7 +10520,13 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) { local_player->gems_still_needed = action_arg_number_new; +#if 1 + game_panel_controls[GAME_PANEL_GEMS].value = local_player->gems_still_needed; + + DisplayGameControlValues(); +#else DrawGameValue_Emeralds(local_player->gems_still_needed); +#endif break; } @@ -8498,6 +10549,33 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) break; } + case CA_SET_LEVEL_RANDOM_SEED: + { +#if 1 + /* ensure that setting a new random seed while playing is predictable */ + InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1); +#else + InitRND(action_arg_number_new); +#endif + +#if 0 + printf("::: %d -> %d\n", action_arg_number_new, RND(10)); +#endif + +#if 0 + { + int i; + + printf("::: "); + for (i = 0; i < 9; i++) + printf("%d, ", RND(2)); + printf("\n"); + } +#endif + + break; + } + /* ---------- player actions ------------------------------------------ */ case CA_MOVE_PLAYER: @@ -8514,7 +10592,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) { for (i = 0; i < MAX_PLAYERS; i++) if (action_arg_player_bits & (1 << i)) - stored_player[i].LevelSolved = stored_player[i].GameOver = TRUE; + PlayerWins(&stored_player[i]); break; } @@ -8542,13 +10620,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) { stored_player[i].key[KEY_NR(element)] = key_state; -#if 1 DrawGameDoorValues(); -#else - DrawGameValue_Keys(stored_player[i].key); -#endif - - redraw_mask |= REDRAW_DOOR_1; } } } @@ -8558,6 +10630,10 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) case CA_SET_PLAYER_SPEED: { +#if 0 + printf("::: trigger_player_bits == %d\n", trigger_player_bits); +#endif + for (i = 0; i < MAX_PLAYERS; i++) { if (trigger_player_bits & (1 << i)) @@ -8588,18 +10664,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) action_arg_number_min, action_arg_number_max); -#if 1 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE); -#else - /* make sure that value is power of 2 */ - move_stepsize = (1 << log_2(move_stepsize)); - - /* do no immediately change -- the player might just be moving */ - stored_player[i].move_delay_value_next = TILEX / move_stepsize; - - stored_player[i].cannot_move = - (action_arg == CA_ARG_SPEED_NOT_MOVING ? TRUE : FALSE); -#endif } } @@ -8664,6 +10729,11 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) (level.use_artwork_element[i] ? level.artwork_element[i] : stored_player[i].element_nr); +#if USE_GFX_RESET_PLAYER_ARTWORK + if (stored_player[i].artwork_element != artwork_element) + stored_player[i].Frame = 0; +#endif + stored_player[i].artwork_element = artwork_element; SetPlayerWaiting(&stored_player[i], FALSE); @@ -8681,6 +10751,104 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) break; } + case CA_SET_PLAYER_INVENTORY: + { + for (i = 0; i < MAX_PLAYERS; i++) + { + struct PlayerInfo *player = &stored_player[i]; + int j, k; + + if (trigger_player_bits & (1 << i)) + { + int inventory_element = action_arg_element; + + if (action_arg == CA_ARG_ELEMENT_TARGET || + action_arg == CA_ARG_ELEMENT_TRIGGER || + action_arg == CA_ARG_ELEMENT_ACTION) + { + int element = inventory_element; + int collect_count = element_info[element].collect_count_initial; + + if (!IS_CUSTOM_ELEMENT(element)) + collect_count = 1; + + if (collect_count == 0) + player->inventory_infinite_element = element; + else + for (k = 0; k < collect_count; k++) + if (player->inventory_size < MAX_INVENTORY_SIZE) + player->inventory_element[player->inventory_size++] = + element; + } + else if (action_arg == CA_ARG_INVENTORY_RM_TARGET || + action_arg == CA_ARG_INVENTORY_RM_TRIGGER || + action_arg == CA_ARG_INVENTORY_RM_ACTION) + { + if (player->inventory_infinite_element != EL_UNDEFINED && + IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element, + action_arg_element_raw)) + player->inventory_infinite_element = EL_UNDEFINED; + + for (k = 0, j = 0; j < player->inventory_size; j++) + { + if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j], + action_arg_element_raw)) + player->inventory_element[k++] = player->inventory_element[j]; + } + + player->inventory_size = k; + } + else if (action_arg == CA_ARG_INVENTORY_RM_FIRST) + { + if (player->inventory_size > 0) + { + for (j = 0; j < player->inventory_size - 1; j++) + player->inventory_element[j] = player->inventory_element[j + 1]; + + player->inventory_size--; + } + } + else if (action_arg == CA_ARG_INVENTORY_RM_LAST) + { + if (player->inventory_size > 0) + player->inventory_size--; + } + else if (action_arg == CA_ARG_INVENTORY_RM_ALL) + { + player->inventory_infinite_element = EL_UNDEFINED; + player->inventory_size = 0; + } + else if (action_arg == CA_ARG_INVENTORY_RESET) + { + player->inventory_infinite_element = EL_UNDEFINED; + player->inventory_size = 0; + + if (level.use_initial_inventory[i]) + { + for (j = 0; j < level.initial_inventory_size[i]; j++) + { + int element = level.initial_inventory_content[i][j]; + int collect_count = element_info[element].collect_count_initial; + + if (!IS_CUSTOM_ELEMENT(element)) + collect_count = 1; + + if (collect_count == 0) + player->inventory_infinite_element = element; + else + for (k = 0; k < collect_count; k++) + if (player->inventory_size < MAX_INVENTORY_SIZE) + player->inventory_element[player->inventory_size++] = + element; + } + } + } + } + } + + break; + } + /* ---------- CE actions ---------------------------------------------- */ case CA_SET_CE_VALUE: @@ -8690,10 +10858,6 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) CustomValue[x][y] = action_arg_number_new; -#if 0 - printf("::: CE value == %d\n", CustomValue[x][y]); -#endif - if (CustomValue[x][y] != last_ce_value) { CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES); @@ -8701,19 +10865,10 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) if (CustomValue[x][y] == 0) { -#if 0 - printf("::: CE_VALUE_GETS_ZERO\n"); -#endif - CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO); CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X); - -#if 0 - printf("::: RESULT: %d, %d\n", Feld[x][y], ChangePage[x][y]); -#endif } } - #endif break; @@ -8726,10 +10881,6 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) ei->collect_score = action_arg_number_new; -#if 0 - printf("::: CE score == %d\n", ei->collect_score); -#endif - if (ei->collect_score != last_ce_score) { CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES); @@ -8739,18 +10890,9 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) { int xx, yy; -#if 0 - printf("::: CE_SCORE_GETS_ZERO\n"); -#endif - CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO); CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X); -#if 0 - printf("::: RESULT: %d, %d\n", Feld[x][y], ChangePage[x][y]); -#endif - -#if 1 /* This is a very special case that seems to be a mixture between CheckElementChange() and CheckTriggeredElementChange(): while @@ -8768,15 +10910,45 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) CheckElementChange(xx, yy, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO); } -#endif } } - #endif break; } + case CA_SET_CE_ARTWORK: + { + int artwork_element = action_arg_element; + boolean reset_frame = FALSE; + int xx, yy; + + if (action_arg == CA_ARG_ELEMENT_RESET) + artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial : + element); + + if (ei->gfx_element != artwork_element) + reset_frame = TRUE; + + ei->gfx_element = artwork_element; + + SCAN_PLAYFIELD(xx, yy) + { + if (Feld[xx][yy] == element) + { + if (reset_frame) + { + ResetGfxAnimation(xx, yy); + ResetRandomAnimationValue(xx, yy); + } + + TEST_DrawLevelField(xx, yy); + } + } + + break; + } + /* ---------- engine actions ------------------------------------------ */ case CA_SET_ENGINE_SCAN_MODE: @@ -8794,11 +10966,12 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page) static void CreateFieldExt(int x, int y, int element, boolean is_change) { int old_element = Feld[x][y]; - int new_element = get_element_from_group_element(element); + int new_element = GetElementFromGroupElement(element); int previous_move_direction = MovDir[x][y]; #if USE_NEW_CUSTOM_VALUE int last_ce_value = CustomValue[x][y]; #endif + boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y); boolean new_element_is_player = ELEM_IS_PLAYER(new_element); boolean add_player_onto_element = (new_element_is_player && #if USE_CODE_THAT_BREAKS_SNAKE_BITE @@ -8852,16 +11025,25 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change) ResetRandomAnimationValue(x, y); #endif - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); if (GFX_CRUMBLED(new_element)) - DrawLevelFieldCrumbledSandNeighbours(x, y); + TEST_DrawLevelFieldCrumbledSandNeighbours(x, y); } #if 1 /* check if element under the player changes from accessible to unaccessible (needed for special case of dropping element which then changes) */ /* (must be checked after creating new element for walkable group elements) */ +#if USE_FIX_KILLED_BY_NON_WALKABLE + if (IS_PLAYER(x, y) && !player_explosion_protected && + IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element)) + { + Bang(x, y); + + return; + } +#else if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) && IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element)) { @@ -8869,6 +11051,7 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change) return; } +#endif #endif /* "ChangeCount" not set yet to allow "entered by player" change one time */ @@ -8925,7 +11108,8 @@ static boolean ChangeElement(int x, int y, int element, int page) { /* reset actual trigger element, trigger player and action element */ change->actual_trigger_element = EL_EMPTY; - change->actual_trigger_player = EL_PLAYER_1; + change->actual_trigger_player = EL_EMPTY; + change->actual_trigger_player_bits = CH_PLAYER_NONE; change->actual_trigger_side = CH_SIDE_NONE; change->actual_trigger_ce_value = 0; change->actual_trigger_ce_score = 0; @@ -9085,6 +11269,7 @@ static void HandleElementChange(int x, int y, int page) int element = MovingOrBlocked2Element(x, y); struct ElementInfo *ei = &element_info[element]; struct ElementChangeInfo *change = &ei->change_page[page]; + boolean handle_action_before_change = FALSE; #ifdef DEBUG if (!CAN_CHANGE_OR_HAS_ACTION(element) && @@ -9115,8 +11300,19 @@ static void HandleElementChange(int x, int y, int page) if (change->can_change) { - ResetGfxAnimation(x, y); - ResetRandomAnimationValue(x, y); +#if 1 + /* !!! not clear why graphic animation should be reset at all here !!! */ + /* !!! UPDATE: but is needed for correct Snake Bite tail animation !!! */ +#if USE_GFX_RESET_WHEN_NOT_MOVING + /* 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)) +#endif + { + ResetGfxAnimation(x, y); + ResetRandomAnimationValue(x, y); + } +#endif if (change->pre_change_function) change->pre_change_function(x, y); @@ -9156,6 +11352,15 @@ static void HandleElementChange(int x, int y, int page) return; } +#if 1 + /* special case: set new level random seed before changing element */ + if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED) + handle_action_before_change = TRUE; + + if (change->has_action && handle_action_before_change) + ExecuteCustomElementAction(x, y, element, page); +#endif + if (change->can_change) { if (ChangeElement(x, y, element, page)) @@ -9165,7 +11370,7 @@ static void HandleElementChange(int x, int y, int page) } } - if (change->has_action) + if (change->has_action && !handle_action_before_change) ExecuteCustomElementAction(x, y, element, page); } } @@ -9265,6 +11470,14 @@ static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y, if (!(trigger_events[trigger_element][trigger_event])) return FALSE; +#if 0 + printf("::: CheckTriggeredElementChangeExt %d ... [%d, %d, %d, '%s']\n", + trigger_event, recursion_loop_depth, recursion_loop_detected, + recursion_loop_element, EL_NAME(recursion_loop_element)); +#endif + + RECURSION_LOOP_DETECTION_START(trigger_element, FALSE); + for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++) { int element = EL_CUSTOM_START + i; @@ -9287,25 +11500,42 @@ static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y, IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)) { change->actual_trigger_element = trigger_element; - change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player); + change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player); + change->actual_trigger_player_bits = trigger_player; change->actual_trigger_side = trigger_side; change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y]; change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element); +#if 0 + printf("::: TRIGGERED CHANGE FOUND: %d ['%s'], %d\n", + element, EL_NAME(element), p); +#endif + if ((change->can_change && !change_done) || change->has_action) { int x, y; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { if (Feld[x][y] == element) { if (change->can_change && !change_done) { +#if USE_FIX_NO_ACTION_AFTER_CHANGE + /* if element already changed in this frame, not only prevent + another element change (checked in ChangeElement()), but + also prevent additional element actions for this element */ + + if (ChangeCount[x][y] >= game.max_num_changes_per_frame && + !level.use_action_after_change_bug) + continue; +#endif + +#if 0 + printf("::: TRIGGERED CHANGE FOUND: %d ['%s'], %d -- CHANGE\n", + element, EL_NAME(element), p); +#endif + ChangeDelay[x][y] = 1; ChangeEvent[x][y] = trigger_event; @@ -9314,6 +11544,22 @@ static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y, #if USE_NEW_DELAYED_ACTION else if (change->has_action) { +#if USE_FIX_NO_ACTION_AFTER_CHANGE + /* if element already changed in this frame, not only prevent + another element change (checked in ChangeElement()), but + also prevent additional element actions for this element */ + + if (ChangeCount[x][y] >= game.max_num_changes_per_frame && + !level.use_action_after_change_bug) + continue; +#endif + + +#if 0 + printf("::: TRIGGERED CHANGE FOUND: %d ['%s'], %d -- ACTION\n", + element, EL_NAME(element), p); +#endif + ExecuteCustomElementAction(x, y, element, p); PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p); } @@ -9331,12 +11577,20 @@ static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y, { change_done = TRUE; change_done_any = TRUE; + +#if 0 + printf("::: TRIGGERED CHANGE FOUND: %d ['%s'], %d -- DONE\n", + element, EL_NAME(element), p); +#endif + } } } } } + RECURSION_LOOP_DETECTION_END(); + return change_done_any; } @@ -9375,14 +11629,34 @@ static boolean CheckElementChangeExt(int x, int y, return FALSE; #endif +#if 0 + printf("::: CheckElementChangeExt %d ... [%d, %d, %d, '%s']\n", + trigger_event, recursion_loop_depth, recursion_loop_detected, + recursion_loop_element, EL_NAME(recursion_loop_element)); +#endif + + RECURSION_LOOP_DETECTION_START(trigger_element, FALSE); + +#if 0 + printf("::: X: trigger_player_bits == %d\n", trigger_player); +#endif + for (p = 0; p < element_info[element].num_change_pages; p++) { struct ElementChangeInfo *change = &element_info[element].change_page[p]; + /* check trigger element for all events where the element that is checked + for changing interacts with a directly adjacent element -- this is + different to element changes that affect other elements to change on the + whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */ boolean check_trigger_element = (trigger_event == CE_TOUCHING_X || trigger_event == CE_HITTING_X || - trigger_event == CE_HIT_BY_X); + trigger_event == CE_HIT_BY_X || +#if 1 + /* this one was forgotten until 3.2.3 */ + trigger_event == CE_DIGGING_X); +#endif if (change->can_change_or_has_action && change->has_event[trigger_event] && @@ -9392,7 +11666,8 @@ static boolean CheckElementChangeExt(int x, int y, IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))) { change->actual_trigger_element = trigger_element; - change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player); + change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player); + change->actual_trigger_player_bits = trigger_player; change->actual_trigger_side = trigger_side; change->actual_trigger_ce_value = CustomValue[x][y]; change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element); @@ -9446,6 +11721,8 @@ static boolean CheckElementChangeExt(int x, int y, } } + RECURSION_LOOP_DETECTION_END(); + return change_done; } @@ -9499,17 +11776,13 @@ static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting) player->frame_counter_bored = FrameCounter + game.player_boring_delay_fixed + - SimpleRND(game.player_boring_delay_random); + GetSimpleRandom(game.player_boring_delay_random); player->frame_counter_sleeping = FrameCounter + game.player_sleeping_delay_fixed + - SimpleRND(game.player_sleeping_delay_random); + GetSimpleRandom(game.player_sleeping_delay_random); -#if 1 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir); -#else - InitPlayerGfxAnimation(player, ACTION_WAITING, player->MovDir); -#endif } if (game.player_sleeping_delay_fixed + @@ -9527,7 +11800,6 @@ static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting) player->is_bored ? ACTION_BORING : ACTION_WAITING); -#if 1 if (player->is_sleeping && player->use_murphy) { /* special case for sleeping Murphy when leaning against non-free tile */ @@ -9545,7 +11817,6 @@ static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting) player->dir_waiting = move_dir; } -#endif if (player->is_sleeping) { @@ -9565,10 +11836,10 @@ static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting) player->anim_delay_counter = graphic_info[special_graphic].anim_delay_fixed + - SimpleRND(graphic_info[special_graphic].anim_delay_random); + GetSimpleRandom(graphic_info[special_graphic].anim_delay_random); player->post_delay_counter = graphic_info[special_graphic].post_delay_fixed + - SimpleRND(graphic_info[special_graphic].post_delay_random); + GetSimpleRandom(graphic_info[special_graphic].post_delay_random); player->special_action_sleeping = special_action; } @@ -9591,16 +11862,16 @@ static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting) if (player->anim_delay_counter == 0 && player->post_delay_counter == 0) { int special_action = - ACTION_BORING_1 + SimpleRND(player->num_special_action_bored); + ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored); int special_graphic = el_act_dir2img(player->artwork_element, special_action, move_dir); player->anim_delay_counter = graphic_info[special_graphic].anim_delay_fixed + - SimpleRND(graphic_info[special_graphic].anim_delay_random); + GetSimpleRandom(graphic_info[special_graphic].anim_delay_random); player->post_delay_counter = graphic_info[special_graphic].post_delay_fixed + - SimpleRND(graphic_info[special_graphic].post_delay_random); + GetSimpleRandom(graphic_info[special_graphic].post_delay_random); player->special_action_bored = special_action; } @@ -9707,7 +11978,8 @@ static void CheckLevelTime() { if (level.native_em_level->lev->home == 0) /* all players at home */ { - local_player->LevelSolved = TRUE; + PlayerWins(local_player); + AllPlayersGone = TRUE; level.native_em_level->lev->home = -1; @@ -9738,7 +12010,7 @@ static void CheckLevelTime() } } - if (!level.use_step_counter) + if (!local_player->LevelSolved && !level.use_step_counter) { TimePlayed++; @@ -9747,9 +12019,15 @@ static void CheckLevelTime() TimeLeft--; if (TimeLeft <= 10 && setup.time_limit) - PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE); + PlaySound(SND_GAME_RUNNING_OUT_OF_TIME); + +#if 1 + game_panel_controls[GAME_PANEL_TIME].value = TimeLeft; + DisplayGameControlValues(); +#else DrawGameValue_Time(TimeLeft); +#endif if (!TimeLeft && setup.time_limit) { @@ -9760,8 +12038,17 @@ static void CheckLevelTime() KillPlayer(&stored_player[i]); } } +#if 1 + else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */ + { + game_panel_controls[GAME_PANEL_TIME].value = TimePlayed; + + DisplayGameControlValues(); + } +#else else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */ DrawGameValue_Time(TimePlayed); +#endif level.native_em_level->lev->time = (level.time == 0 ? TimePlayed : TimeLeft); @@ -9770,17 +12057,19 @@ static void CheckLevelTime() if (tape.recording || tape.playing) DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime); } + +#if 1 + UpdateAndDisplayGameControlValues(); +#else + UpdateGameDoorValues(); + DrawGameDoorValues(); +#endif } void AdvanceFrameAndPlayerCounters(int player_nr) { int i; -#if 0 - Error(ERR_NETWORK_CLIENT, "advancing frame counter from %d to %d", - FrameCounter, FrameCounter + 1); -#endif - /* advance frame counters (global frame counter and time frame counter) */ FrameCounter++; TimeFrames++; @@ -9857,14 +12146,34 @@ void GameActions() byte tape_action[MAX_PLAYERS]; int i; + /* detect endless loops, caused by custom element programming */ + if (recursion_loop_detected && recursion_loop_depth == 0) + { + char *message = getStringCat3("Internal Error ! Element ", + EL_NAME(recursion_loop_element), + " caused endless loop ! Quit the game ?"); + + Error(ERR_WARN, "element '%s' caused endless loop in game engine", + EL_NAME(recursion_loop_element)); + + RequestQuitGameExt(FALSE, level_editor_test_game, message); + + recursion_loop_detected = FALSE; /* if game should be continued */ + + free(message); + + return; + } + if (game.restart_level) - StartGameActions(options.network, setup.autorecord, NEW_RANDOMIZE); + StartGameActions(options.network, setup.autorecord, level.random_seed); if (level.game_engine_type == GAME_ENGINE_TYPE_EM) { if (level.native_em_level->lev->home == 0) /* all players at home */ { - local_player->LevelSolved = TRUE; + PlayerWins(local_player); + AllPlayersGone = TRUE; level.native_em_level->lev->home = -1; @@ -9877,7 +12186,7 @@ void GameActions() AllPlayersGone = TRUE; } - if (local_player->LevelSolved) + if (local_player->LevelSolved && !local_player->LevelSolved_GameEnd) GameWon(); if (AllPlayersGone && !TAPE_IS_STOPPED(tape)) @@ -9920,18 +12229,32 @@ void GameActions() /* at this point we know that we really continue executing the game */ -#if 1 network_player_action_received = FALSE; -#endif + /* when playing tape, read previously recorded player input from tape data */ recorded_player_action = (tape.playing ? TapePlayAction() : NULL); +#if 1 + /* TapePlayAction() may return NULL when toggling to "pause before death" */ + if (tape.pausing) + return; +#endif + if (tape.set_centered_player) { game.centered_player_nr_next = tape.centered_player_nr_next; game.set_centered_player = TRUE; } +#if 0 /* USE_NEW_PLAYER_ASSIGNMENTS */ + for (i = 0; i < MAX_PLAYERS; i++) + { + summarized_player_action |= stored_player[i].mapped_action; + + if (!network_playing) + stored_player[i].effective_action = stored_player[i].mapped_action; + } +#else for (i = 0; i < MAX_PLAYERS; i++) { summarized_player_action |= stored_player[i].action; @@ -9939,6 +12262,7 @@ void GameActions() if (!network_playing) stored_player[i].effective_action = stored_player[i].action; } +#endif #if defined(NETWORK_AVALIABLE) if (network_playing) @@ -9955,13 +12279,25 @@ void GameActions() (i == game.centered_player_nr ? summarized_player_action : 0); } +#if 0 /* USE_NEW_PLAYER_ASSIGNMENTS */ + if (recorded_player_action != NULL) + for (i = 0; i < MAX_PLAYERS; i++) + stored_player[i].effective_action = + recorded_player_action[map_player_action[i]]; +#else if (recorded_player_action != NULL) for (i = 0; i < MAX_PLAYERS; i++) - stored_player[i].effective_action = recorded_player_action[i]; + stored_player[i].effective_action = + recorded_player_action[i]; +#endif for (i = 0; i < MAX_PLAYERS; i++) { +#if 0 /* USE_NEW_PLAYER_ASSIGNMENTS */ + tape_action[i] = stored_player[i].action; +#else tape_action[i] = stored_player[i].effective_action; +#endif /* (this can only happen in the R'n'D game engine) */ if (tape.recording && tape_action[i] && !tape.player_participates[i]) @@ -9972,6 +12308,37 @@ void GameActions() if (tape.recording) TapeRecordAction(tape_action); +#if USE_NEW_PLAYER_ASSIGNMENTS + { +#if 0 + + for (i = 0; i < MAX_PLAYERS; i++) + stored_player[i].mapped_action = stored_player[map_player_action[i]].action; + +#else + +#if 1 + byte unmapped_action[MAX_PLAYERS]; + + for (i = 0; i < MAX_PLAYERS; i++) + unmapped_action[i] = stored_player[i].effective_action; + + for (i = 0; i < MAX_PLAYERS; i++) + stored_player[i].effective_action = unmapped_action[map_player_action[i]]; +#endif + +#if 0 + for (i = 0; i < MAX_PLAYERS; i++) + printf("::: %d: %d [%d]\n", i, stored_player[i].effective_action, + map_player_action[i]); +#endif +#endif + } +#else + for (i = 0; i < MAX_PLAYERS; i++) + stored_player[i].mapped_action = stored_player[i].action; +#endif + if (level.game_engine_type == GAME_ENGINE_TYPE_EM) { GameActions_EM_Main(); @@ -9991,10 +12358,6 @@ void GameActions_EM_Main() for (i = 0; i < MAX_PLAYERS; i++) effective_action[i] = stored_player[i].effective_action; -#if 0 - printf("::: %04d: %08x\n", FrameCounter, effective_action[0]); -#endif - GameActions_EM(effective_action, warp_mode); CheckLevelTime(); @@ -10020,7 +12383,6 @@ void GameActions_RND() } #endif -#if 1 if (game.set_centered_player) { boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND(); @@ -10059,10 +12421,9 @@ void GameActions_RND() game.centered_player_nr = game.centered_player_nr_next; game.set_centered_player = FALSE; - DrawRelocateScreen(sx, sy, MV_NONE, TRUE, setup.quick_switch); + DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch); DrawGameDoorValues(); } -#endif for (i = 0; i < MAX_PLAYERS; i++) { @@ -10083,22 +12444,11 @@ void GameActions_RND() if (stored_player[i].programmed_action) actual_player_action = stored_player[i].programmed_action; -#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 0 - network_player_action_received = FALSE; -#endif - ScrollScreen(NULL, SCROLL_GO_ON); /* for backwards compatibility, the following code emulates a fixed bug that @@ -10126,18 +12476,16 @@ void GameActions_RND() /* continue moving after pushing (this is actually a bug) */ if (!IS_MOVING(x, y)) - { Stop[x][y] = FALSE; - } } } } -#if 1 - SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) +#if 0 + debug_print_timestamp(0, "start main loop profiling"); #endif + + SCAN_PLAYFIELD(x, y) { ChangeCount[x][y] = 0; ChangeEvent[x][y] = -1; @@ -10157,7 +12505,7 @@ void GameActions_RND() if (MovDelay[x][y] <= 0) { RemoveField(x, y); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); TestIfElementTouchesCustomElement(x, y); /* for empty space */ } @@ -10181,6 +12529,8 @@ void GameActions_RND() WasJustFalling[x][y]--; if (CheckCollision[x][y] > 0) CheckCollision[x][y]--; + if (CheckImpact[x][y] > 0) + CheckImpact[x][y]--; GfxFrame[x][y]++; @@ -10189,7 +12539,7 @@ void GameActions_RND() if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y)) { ResetGfxAnimation(x, y); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } #if DEBUG @@ -10209,62 +12559,70 @@ void GameActions_RND() #endif } -#if 1 - SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) +#if 0 + debug_print_timestamp(0, "- time for pre-main loop:"); #endif + +#if 0 // -------------------- !!! TEST ONLY !!! -------------------- + SCAN_PLAYFIELD(x, y) { element = Feld[x][y]; graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); -#if 0 - printf("::: %d,%d\n", x, y); - - if (element == EL_ROCK) - printf("::: Yo man! Rocks can fall!\n"); -#endif - #if 1 - ResetGfxFrame(x, y, TRUE); -#else - if (graphic_info[graphic].anim_global_sync) - GfxFrame[x][y] = FrameCounter; - else if (ANIM_MODE(graphic) == ANIM_CE_VALUE) { - int old_gfx_frame = GfxFrame[x][y]; - - GfxFrame[x][y] = CustomValue[x][y]; - #if 1 - if (GfxFrame[x][y] != old_gfx_frame) + int element2 = element; + int graphic2 = graphic; +#else + int element2 = Feld[x][y]; + int graphic2 = el_act_dir2img(element2, GfxAction[x][y], GfxDir[x][y]); #endif - DrawLevelGraphicAnimation(x, y, graphic); - } - else if (ANIM_MODE(graphic) == ANIM_CE_SCORE) - { - int old_gfx_frame = GfxFrame[x][y]; + int last_gfx_frame = GfxFrame[x][y]; - GfxFrame[x][y] = element_info[element].collect_score; + if (graphic_info[graphic2].anim_global_sync) + GfxFrame[x][y] = FrameCounter; + else if (ANIM_MODE(graphic2) == ANIM_CE_VALUE) + GfxFrame[x][y] = CustomValue[x][y]; + else if (ANIM_MODE(graphic2) == ANIM_CE_SCORE) + GfxFrame[x][y] = element_info[element2].collect_score; + else if (ANIM_MODE(graphic2) == ANIM_CE_DELAY) + GfxFrame[x][y] = ChangeDelay[x][y]; + + if (redraw && GfxFrame[x][y] != last_gfx_frame) + DrawLevelGraphicAnimation(x, y, graphic2); + } +#else + ResetGfxFrame(x, y, TRUE); +#endif #if 1 - if (GfxFrame[x][y] != old_gfx_frame) + if (ANIM_MODE(graphic) == ANIM_RANDOM && + IS_NEXT_FRAME(GfxFrame[x][y], graphic)) + ResetRandomAnimationValue(x, y); #endif - DrawLevelGraphicAnimation(x, y, graphic); - } - else if (ANIM_MODE(graphic) == ANIM_CE_DELAY) - { - int old_gfx_frame = GfxFrame[x][y]; - GfxFrame[x][y] = ChangeDelay[x][y]; +#if 1 + SetRandomAnimationValue(x, y); +#endif #if 1 - if (GfxFrame[x][y] != old_gfx_frame) + PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]); #endif - DrawLevelGraphicAnimation(x, y, graphic); - } + } +#endif // -------------------- !!! TEST ONLY !!! -------------------- + +#if 0 + debug_print_timestamp(0, "- time for TEST loop: -->"); #endif + SCAN_PLAYFIELD(x, y) + { + element = Feld[x][y]; + graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); + + ResetGfxFrame(x, y, TRUE); + if (ANIM_MODE(graphic) == ANIM_RANDOM && IS_NEXT_FRAME(GfxFrame[x][y], graphic)) ResetRandomAnimationValue(x, y); @@ -10286,18 +12644,6 @@ void GameActions_RND() (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y])) { int page = element_info[element].event_page_nr[CE_DELAY]; -#if 0 - HandleElementChange(x, y, ChangePage[x][y] != -1 ? ChangePage[x][y] : page); -#else - -#if 0 - printf("::: ChangeDelay == %d\n", ChangeDelay[x][y]); -#endif - -#if 0 - if (element == EL_CUSTOM_255) - printf("::: ChangeDelay == %d\n", ChangeDelay[x][y]); -#endif #if 1 HandleElementChange(x, y, page); @@ -10309,12 +12655,147 @@ void GameActions_RND() ExecuteCustomElementAction(x, y, element, page); #endif -#endif + element = Feld[x][y]; + graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); + } + +#if 0 // --------------------------------------------------------------------- + + if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element))) + { + StartMoving(x, y); element = Feld[x][y]; graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]); + + if (IS_ANIMATED(graphic) && + !IS_MOVING(x, y) && + !Stop[x][y]) + DrawLevelGraphicAnimationIfNeeded(x, y, graphic); + + if (IS_GEM(element) || element == EL_SP_INFOTRON) + TEST_DrawTwinkleOnField(x, y); + } + else if (IS_MOVING(x, y)) + ContinueMoving(x, y); + else + { + switch (element) + { + case EL_ACID: + case EL_EXIT_OPEN: + case EL_EM_EXIT_OPEN: + case EL_SP_EXIT_OPEN: + case EL_STEEL_EXIT_OPEN: + case EL_EM_STEEL_EXIT_OPEN: + case EL_SP_TERMINAL: + case EL_SP_TERMINAL_ACTIVE: + case EL_EXTRA_TIME: + case EL_SHIELD_NORMAL: + case EL_SHIELD_DEADLY: + if (IS_ANIMATED(graphic)) + DrawLevelGraphicAnimationIfNeeded(x, y, graphic); + break; + + case EL_DYNAMITE_ACTIVE: + case EL_EM_DYNAMITE_ACTIVE: + case EL_DYNABOMB_PLAYER_1_ACTIVE: + case EL_DYNABOMB_PLAYER_2_ACTIVE: + case EL_DYNABOMB_PLAYER_3_ACTIVE: + case EL_DYNABOMB_PLAYER_4_ACTIVE: + case EL_SP_DISK_RED_ACTIVE: + CheckDynamite(x, y); + break; + + case EL_AMOEBA_GROWING: + AmoebeWaechst(x, y); + break; + + case EL_AMOEBA_SHRINKING: + AmoebaDisappearing(x, y); + break; + +#if !USE_NEW_AMOEBA_CODE + case EL_AMOEBA_WET: + case EL_AMOEBA_DRY: + case EL_AMOEBA_FULL: + case EL_BD_AMOEBA: + case EL_EMC_DRIPPER: + AmoebeAbleger(x, y); + break; +#endif + + case EL_GAME_OF_LIFE: + case EL_BIOMAZE: + Life(x, y); + break; + + case EL_EXIT_CLOSED: + CheckExit(x, y); + break; + + case EL_EM_EXIT_CLOSED: + CheckExitEM(x, y); + break; + + case EL_STEEL_EXIT_CLOSED: + CheckExitSteel(x, y); + break; + + case EL_EM_STEEL_EXIT_CLOSED: + CheckExitSteelEM(x, y); + break; + + case EL_SP_EXIT_CLOSED: + CheckExitSP(x, y); + break; + + case EL_EXPANDABLE_WALL_GROWING: + case EL_EXPANDABLE_STEELWALL_GROWING: + MauerWaechst(x, y); + break; + + case EL_EXPANDABLE_WALL: + case EL_EXPANDABLE_WALL_HORIZONTAL: + case EL_EXPANDABLE_WALL_VERTICAL: + case EL_EXPANDABLE_WALL_ANY: + case EL_BD_EXPANDABLE_WALL: + MauerAbleger(x, y); + break; + + case EL_EXPANDABLE_STEELWALL_HORIZONTAL: + case EL_EXPANDABLE_STEELWALL_VERTICAL: + case EL_EXPANDABLE_STEELWALL_ANY: + MauerAblegerStahl(x, y); + break; + + case EL_FLAMES: + CheckForDragon(x, y); + break; + + case EL_EXPLOSION: + break; + + case EL_ELEMENT_SNAPPING: + case EL_DIAGONAL_SHRINKING: + case EL_DIAGONAL_GROWING: + { + graphic = + el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]); + + DrawLevelGraphicAnimationIfNeeded(x, y, graphic); + break; + } + + default: + if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y)) + DrawLevelGraphicAnimationIfNeeded(x, y, graphic); + break; + } } +#else // --------------------------------------------------------------------- + if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element))) { StartMoving(x, y); @@ -10328,11 +12809,14 @@ void GameActions_RND() DrawLevelGraphicAnimationIfNeeded(x, y, graphic); if (IS_GEM(element) || element == EL_SP_INFOTRON) - EdelsteinFunkeln(x, y); + TEST_DrawTwinkleOnField(x, y); } else if ((element == EL_ACID || element == EL_EXIT_OPEN || + element == EL_EM_EXIT_OPEN || element == EL_SP_EXIT_OPEN || + element == EL_STEEL_EXIT_OPEN || + element == EL_EM_STEEL_EXIT_OPEN || element == EL_SP_TERMINAL || element == EL_SP_TERMINAL_ACTIVE || element == EL_EXTRA_TIME || @@ -10358,9 +12842,16 @@ void GameActions_RND() Life(x, y); else if (element == EL_EXIT_CLOSED) CheckExit(x, y); + else if (element == EL_EM_EXIT_CLOSED) + CheckExitEM(x, y); + else if (element == EL_STEEL_EXIT_CLOSED) + CheckExitSteel(x, y); + else if (element == EL_EM_STEEL_EXIT_CLOSED) + CheckExitSteelEM(x, y); else if (element == EL_SP_EXIT_CLOSED) CheckExitSP(x, y); - else if (element == EL_EXPANDABLE_WALL_GROWING) + else if (element == EL_EXPANDABLE_WALL_GROWING || + element == EL_EXPANDABLE_STEELWALL_GROWING) MauerWaechst(x, y); else if (element == EL_EXPANDABLE_WALL || element == EL_EXPANDABLE_WALL_HORIZONTAL || @@ -10368,6 +12859,10 @@ void GameActions_RND() element == EL_EXPANDABLE_WALL_ANY || element == EL_BD_EXPANDABLE_WALL) MauerAbleger(x, y); + else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL || + element == EL_EXPANDABLE_STEELWALL_VERTICAL || + element == EL_EXPANDABLE_STEELWALL_ANY) + MauerAblegerStahl(x, y); else if (element == EL_FLAMES) CheckForDragon(x, y); else if (element == EL_EXPLOSION) @@ -10376,20 +12871,14 @@ void GameActions_RND() element == EL_DIAGONAL_SHRINKING || element == EL_DIAGONAL_GROWING) { -#if 1 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]); DrawLevelGraphicAnimationIfNeeded(x, y, graphic); -#endif } else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y)) DrawLevelGraphicAnimationIfNeeded(x, y, graphic); -#if 0 - if (element == EL_CUSTOM_255 || - element == EL_CUSTOM_256) - DrawLevelGraphicAnimation(x, y, graphic); -#endif +#endif // --------------------------------------------------------------------- if (IS_BELT_ACTIVE(element)) PlayLevelSoundAction(x, y, ACTION_ACTIVE); @@ -10404,7 +12893,10 @@ void GameActions_RND() element == EL_MAGIC_WALL_EMPTYING || element == EL_BD_MAGIC_WALL_FULL || element == EL_BD_MAGIC_WALL_ACTIVE || - element == EL_BD_MAGIC_WALL_EMPTYING) && + element == EL_BD_MAGIC_WALL_EMPTYING || + element == EL_DC_MAGIC_WALL_FULL || + element == EL_DC_MAGIC_WALL_ACTIVE || + element == EL_DC_MAGIC_WALL_EMPTYING) && ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy)) { magic_wall_x = x; @@ -10413,6 +12905,10 @@ void GameActions_RND() } } +#if 0 + debug_print_timestamp(0, "- time for MAIN loop: -->"); +#endif + #if USE_NEW_AMOEBA_CODE /* new experimental amoeba growth stuff */ if (!(FrameCounter % 8)) @@ -10429,6 +12925,7 @@ void GameActions_RND() (element == EL_EMPTY || CAN_GROW_INTO(element) || element == EL_QUICKSAND_EMPTY || + element == EL_QUICKSAND_FAST_EMPTY || element == EL_ACID_SPLASH_LEFT || element == EL_ACID_SPLASH_RIGHT)) { @@ -10450,11 +12947,7 @@ void GameActions_RND() { game.explosions_delayed = FALSE; -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { element = Feld[x][y]; @@ -10479,6 +12972,10 @@ void GameActions_RND() element == EL_BD_MAGIC_WALL_ACTIVE || element == EL_BD_MAGIC_WALL_EMPTYING) PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE); + else if (element == EL_DC_MAGIC_WALL_FULL || + element == EL_DC_MAGIC_WALL_ACTIVE || + element == EL_DC_MAGIC_WALL_EMPTYING) + PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE); else PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE); } @@ -10486,13 +12983,10 @@ void GameActions_RND() if (game.magic_wall_time_left > 0) { game.magic_wall_time_left--; + if (!game.magic_wall_time_left) { -#if 1 SCAN_PLAYFIELD(x, y) -#else - for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++) -#endif { element = Feld[x][y]; @@ -10500,13 +12994,19 @@ void GameActions_RND() element == EL_MAGIC_WALL_FULL) { Feld[x][y] = EL_MAGIC_WALL_DEAD; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_BD_MAGIC_WALL_ACTIVE || element == EL_BD_MAGIC_WALL_FULL) { Feld[x][y] = EL_BD_MAGIC_WALL_DEAD; - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); + } + else if (element == EL_DC_MAGIC_WALL_ACTIVE || + element == EL_DC_MAGIC_WALL_FULL) + { + Feld[x][y] = EL_DC_MAGIC_WALL_DEAD; + TEST_DrawLevelField(x, y); } } @@ -10560,6 +13060,36 @@ void GameActions_RND() } } +#if USE_DELAYED_GFX_REDRAW + SCAN_PLAYFIELD(x, y) + { +#if 1 + if (GfxRedraw[x][y] != GFX_REDRAW_NONE) +#else + if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)) && + GfxRedraw[x][y] != GFX_REDRAW_NONE) +#endif + { + /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES + !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */ + + if (GfxRedraw[x][y] & GFX_REDRAW_TILE) + DrawLevelField(x, y); + + if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED) + DrawLevelFieldCrumbledSand(x, y); + + if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS) + DrawLevelFieldCrumbledSandNeighbours(x, y); + + if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED) + DrawTwinkleOnField(x, y); + } + + GfxRedraw[x][y] = GFX_REDRAW_NONE; + } +#endif + CheckLevelTime(); DrawAllPlayers(); @@ -10593,6 +13123,11 @@ void GameActions_RND() local_player->show_envelope = 0; } +#if 0 + debug_print_timestamp(0, "stop main loop profiling "); + printf("----------------------------------------------------------\n"); +#endif + /* use random number generator in every frame to make it less predictable */ if (game.engine_version >= VERSION_IDENT(3,1,1,0)) RND(1); @@ -10639,25 +13174,87 @@ static boolean AllPlayersInVisibleScreen() void ScrollLevel(int dx, int dy) { +#if 0 + /* (directly solved in BlitBitmap() now) */ + static Bitmap *bitmap_db_field2 = NULL; int softscroll_offset = (setup.soft_scrolling ? TILEX : 0); int x, y; +#else + int x, y; +#endif + +#if 0 + /* !!! THIS IS APPARENTLY WRONG FOR PLAYER RELOCATION !!! */ + /* only horizontal XOR vertical scroll direction allowed */ + if ((dx == 0 && dy == 0) || (dx != 0 && dy != 0)) + return; +#endif + +#if 0 + /* (directly solved in BlitBitmap() now) */ + if (bitmap_db_field2 == NULL) + bitmap_db_field2 = CreateBitmap(FXSIZE, FYSIZE, DEFAULT_DEPTH); + + /* needed when blitting directly to same bitmap -- should not be needed with + recent SDL libraries, but apparently does not work in 1.2.11 directly */ + BlitBitmap(drawto_field, bitmap_db_field2, + FX + TILEX * (dx == -1) - softscroll_offset, + FY + TILEY * (dy == -1) - softscroll_offset, + SXSIZE - TILEX * (dx != 0) + 2 * softscroll_offset, + SYSIZE - TILEY * (dy != 0) + 2 * softscroll_offset, + FX + TILEX * (dx == 1) - softscroll_offset, + FY + TILEY * (dy == 1) - softscroll_offset); + BlitBitmap(bitmap_db_field2, drawto_field, + FX + TILEX * (dx == 1) - softscroll_offset, + FY + TILEY * (dy == 1) - softscroll_offset, + SXSIZE - TILEX * (dx != 0) + 2 * softscroll_offset, + SYSIZE - TILEY * (dy != 0) + 2 * softscroll_offset, + FX + TILEX * (dx == 1) - softscroll_offset, + FY + TILEY * (dy == 1) - softscroll_offset); + +#else + +#if 0 + /* !!! DOES NOT WORK FOR DIAGONAL PLAYER RELOCATION !!! */ + int xsize = (BX2 - BX1 + 1); + int ysize = (BY2 - BY1 + 1); + int start = (dx != 0 ? (dx == -1 ? BX1 : BX2) : (dy == -1 ? BY1 : BY2)); + int end = (dx != 0 ? (dx == -1 ? BX2 : BX1) : (dy == -1 ? BY2 : BY1)); + int step = (start < end ? +1 : -1); + + for (i = start; i != end; i += step) + { + BlitBitmap(drawto_field, drawto_field, + FX + TILEX * (dx != 0 ? i + step : 0), + FY + TILEY * (dy != 0 ? i + step : 0), + TILEX * (dx != 0 ? 1 : xsize), + TILEY * (dy != 0 ? 1 : ysize), + FX + TILEX * (dx != 0 ? i : 0), + FY + TILEY * (dy != 0 ? i : 0)); + } + +#else + + int softscroll_offset = (setup.soft_scrolling ? TILEX : 0); BlitBitmap(drawto_field, drawto_field, FX + TILEX * (dx == -1) - softscroll_offset, FY + TILEY * (dy == -1) - softscroll_offset, - SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset, - SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset, + SXSIZE - TILEX * (dx != 0) + 2 * softscroll_offset, + SYSIZE - TILEY * (dy != 0) + 2 * softscroll_offset, FX + TILEX * (dx == 1) - softscroll_offset, FY + TILEY * (dy == 1) - softscroll_offset); +#endif +#endif - if (dx) + if (dx != 0) { x = (dx == 1 ? BX1 : BX2); for (y = BY1; y <= BY2; y++) DrawScreenField(x, y); } - if (dy) + if (dy != 0) { y = (dy == 1 ? BY1 : BY2); for (x = BX1; x <= BX2; x++) @@ -10787,7 +13384,6 @@ boolean MovePlayerOneStep(struct PlayerInfo *player, if (!player_can_move) { -#if 1 if (player->MovPos == 0) { player->is_moving = FALSE; @@ -10796,14 +13392,6 @@ boolean MovePlayerOneStep(struct PlayerInfo *player, player->is_snapping = FALSE; player->is_pushing = FALSE; } -#else - DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH); - SnapField(player, 0, 0); -#endif - -#if 0 - return MP_NO_ACTION; -#endif } #if 1 @@ -10838,18 +13426,9 @@ boolean MovePlayerOneStep(struct PlayerInfo *player, #endif can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG); -#if 0 -#if USE_FIXED_DONT_RUN_INTO - if (can_move == MP_DONT_RUN_INTO) - return MP_MOVING; -#endif -#endif if (can_move != MP_MOVING) return can_move; -#if USE_FIXED_DONT_RUN_INTO -#endif - /* check if DigField() has caused relocation of the player */ if (player->jx != jx || player->jy != jy) return MP_NO_ACTION; /* <-- !!! CHECK THIS [-> MP_ACTION ?] !!! */ @@ -10986,7 +13565,7 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy) #endif { int old_scroll_x = scroll_x, old_scroll_y = scroll_y; - int offset = (setup.scroll_delay ? 3 : 0); + int offset = game.scroll_delay_value; if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy))) { @@ -11070,7 +13649,7 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy) else if (old_jx == jx && old_jy != jy) player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP); - DrawLevelField(jx, jy); /* for "crumbled sand" */ + TEST_DrawLevelField(jx, jy); /* for "crumbled sand" */ player->last_move_dir = player->MovDir; player->is_moving = TRUE; @@ -11175,12 +13754,6 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) else if (!FrameReached(&player->actual_frame_counter, 1)) return; -#if 0 - printf("::: player->MovPos: %d -> %d\n", - player->MovPos, - player->MovPos + (player->MovPos > 0 ? -1 : 1) * move_stepsize); -#endif - #if USE_NEW_PLAYER_SPEED if (player->MovPos != 0) { @@ -11202,10 +13775,6 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) if (player->MovPos == 0) /* player reached destination field */ { -#if 0 - printf("::: player reached destination field\n"); -#endif - if (player->move_delay_reset_counter > 0) { player->move_delay_reset_counter--; @@ -11224,6 +13793,15 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) player->last_jy = jy; if (Feld[jx][jy] == EL_EXIT_OPEN || + Feld[jx][jy] == EL_EM_EXIT_OPEN || +#if 1 + Feld[jx][jy] == EL_EM_EXIT_OPENING || +#endif + Feld[jx][jy] == EL_STEEL_EXIT_OPEN || + Feld[jx][jy] == EL_EM_STEEL_EXIT_OPEN || +#if 1 + Feld[jx][jy] == EL_EM_STEEL_EXIT_OPENING || +#endif Feld[jx][jy] == EL_SP_EXIT_OPEN || Feld[jx][jy] == EL_SP_EXIT_OPENING) /* <-- special case */ { @@ -11232,7 +13810,7 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) if (local_player->friends_still_needed == 0 || IS_SP_ELEMENT(Feld[jx][jy])) - player->LevelSolved = player->GameOver = TRUE; + PlayerWins(player); } /* this breaks one level: "machine", level 000 */ @@ -11262,8 +13840,13 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) CE_PLAYER_ENTERS_X, player->index_bit, enter_side); +#if USE_FIX_CE_ACTION_WITH_PLAYER + CheckTriggeredElementChangeBySide(jx, jy, player->initial_element, + CE_MOVE_OF_X, move_direction); +#else CheckTriggeredElementChangeBySide(jx, jy, player->element_nr, CE_MOVE_OF_X, move_direction); +#endif } if (game.engine_version >= VERSION_IDENT(3,0,7,0)) @@ -11280,7 +13863,7 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) RemovePlayer(player); } - if (level.use_step_counter) + if (!local_player->LevelSolved && level.use_step_counter) { int i; @@ -11291,16 +13874,31 @@ void ScrollPlayer(struct PlayerInfo *player, int mode) TimeLeft--; if (TimeLeft <= 10 && setup.time_limit) - PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE); + PlaySound(SND_GAME_RUNNING_OUT_OF_TIME); + +#if 1 + game_panel_controls[GAME_PANEL_TIME].value = TimeLeft; + DisplayGameControlValues(); +#else DrawGameValue_Time(TimeLeft); +#endif if (!TimeLeft && setup.time_limit) for (i = 0; i < MAX_PLAYERS; i++) KillPlayer(&stored_player[i]); } +#if 1 + else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */ + { + game_panel_controls[GAME_PANEL_TIME].value = TimePlayed; + + DisplayGameControlValues(); + } +#else else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */ DrawGameValue_Time(TimePlayed); +#endif } if (tape.single_step && tape.recording && !tape.pausing && @@ -11375,7 +13973,7 @@ void TestIfPlayerTouchesCustomElement(int x, int y) if (!IN_LEV_FIELD(xx, yy)) continue; - if (IS_PLAYER(x, y)) + if (IS_PLAYER(x, y)) /* player found at center element */ { struct PlayerInfo *player = PLAYERINFO(x, y); @@ -11393,8 +13991,21 @@ void TestIfPlayerTouchesCustomElement(int x, int y) CheckTriggeredElementChangeByPlayer(xx, yy, border_element, CE_PLAYER_TOUCHES_X, player->index_bit, border_side); + +#if USE_FIX_CE_ACTION_WITH_PLAYER + { + /* use player element that is initially defined in the level playfield, + not the player element that corresponds to the runtime player number + (example: a level that contains EL_PLAYER_3 as the only player would + incorrectly give EL_PLAYER_1 for "player->element_nr") */ + int player_element = PLAYERINFO(x, y)->initial_element; + + CheckElementChangeBySide(xx, yy, border_element, player_element, + CE_TOUCHING_X, border_side); + } +#endif } - else if (IS_PLAYER(xx, yy)) + else if (IS_PLAYER(xx, yy)) /* player found at border element */ { struct PlayerInfo *player = PLAYERINFO(xx, yy); @@ -11409,6 +14020,20 @@ void TestIfPlayerTouchesCustomElement(int x, int y) CheckTriggeredElementChangeByPlayer(x, y, center_element, CE_PLAYER_TOUCHES_X, player->index_bit, center_side); + +#if USE_FIX_CE_ACTION_WITH_PLAYER + { + /* use player element that is initially defined in the level playfield, + not the player element that corresponds to the runtime player number + (example: a level that contains EL_PLAYER_3 as the only player would + incorrectly give EL_PLAYER_1 for "player->element_nr") */ + int player_element = PLAYERINFO(xx, yy)->initial_element; + + CheckElementChangeBySide(x, y, center_element, player_element, + CE_TOUCHING_X, center_side); + } +#endif + break; } } @@ -11481,10 +14106,14 @@ void TestIfElementTouchesCustomElement(int x, int y) /* check for change of border element */ CheckElementChangeBySide(xx, yy, border_element, center_element, CE_TOUCHING_X, center_side); + + /* (center element cannot be player, so we dont have to check this here) */ } for (i = 0; i < NUM_DIRECTIONS; i++) { + int xx = x + xy[i][0]; + int yy = y + xy[i][1]; int border_side = trigger_sides[i][1]; int border_element = border_element_old[i]; @@ -11496,6 +14125,20 @@ void TestIfElementTouchesCustomElement(int x, int y) change_center_element = CheckElementChangeBySide(x, y, center_element, border_element, CE_TOUCHING_X, border_side); + +#if USE_FIX_CE_ACTION_WITH_PLAYER + if (IS_PLAYER(xx, yy)) + { + /* use player element that is initially defined in the level playfield, + not the player element that corresponds to the runtime player number + (example: a level that contains EL_PLAYER_3 as the only player would + incorrectly give EL_PLAYER_1 for "player->element_nr") */ + int player_element = PLAYERINFO(xx, yy)->initial_element; + + CheckElementChangeBySide(x, y, center_element, player_element, + CE_TOUCHING_X, border_side); + } +#endif } } @@ -11593,11 +14236,25 @@ void TestIfElementHitsCustomElement(int x, int y, int direction) CheckElementChangeBySide(x, y, hitting_element, touched_element, CE_HITTING_X, touched_side); - CheckElementChangeBySide(hitx, hity, touched_element, - hitting_element, CE_HIT_BY_X, hitting_side); + CheckElementChangeBySide(hitx, hity, touched_element, hitting_element, + CE_HIT_BY_X, hitting_side); CheckElementChangeBySide(hitx, hity, touched_element, hitting_element, CE_HIT_BY_SOMETHING, opposite_direction); + +#if USE_FIX_CE_ACTION_WITH_PLAYER + if (IS_PLAYER(hitx, hity)) + { + /* use player element that is initially defined in the level playfield, + not the player element that corresponds to the runtime player number + (example: a level that contains EL_PLAYER_3 as the only player would + incorrectly give EL_PLAYER_1 for "player->element_nr") */ + int player_element = PLAYERINFO(hitx, hity)->initial_element; + + CheckElementChangeBySide(x, y, hitting_element, player_element, + CE_HITTING_X, touched_side); + } +#endif } } @@ -11770,6 +14427,7 @@ void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir) test_x = bad_x + test_xy[i][0]; test_y = bad_y + test_xy[i][1]; + if (!IN_LEV_FIELD(test_x, test_y)) continue; @@ -11800,12 +14458,14 @@ void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir) kill_x = test_x; kill_y = test_y; + break; } else if (test_element == EL_PENGUIN) { kill_x = test_x; kill_y = test_y; + break; } } @@ -11828,6 +14488,63 @@ void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir) } } +void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir) +{ + int bad_element = Feld[bad_x][bad_y]; + int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0); + int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0); + int test_x = bad_x + dx, test_y = bad_y + dy; + int test_move_dir, test_element; + int kill_x = -1, kill_y = -1; + + if (!IN_LEV_FIELD(test_x, test_y)) + return; + + test_move_dir = + (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE); + + test_element = Feld[test_x][test_y]; + + if (test_move_dir != bad_move_dir) + { + /* good thing can be player or penguin that does not move away */ + if (IS_PLAYER(test_x, test_y)) + { + struct PlayerInfo *player = PLAYERINFO(test_x, test_y); + + /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the + player as being hit when he is moving towards the bad thing, because + the "get hit by" condition would be lost after the player stops) */ + if (player->MovPos != 0 && player->MovDir == bad_move_dir) + return; /* player moves away from bad thing */ + + kill_x = test_x; + kill_y = test_y; + } + else if (test_element == EL_PENGUIN) + { + kill_x = test_x; + kill_y = test_y; + } + } + + if (kill_x != -1 || kill_y != -1) + { + if (IS_PLAYER(kill_x, kill_y)) + { + struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y); + + if (player->shield_deadly_time_left > 0 && + !IS_INDESTRUCTIBLE(bad_element)) + Bang(bad_x, bad_y); + else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y)) + KillPlayer(player); + } + else + Bang(kill_x, kill_y); + } +} + void TestIfPlayerTouchesBadThing(int x, int y) { TestIfGoodThingHitsBadThing(x, y, MV_NONE); @@ -11899,6 +14616,28 @@ void KillPlayer(struct PlayerInfo *player) if (!player->active) return; +#if 0 + printf("::: 0: killed == %d, active == %d, reanimated == %d\n", + player->killed, player->active, player->reanimated); +#endif + + /* the following code was introduced to prevent an infinite loop when calling + -> Bang() + -> CheckTriggeredElementChangeExt() + -> ExecuteCustomElementAction() + -> KillPlayer() + -> (infinitely repeating the above sequence of function calls) + which occurs when killing the player while having a CE with the setting + "kill player X when explosion of "; the solution using a new + field "player->killed" was chosen for backwards compatibility, although + clever use of the fields "player->active" etc. would probably also work */ +#if 1 + if (player->killed) + return; +#endif + + player->killed = TRUE; + /* remove accessible field at the player's position */ Feld[jx][jy] = EL_EMPTY; @@ -11906,8 +14645,31 @@ void KillPlayer(struct PlayerInfo *player) player->shield_normal_time_left = 0; player->shield_deadly_time_left = 0; +#if 0 + printf("::: 1: killed == %d, active == %d, reanimated == %d\n", + player->killed, player->active, player->reanimated); +#endif + Bang(jx, jy); + +#if 0 + printf("::: 2: killed == %d, active == %d, reanimated == %d\n", + player->killed, player->active, player->reanimated); +#endif + +#if USE_PLAYER_REANIMATION +#if 1 + if (player->reanimated) /* killed player may have been reanimated */ + player->killed = player->reanimated = FALSE; + else + BuryPlayer(player); +#else + if (player->killed) /* player may have been reanimated */ + BuryPlayer(player); +#endif +#else BuryPlayer(player); +#endif } static void KillPlayerUnlessEnemyProtected(int x, int y) @@ -11948,7 +14710,7 @@ void RemovePlayer(struct PlayerInfo *player) StorePlayer[jx][jy] = 0; if (player->is_moving) - DrawLevelField(player->last_jx, player->last_jy); + TEST_DrawLevelField(player->last_jx, player->last_jy); for (i = 0; i < MAX_PLAYERS; i++) if (stored_player[i].active) @@ -12019,9 +14781,9 @@ static boolean checkDiagonalPushing(struct PlayerInfo *player, ============================================================================= */ -int DigField(struct PlayerInfo *player, - int oldx, int oldy, int x, int y, - int real_dx, int real_dy, int mode) +static int DigField(struct PlayerInfo *player, + int oldx, int oldy, int x, int y, + int real_dx, int real_dy, int mode) { boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG); boolean player_was_pushing = player->is_pushing; @@ -12077,31 +14839,6 @@ int DigField(struct PlayerInfo *player, game.engine_version >= VERSION_IDENT(2,2,0,0)) old_element = Back[jx][jy]; - /* checking here causes player to move into acid even if the current field - cannot be left to that direction */ -#if 0 -#if USE_FIXED_DONT_RUN_INTO - if (player_can_move && DONT_RUN_INTO(element)) - { - if (element == EL_ACID && dx == 0 && dy == 1) - { - SplashAcid(x, y); - Feld[jx][jy] = EL_PLAYER_1; - InitMovingField(jx, jy, MV_DOWN); - Store[jx][jy] = EL_ACID; - ContinueMoving(jx, jy); - BuryPlayer(player); - } - else - TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir); - - return MP_DONT_RUN_INTO; - } -#endif -#endif - -#if 1 /* ------------------------------ NEW ------------------------------ */ - if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction)) return MP_NO_ACTION; /* field has no opening in this direction */ @@ -12112,11 +14849,8 @@ int DigField(struct PlayerInfo *player, if (player_can_move && element == EL_ACID && move_direction == MV_DOWN) { SplashAcid(x, y); -#if 1 + Feld[jx][jy] = player->artwork_element; -#else - Feld[jx][jy] = EL_PLAYER_1; -#endif InitMovingField(jx, jy, MV_DOWN); Store[jx][jy] = EL_ACID; ContinueMoving(jx, jy); @@ -12135,65 +14869,6 @@ int DigField(struct PlayerInfo *player, } #endif -#else /* ------------------------------ OLD ------------------------------ */ - -#if 1 -#if USE_FIXED_DONT_RUN_INTO - if (player_can_move && DONT_RUN_INTO(element)) - { - TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir); - - return MP_DONT_RUN_INTO; - } -#endif -#endif - - if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction)) - return MP_NO_ACTION; /* field has no opening in this direction */ - - if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction)) - return MP_NO_ACTION; /* field has no opening in this direction */ - - /* checking here causes player to explode when moving into acid */ -#if 1 -#if USE_FIXED_DONT_RUN_INTO - if (player_can_move && element == EL_ACID && move_direction == MV_DOWN) - { - SplashAcid(x, y); - Feld[jx][jy] = EL_PLAYER_1; - InitMovingField(jx, jy, MV_DOWN); - Store[jx][jy] = EL_ACID; - ContinueMoving(jx, jy); - BuryPlayer(player); - - return MP_DONT_RUN_INTO; - } -#endif -#endif - -#endif /* ------------------------------ END ------------------------------ */ - -#if 0 -#if USE_FIXED_DONT_RUN_INTO - if (player_can_move && DONT_RUN_INTO(element)) - { - if (element == EL_ACID && dx == 0 && dy == 1) - { - SplashAcid(x, y); - Feld[jx][jy] = EL_PLAYER_1; - InitMovingField(jx, jy, MV_DOWN); - Store[jx][jy] = EL_ACID; - ContinueMoving(jx, jy); - BuryPlayer(player); - } - else - TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir); - - return MP_DONT_RUN_INTO; - } -#endif -#endif - #if USE_FIXED_DONT_RUN_INTO if (IS_MOVING(x, y) || IS_PLAYER(x, y)) return MP_NO_ACTION; @@ -12219,6 +14894,9 @@ int DigField(struct PlayerInfo *player, CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X, player->index_bit, dig_side); + if (element == EL_DC_LANDMINE) + Bang(x, y); + if (Feld[x][y] != element) /* field changed by snapping */ return MP_ACTION; @@ -12259,6 +14937,15 @@ int DigField(struct PlayerInfo *player, return MP_NO_ACTION; } else if (element == EL_EXIT_OPEN || + element == EL_EM_EXIT_OPEN || +#if 1 + element == EL_EM_EXIT_OPENING || +#endif + element == EL_STEEL_EXIT_OPEN || + element == EL_EM_STEEL_EXIT_OPEN || +#if 1 + element == EL_EM_STEEL_EXIT_OPENING || +#endif element == EL_SP_EXIT_OPEN || element == EL_SP_EXIT_OPENING) { @@ -12314,6 +15001,15 @@ int DigField(struct PlayerInfo *player, if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)]) return MP_NO_ACTION; } + else if (element == EL_DC_GATE_WHITE || + element == EL_DC_GATE_WHITE_GRAY || + element == EL_DC_GATE_WHITE_GRAY_ACTIVE) + { + if (player->num_white_keys == 0) + return MP_NO_ACTION; + + player->num_white_keys--; + } else if (IS_SP_PORT(element)) { if (element == EL_SP_GRAVITY_PORT_LEFT || @@ -12404,7 +15100,14 @@ int DigField(struct PlayerInfo *player, else if (element == EL_EXTRA_TIME && level.time > 0) { TimeLeft += level.extra_time; + +#if 1 + game_panel_controls[GAME_PANEL_TIME].value = TimeLeft; + + DisplayGameControlValues(); +#else DrawGameValue_Time(TimeLeft); +#endif } else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY) { @@ -12419,11 +15122,7 @@ int DigField(struct PlayerInfo *player, if (player->inventory_size < MAX_INVENTORY_SIZE) player->inventory_element[player->inventory_size++] = element; -#if 1 DrawGameDoorValues(); -#else - DrawGameValue_Dynamite(local_player->inventory_size); -#endif } else if (element == EL_DYNABOMB_INCREASE_NUMBER) { @@ -12442,13 +15141,14 @@ int DigField(struct PlayerInfo *player, { player->key[KEY_NR(element)] = TRUE; -#if 1 DrawGameDoorValues(); -#else - DrawGameValue_Keys(player->key); -#endif + } + else if (element == EL_DC_KEY_WHITE) + { + player->num_white_keys++; - redraw_mask |= REDRAW_DOOR_1; + /* display white keys? */ + /* DrawGameDoorValues(); */ } else if (IS_ENVELOPE(element)) { @@ -12478,11 +15178,7 @@ int DigField(struct PlayerInfo *player, if (player->inventory_size < MAX_INVENTORY_SIZE) player->inventory_element[player->inventory_size++] = element; -#if 1 DrawGameDoorValues(); -#else - DrawGameValue_Dynamite(local_player->inventory_size); -#endif } else if (collect_count > 0) { @@ -12490,7 +15186,13 @@ int DigField(struct PlayerInfo *player, if (local_player->gems_still_needed < 0) local_player->gems_still_needed = 0; +#if 1 + game_panel_controls[GAME_PANEL_GEMS].value = local_player->gems_still_needed; + + DisplayGameControlValues(); +#else DrawGameValue_Emeralds(local_player->gems_still_needed); +#endif } RaiseScoreElement(element); @@ -12566,8 +15268,10 @@ int DigField(struct PlayerInfo *player, if (!(IN_LEV_FIELD(nextx, nexty) && (IS_FREE(nextx, nexty) || - (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY && - IS_SB_ELEMENT(element))))) + (IS_SB_ELEMENT(element) && + Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) || + (IS_CUSTOM_ELEMENT(element) && + CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))))) return MP_NO_ACTION; if (!checkDiagonalPushing(player, x, y, real_dx, real_dy)) @@ -12587,6 +15291,13 @@ int DigField(struct PlayerInfo *player, return MP_NO_ACTION; } + if (IS_CUSTOM_ELEMENT(element) && + CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)) + { + if (!DigFieldByCE(nextx, nexty, element)) + return MP_NO_ACTION; + } + if (IS_SB_ELEMENT(element)) { if (element == EL_SOKOBAN_FIELD_FULL) @@ -12615,7 +15326,8 @@ int DigField(struct PlayerInfo *player, if (local_player->sokobanfields_still_needed == 0 && game.emulation == EMU_SOKOBAN) { - player->LevelSolved = player->GameOver = TRUE; + PlayerWins(player); + PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING); } } @@ -12669,17 +15381,15 @@ int DigField(struct PlayerInfo *player, ZX = x; ZY = y; - DrawLevelField(x, y); + game.robot_wheel_active = TRUE; + + TEST_DrawLevelField(x, y); } else if (element == EL_SP_TERMINAL) { int xx, yy; -#if 1 SCAN_PLAYFIELD(xx, yy) -#else - for (yy = 0; yy < lev_fieldy; yy++) for (xx = 0; xx < lev_fieldx; xx++) -#endif { if (Feld[xx][yy] == EL_SP_DISK_YELLOW) Bang(xx, yy); @@ -12692,7 +15402,9 @@ int DigField(struct PlayerInfo *player, ToggleBeltSwitch(x, y); } else if (element == EL_SWITCHGATE_SWITCH_UP || - element == EL_SWITCHGATE_SWITCH_DOWN) + element == EL_SWITCHGATE_SWITCH_DOWN || + element == EL_DC_SWITCHGATE_SWITCH_UP || + element == EL_DC_SWITCHGATE_SWITCH_DOWN) { ToggleSwitchgateSwitch(x, y); } @@ -12701,7 +15413,8 @@ int DigField(struct PlayerInfo *player, { ToggleLightSwitch(x, y); } - else if (element == EL_TIMEGATE_SWITCH) + else if (element == EL_TIMEGATE_SWITCH || + element == EL_DC_TIMEGATE_SWITCH) { ActivateTimegateSwitch(x, y); } @@ -12725,7 +15438,7 @@ int DigField(struct PlayerInfo *player, local_player->lights_still_needed--; ResetGfxAnimation(x, y); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_TIME_ORB_FULL) { @@ -12734,11 +15447,18 @@ int DigField(struct PlayerInfo *player, if (level.time > 0 || level.use_time_orb_bug) { TimeLeft += level.time_orb_time; + +#if 1 + game_panel_controls[GAME_PANEL_TIME].value = TimeLeft; + + DisplayGameControlValues(); +#else DrawGameValue_Time(TimeLeft); +#endif } ResetGfxAnimation(x, y); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); } else if (element == EL_EMC_MAGIC_BALL_SWITCH || element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE) @@ -12747,11 +15467,7 @@ int DigField(struct PlayerInfo *player, game.ball_state = !game.ball_state; -#if 1 SCAN_PLAYFIELD(xx, yy) -#else - for (yy = 0; yy < lev_fieldy; yy++) for (xx = 0; xx < lev_fieldx; xx++) -#endif { int e = Feld[xx][yy]; @@ -12821,10 +15537,69 @@ int DigField(struct PlayerInfo *player, } } - return MP_MOVING; + return MP_MOVING; +} + +static boolean DigFieldByCE(int x, int y, int digging_element) +{ + int element = Feld[x][y]; + + if (!IS_FREE(x, y)) + { + int action = (IS_DIGGABLE(element) ? ACTION_DIGGING : + IS_COLLECTIBLE(element) ? ACTION_COLLECTING : + ACTION_BREAKING); + + /* no element can dig solid indestructible elements */ + if (IS_INDESTRUCTIBLE(element) && + !IS_DIGGABLE(element) && + !IS_COLLECTIBLE(element)) + return FALSE; + + if (AmoebaNr[x][y] && + (element == EL_AMOEBA_FULL || + element == EL_BD_AMOEBA || + element == EL_AMOEBA_GROWING)) + { + AmoebaCnt[AmoebaNr[x][y]]--; + AmoebaCnt2[AmoebaNr[x][y]]--; + } + + if (IS_MOVING(x, y)) + RemoveMovingField(x, y); + else + { + RemoveField(x, y); + TEST_DrawLevelField(x, y); + } + + /* if digged element was about to explode, prevent the explosion */ + ExplodeField[x][y] = EX_TYPE_NONE; + + PlayLevelSoundAction(x, y, action); + } + + Store[x][y] = EL_EMPTY; + +#if 1 + /* this makes it possible to leave the removed element again */ + if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element))) + Store[x][y] = element; +#else + if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element))) + { + int move_leave_element = element_info[digging_element].move_leave_element; + + /* this makes it possible to leave the removed element again */ + Store[x][y] = (move_leave_element == EL_TRIGGER_ELEMENT ? + element : move_leave_element); + } +#endif + + return TRUE; } -boolean SnapField(struct PlayerInfo *player, int dx, int dy) +static boolean SnapField(struct PlayerInfo *player, int dx, int dy) { int jx = player->jx, jy = player->jy; int x = jx + dx, y = jy + dy; @@ -12897,19 +15672,22 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy) } if (player->MovPos != 0) /* prevent graphic bugs in versions < 2.2.0 */ - DrawLevelField(player->last_jx, player->last_jy); + TEST_DrawLevelField(player->last_jx, player->last_jy); - DrawLevelField(x, y); + TEST_DrawLevelField(x, y); return TRUE; } -boolean DropElement(struct PlayerInfo *player) +static boolean DropElement(struct PlayerInfo *player) { int old_element, new_element; int dropx = player->jx, dropy = player->jy; int drop_direction = player->MovDir; int drop_side = drop_direction; +#if 1 + int drop_element = get_next_dropped_element(player); +#else int drop_element = (player->inventory_size > 0 ? player->inventory_element[player->inventory_size - 1] : player->inventory_infinite_element != EL_UNDEFINED ? @@ -12917,6 +15695,7 @@ boolean DropElement(struct PlayerInfo *player) player->dynabombs_left > 0 ? EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr : EL_UNDEFINED); +#endif player->is_dropping_pressed = TRUE; @@ -12972,11 +15751,7 @@ boolean DropElement(struct PlayerInfo *player) { player->inventory_size--; -#if 1 DrawGameDoorValues(); -#else - DrawGameValue_Dynamite(local_player->inventory_size); -#endif if (new_element == EL_DYNAMITE) new_element = EL_DYNAMITE_ACTIVE; @@ -13036,7 +15811,13 @@ boolean DropElement(struct PlayerInfo *player) nexty = dropy + GET_DY_FROM_DIR(move_direction); ChangeCount[dropx][dropy] = 0; /* allow at least one more change */ + +#if USE_FIX_IMPACT_COLLISION + /* do not cause impact style collision by dropping elements that can fall */ + CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION; +#else CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION; +#endif } player->drop_delay = GET_NEW_DROP_DELAY(drop_element); @@ -13169,9 +15950,12 @@ static void PlayLevelMusic() PlayMusic(MAP_NOCONF_MUSIC(level_nr)); /* from music dir */ } -void PlayLevelSound_EM(int x, int y, int element_em, int sample) +void PlayLevelSound_EM(int xx, int yy, int element_em, int sample) { int element = (element_em > -1 ? map_element_EM_to_RND(element_em) : 0); + int offset = (BorderElement == EL_STEELWALL ? 1 : 0); + int x = xx - 1 - offset; + int y = yy - 1 - offset; switch (sample) { @@ -13317,7 +16101,7 @@ void PlayLevelSound_EM(int x, int y, int element_em, int sample) break; case SAMPLE_time: - PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE); + PlaySound(SND_GAME_RUNNING_OUT_OF_TIME); break; default: @@ -13326,16 +16110,47 @@ void PlayLevelSound_EM(int x, int y, int element_em, int sample) } } +#if 0 +void ChangeTime(int value) +{ + int *time = (level.time == 0 ? &TimePlayed : &TimeLeft); + + *time += value; + + /* EMC game engine uses value from time counter of RND game engine */ + level.native_em_level->lev->time = *time; + + DrawGameValue_Time(*time); +} + +void RaiseScore(int value) +{ + /* EMC game engine and RND game engine have separate score counters */ + int *score = (level.game_engine_type == GAME_ENGINE_TYPE_EM ? + &level.native_em_level->lev->score : &local_player->score); + + *score += value; + + DrawGameValue_Score(*score); +} +#endif + void RaiseScore(int value) { local_player->score += value; +#if 1 + game_panel_controls[GAME_PANEL_SCORE].value = local_player->score; + + DisplayGameControlValues(); +#else DrawGameValue_Score(local_player->score); +#endif } void RaiseScoreElement(int element) { - switch(element) + switch (element) { case EL_EMERALD: case EL_BD_DIAMOND: @@ -13404,6 +16219,7 @@ void RaiseScoreElement(int element) case EL_EMC_KEY_6: case EL_EMC_KEY_7: case EL_EMC_KEY_8: + case EL_DC_KEY_WHITE: RaiseScore(level.score[SC_KEY]); break; default: @@ -13412,13 +16228,9 @@ void RaiseScoreElement(int element) } } -void RequestQuitGame(boolean ask_if_really_quit) +void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message) { - if (AllPlayersGone || - !ask_if_really_quit || - level_editor_test_game || - Request("Do you really want to quit the game ?", - REQ_ASK | REQ_STAY_CLOSED)) + if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED)) { #if defined(NETWORK_AVALIABLE) if (options.network) @@ -13426,15 +16238,33 @@ void RequestQuitGame(boolean ask_if_really_quit) else #endif { - if (!ask_if_really_quit || level_editor_test_game) + if (quick_quit) { +#if 1 + +#if 1 + FadeSkipNextFadeIn(); +#else + fading = fading_none; +#endif + +#else + OpenDoor(DOOR_CLOSE_1); +#endif + game_status = GAME_MODE_MAIN; +#if 1 + DrawAndFadeInMainMenu(REDRAW_FIELD); +#else DrawMainMenu(); +#endif } else { +#if 0 FadeOut(REDRAW_FIELD); +#endif game_status = GAME_MODE_MAIN; @@ -13442,7 +16272,7 @@ void RequestQuitGame(boolean ask_if_really_quit) } } } - else + else /* continue playing the game */ { if (tape.playing && tape.deactivate_display) TapeDeactivateDisplayOff(TRUE); @@ -13454,6 +16284,325 @@ void RequestQuitGame(boolean ask_if_really_quit) } } +void RequestQuitGame(boolean ask_if_really_quit) +{ + boolean quick_quit = (!ask_if_really_quit || level_editor_test_game); + boolean skip_request = AllPlayersGone || quick_quit; + + RequestQuitGameExt(skip_request, quick_quit, + "Do you really want to quit the game ?"); +} + + +/* ------------------------------------------------------------------------- */ +/* random generator functions */ +/* ------------------------------------------------------------------------- */ + +unsigned int InitEngineRandom_RND(long seed) +{ + game.num_random_calls = 0; + +#if 0 + unsigned int rnd_seed = InitEngineRandom(seed); + + printf("::: START RND: %d\n", rnd_seed); + + return rnd_seed; +#else + + return InitEngineRandom(seed); + +#endif + +} + +unsigned int RND(int max) +{ + if (max > 0) + { + game.num_random_calls++; + + return GetEngineRandom(max); + } + + return 0; +} + + +/* ------------------------------------------------------------------------- */ +/* game engine snapshot handling functions */ +/* ------------------------------------------------------------------------- */ + +#define ARGS_ADDRESS_AND_SIZEOF(x) (&(x)), (sizeof(x)) + +struct EngineSnapshotInfo +{ + /* runtime values for custom element collect score */ + int collect_score[NUM_CUSTOM_ELEMENTS]; + + /* runtime values for group element choice position */ + int choice_pos[NUM_GROUP_ELEMENTS]; + + /* runtime values for belt position animations */ + int belt_graphic[4 * NUM_BELT_PARTS]; + int belt_anim_mode[4 * NUM_BELT_PARTS]; +}; + +struct EngineSnapshotNodeInfo +{ + void *buffer_orig; + void *buffer_copy; + int size; +}; + +static struct EngineSnapshotInfo engine_snapshot_rnd; +static ListNode *engine_snapshot_list = NULL; +static char *snapshot_level_identifier = NULL; +static int snapshot_level_nr = -1; + +void FreeEngineSnapshot() +{ + while (engine_snapshot_list != NULL) + deleteNodeFromList(&engine_snapshot_list, engine_snapshot_list->key, + checked_free); + + setString(&snapshot_level_identifier, NULL); + snapshot_level_nr = -1; +} + +static void SaveEngineSnapshotValues_RND() +{ + static int belt_base_active_element[4] = + { + EL_CONVEYOR_BELT_1_LEFT_ACTIVE, + EL_CONVEYOR_BELT_2_LEFT_ACTIVE, + EL_CONVEYOR_BELT_3_LEFT_ACTIVE, + EL_CONVEYOR_BELT_4_LEFT_ACTIVE + }; + int i, j; + + for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++) + { + int element = EL_CUSTOM_START + i; + + engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score; + } + + for (i = 0; i < NUM_GROUP_ELEMENTS; i++) + { + int element = EL_GROUP_START + i; + + engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos; + } + + for (i = 0; i < 4; i++) + { + for (j = 0; j < NUM_BELT_PARTS; j++) + { + int element = belt_base_active_element[i] + j; + int graphic = el2img(element); + int anim_mode = graphic_info[graphic].anim_mode; + + engine_snapshot_rnd.belt_graphic[i * 4 + j] = graphic; + engine_snapshot_rnd.belt_anim_mode[i * 4 + j] = anim_mode; + } + } +} + +static void LoadEngineSnapshotValues_RND() +{ + unsigned long num_random_calls = game.num_random_calls; + int i, j; + + for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++) + { + int element = EL_CUSTOM_START + i; + + element_info[element].collect_score = engine_snapshot_rnd.collect_score[i]; + } + + for (i = 0; i < NUM_GROUP_ELEMENTS; i++) + { + int element = EL_GROUP_START + i; + + element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i]; + } + + for (i = 0; i < 4; i++) + { + for (j = 0; j < NUM_BELT_PARTS; j++) + { + int graphic = engine_snapshot_rnd.belt_graphic[i * 4 + j]; + int anim_mode = engine_snapshot_rnd.belt_anim_mode[i * 4 + j]; + + graphic_info[graphic].anim_mode = anim_mode; + } + } + + if (level.game_engine_type == GAME_ENGINE_TYPE_RND) + { + InitRND(tape.random_seed); + for (i = 0; i < num_random_calls; i++) + RND(1); + } + + if (game.num_random_calls != num_random_calls) + { + Error(ERR_INFO, "number of random calls out of sync"); + Error(ERR_INFO, "number of random calls should be %d", num_random_calls); + Error(ERR_INFO, "number of random calls is %d", game.num_random_calls); + Error(ERR_EXIT, "this should not happen -- please debug"); + } +} + +static void SaveEngineSnapshotBuffer(void *buffer, int size) +{ + struct EngineSnapshotNodeInfo *bi = + checked_calloc(sizeof(struct EngineSnapshotNodeInfo)); + + bi->buffer_orig = buffer; + bi->buffer_copy = checked_malloc(size); + bi->size = size; + + memcpy(bi->buffer_copy, buffer, size); + + addNodeToList(&engine_snapshot_list, NULL, bi); +} + +void SaveEngineSnapshot() +{ + FreeEngineSnapshot(); /* free previous snapshot, if needed */ + + if (level_editor_test_game) /* do not save snapshots from editor */ + return; + + /* copy some special values to a structure better suited for the snapshot */ + + SaveEngineSnapshotValues_RND(); + SaveEngineSnapshotValues_EM(); + + /* save values stored in special snapshot structure */ + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em)); + + /* save further RND engine values */ + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(stored_player)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(game)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(tape)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ZX)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ZY)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ExitX)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ExitY)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(FrameCounter)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(TimeFrames)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(TimePlayed)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(TimeLeft)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(TapeTime)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(AllPlayersGone)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(Feld)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(MovPos)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(MovDir)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(MovDelay)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ChangeDelay)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ChangePage)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(CustomValue)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(Store)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(Store2)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(StorePlayer)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(Back)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(AmoebaNr)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(WasJustMoving)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(WasJustFalling)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(CheckCollision)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(CheckImpact)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(Stop)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(Pushed)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ChangeCount)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ChangeEvent)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ExplodePhase)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(ExplodeField)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(RunnerVisit)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(PlayerVisit)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(GfxFrame)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(GfxRandom)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(GfxElement)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(GfxAction)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(GfxDir)); + + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(scroll_x)); + SaveEngineSnapshotBuffer(ARGS_ADDRESS_AND_SIZEOF(scroll_y)); + + /* save level identification information */ + + setString(&snapshot_level_identifier, leveldir_current->identifier); + snapshot_level_nr = level_nr; + +#if 0 + ListNode *node = engine_snapshot_list; + int num_bytes = 0; + + while (node != NULL) + { + num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size; + + node = node->next; + } + + printf("::: size of engine snapshot: %d bytes\n", num_bytes); +#endif +} + +static void LoadEngineSnapshotBuffer(struct EngineSnapshotNodeInfo *bi) +{ + memcpy(bi->buffer_orig, bi->buffer_copy, bi->size); +} + +void LoadEngineSnapshot() +{ + ListNode *node = engine_snapshot_list; + + if (engine_snapshot_list == NULL) + return; + + while (node != NULL) + { + LoadEngineSnapshotBuffer((struct EngineSnapshotNodeInfo *)node->content); + + node = node->next; + } + + /* restore special values from snapshot structure */ + + LoadEngineSnapshotValues_RND(); + LoadEngineSnapshotValues_EM(); +} + +boolean CheckEngineSnapshot() +{ + return (strEqual(snapshot_level_identifier, leveldir_current->identifier) && + snapshot_level_nr == level_nr); +} + /* ---------- new game button stuff ---------------------------------------- */ @@ -13474,11 +16623,50 @@ void RequestQuitGame(boolean ask_if_really_quit) static struct { - int x, y; + int *x, *y; + int gd_x, gd_y; int gadget_id; char *infotext; } gamebutton_info[NUM_GAME_BUTTONS] = { +#if 1 + { + &game.button.stop.x, &game.button.stop.y, + GAME_BUTTON_STOP_XPOS, GAME_BUTTON_YPOS, + GAME_CTRL_ID_STOP, + "stop game" + }, + { + &game.button.pause.x, &game.button.pause.y, + GAME_BUTTON_PAUSE_XPOS, GAME_BUTTON_YPOS, + GAME_CTRL_ID_PAUSE, + "pause game" + }, + { + &game.button.play.x, &game.button.play.y, + GAME_BUTTON_PLAY_XPOS, GAME_BUTTON_YPOS, + GAME_CTRL_ID_PLAY, + "play game" + }, + { + &game.button.sound_music.x, &game.button.sound_music.y, + SOUND_BUTTON_MUSIC_XPOS, SOUND_BUTTON_YPOS, + SOUND_CTRL_ID_MUSIC, + "background music on/off" + }, + { + &game.button.sound_loops.x, &game.button.sound_loops.y, + SOUND_BUTTON_LOOPS_XPOS, SOUND_BUTTON_YPOS, + SOUND_CTRL_ID_LOOPS, + "sound loops on/off" + }, + { + &game.button.sound_simple.x,&game.button.sound_simple.y, + SOUND_BUTTON_SIMPLE_XPOS, SOUND_BUTTON_YPOS, + SOUND_CTRL_ID_SIMPLE, + "normal sounds on/off" + } +#else { GAME_BUTTON_STOP_XPOS, GAME_BUTTON_YPOS, GAME_CTRL_ID_STOP, @@ -13509,6 +16697,7 @@ static struct SOUND_CTRL_ID_SIMPLE, "normal sounds on/off" } +#endif }; void CreateGameButtons() @@ -13522,12 +16711,15 @@ void CreateGameButtons() int button_type; boolean checked; unsigned long event_mask; + int x, y; int gd_xoffset, gd_yoffset; int gd_x1, gd_x2, gd_y1, gd_y2; int id = i; - gd_xoffset = gamebutton_info[i].x; - gd_yoffset = gamebutton_info[i].y; + x = DX + *gamebutton_info[i].x; + y = DY + *gamebutton_info[i].y; + gd_xoffset = gamebutton_info[i].gd_x; + gd_yoffset = gamebutton_info[i].gd_y; gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset; gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset; @@ -13555,8 +16747,13 @@ void CreateGameButtons() gi = CreateGadget(GDI_CUSTOM_ID, id, GDI_INFO_TEXT, gamebutton_info[i].infotext, +#if 1 + GDI_X, x, + GDI_Y, y, +#else GDI_X, DX + gd_xoffset, GDI_Y, DY + gd_yoffset, +#endif GDI_WIDTH, GAME_BUTTON_XSIZE, GDI_HEIGHT, GAME_BUTTON_YSIZE, GDI_TYPE, button_type, @@ -13566,6 +16763,7 @@ void CreateGameButtons() GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1, GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2, GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2, + GDI_DIRECT_DRAW, FALSE, GDI_EVENT_MASK, event_mask, GDI_CALLBACK_ACTION, HandleGameButtons, GDI_END); @@ -13601,6 +16799,14 @@ void UnmapGameButtons() UnmapGadget(game_gadget[i]); } +void RedrawGameButtons() +{ + int i; + + for (i = 0; i < NUM_GAME_BUTTONS; i++) + RedrawGadget(game_gadget[i]); +} + static void HandleGameButtons(struct GadgetInfo *gi) { int id = gi->custom_id;