1 /***********************************************************
2 * Rocks'n'Diamonds -- McDuffin Strikes Back! *
3 *----------------------------------------------------------*
4 * (c) 1995-2002 Artsoft Entertainment *
6 * Detmolder Strasse 189 *
9 * e-mail: info@artsoft.org *
10 *----------------------------------------------------------*
12 ***********************************************************/
14 #include "libgame/libgame.h"
24 /* this switch controls how rocks move horizontally */
25 #define OLD_GAME_BEHAVIOUR FALSE
27 /* EXPERIMENTAL STUFF */
28 #define USE_NEW_AMOEBA_CODE FALSE
35 /* for MovePlayer() */
36 #define MF_NO_ACTION 0
40 /* for ScrollPlayer() */
42 #define SCROLL_GO_ON 1
45 #define EX_PHASE_START 0
46 #define EX_NO_EXPLOSION 0
51 /* special positions in the game control window (relative to control window) */
54 #define XX_EMERALDS 29
55 #define YY_EMERALDS 54
56 #define XX_DYNAMITE 29
57 #define YY_DYNAMITE 89
66 /* special positions in the game control window (relative to main window) */
67 #define DX_LEVEL (DX + XX_LEVEL)
68 #define DY_LEVEL (DY + YY_LEVEL)
69 #define DX_EMERALDS (DX + XX_EMERALDS)
70 #define DY_EMERALDS (DY + YY_EMERALDS)
71 #define DX_DYNAMITE (DX + XX_DYNAMITE)
72 #define DY_DYNAMITE (DY + YY_DYNAMITE)
73 #define DX_KEYS (DX + XX_KEYS)
74 #define DY_KEYS (DY + YY_KEYS)
75 #define DX_SCORE (DX + XX_SCORE)
76 #define DY_SCORE (DY + YY_SCORE)
77 #define DX_TIME1 (DX + XX_TIME1)
78 #define DX_TIME2 (DX + XX_TIME2)
79 #define DY_TIME (DY + YY_TIME)
81 /* values for initial player move delay (initial delay counter value) */
82 #define INITIAL_MOVE_DELAY_OFF -1
83 #define INITIAL_MOVE_DELAY_ON 0
85 /* values for player movement speed (which is in fact a delay value) */
86 #define MOVE_DELAY_NORMAL_SPEED 8
87 #define MOVE_DELAY_HIGH_SPEED 4
89 #define DOUBLE_MOVE_DELAY(x) (x = (x <= MOVE_DELAY_HIGH_SPEED ? x * 2 : x))
90 #define HALVE_MOVE_DELAY(x) (x = (x >= MOVE_DELAY_HIGH_SPEED ? x / 2 : x))
91 #define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY((p)->move_delay_value))
92 #define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
94 /* values for other actions */
95 #define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED)
97 #define INIT_GFX_RANDOM() (SimpleRND(1000000))
99 #define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \
100 RND(element_info[e].push_delay_random))
101 #define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
102 RND(element_info[e].move_delay_random))
103 #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
104 (element_info[e].move_delay_random))
106 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
107 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
110 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
111 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
112 (CAN_MOVE_INTO_ACID(e) && \
113 Feld[x][y] == EL_ACID) || \
116 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
117 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
118 (CAN_MOVE_INTO_ACID(e) && \
119 Feld[x][y] == EL_ACID) || \
122 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
123 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
125 (CAN_MOVE_INTO_ACID(e) && \
126 Feld[x][y] == EL_ACID) || \
127 (DONT_COLLIDE_WITH(e) && \
129 !PLAYER_ENEMY_PROTECTED(x, y))))
132 #define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition) \
133 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
135 (DONT_COLLIDE_WITH(e) && \
137 !PLAYER_ENEMY_PROTECTED(x, y))))
140 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
141 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
144 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
145 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
147 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
148 ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, Feld[x][y] == EL_ACID)
152 #define ENEMY_CAN_ENTER_FIELD(e, x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
155 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
156 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
160 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
161 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Feld[x][y] == EL_DIAMOND)
163 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
164 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Feld[x][y]))
166 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
167 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Feld[x][y]))
169 #define PIG_CAN_ENTER_FIELD(e, x, y) \
170 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Feld[x][y]))
172 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
173 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Feld[x][y] == EL_EXIT_OPEN ||\
174 IS_FOOD_PENGUIN(Feld[x][y])))
175 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
176 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
178 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
179 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
181 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
182 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
186 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
187 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
188 (CAN_MOVE_INTO_ACID(e) && \
189 Feld[x][y] == EL_ACID) || \
190 Feld[x][y] == EL_DIAMOND))
192 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
193 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
194 (CAN_MOVE_INTO_ACID(e) && \
195 Feld[x][y] == EL_ACID) || \
196 IS_FOOD_DARK_YAMYAM(Feld[x][y])))
198 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
199 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
200 (CAN_MOVE_INTO_ACID(e) && \
201 Feld[x][y] == EL_ACID) || \
202 IS_AMOEBOID(Feld[x][y])))
204 #define PIG_CAN_ENTER_FIELD(e, x, y) \
205 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
206 (CAN_MOVE_INTO_ACID(e) && \
207 Feld[x][y] == EL_ACID) || \
208 IS_FOOD_PIG(Feld[x][y])))
210 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
211 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
212 (CAN_MOVE_INTO_ACID(e) && \
213 Feld[x][y] == EL_ACID) || \
214 IS_FOOD_PENGUIN(Feld[x][y]) || \
215 Feld[x][y] == EL_EXIT_OPEN))
217 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
218 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
219 (CAN_MOVE_INTO_ACID(e) && \
220 Feld[x][y] == EL_ACID)))
222 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
223 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
224 (CAN_MOVE_INTO_ACID(e) && \
225 Feld[x][y] == EL_ACID) || \
228 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
229 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
230 (CAN_MOVE_INTO_ACID(e) && \
231 Feld[x][y] == EL_ACID)))
235 #define GROUP_NR(e) ((e) - EL_GROUP_START)
236 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
237 #define IS_IN_GROUP(e, nr) (element_info[e].in_group[nr] == TRUE)
238 #define IS_IN_GROUP_EL(e, ge) (IS_IN_GROUP(e, (ge) - EL_GROUP_START))
240 #define IS_EQUAL_OR_IN_GROUP(e, ge) \
241 (IS_GROUP_ELEMENT(ge) ? IS_IN_GROUP(e, GROUP_NR(ge)) : (e) == (ge))
244 #define CE_ENTER_FIELD_COND(e, x, y) \
245 (!IS_PLAYER(x, y) && \
246 (Feld[x][y] == EL_ACID || \
247 IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e))))
249 #define CE_ENTER_FIELD_COND(e, x, y) \
250 (!IS_PLAYER(x, y) && \
251 IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e)))
254 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
255 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
257 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
258 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
260 /* game button identifiers */
261 #define GAME_CTRL_ID_STOP 0
262 #define GAME_CTRL_ID_PAUSE 1
263 #define GAME_CTRL_ID_PLAY 2
264 #define SOUND_CTRL_ID_MUSIC 3
265 #define SOUND_CTRL_ID_LOOPS 4
266 #define SOUND_CTRL_ID_SIMPLE 5
268 #define NUM_GAME_BUTTONS 6
271 /* forward declaration for internal use */
273 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
274 static boolean MovePlayer(struct PlayerInfo *, int, int);
275 static void ScrollPlayer(struct PlayerInfo *, int);
276 static void ScrollScreen(struct PlayerInfo *, int);
278 int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
280 static void InitBeltMovement(void);
281 static void CloseAllOpenTimegates(void);
282 static void CheckGravityMovement(struct PlayerInfo *);
283 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
284 static void KillHeroUnlessEnemyProtected(int, int);
285 static void KillHeroUnlessExplosionProtected(int, int);
287 static void TestIfPlayerTouchesCustomElement(int, int);
288 static void TestIfElementTouchesCustomElement(int, int);
289 static void TestIfElementHitsCustomElement(int, int, int);
291 static void TestIfElementSmashesCustomElement(int, int, int);
294 static void ChangeElement(int, int, int);
296 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
297 #define CheckTriggeredElementChange(x, y, e, ev) \
298 CheckTriggeredElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, -1)
299 #define CheckTriggeredElementChangePlayer(x, y, e, ev, p, s) \
300 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
301 #define CheckTriggeredElementChangeSide(x, y, e, ev, s) \
302 CheckTriggeredElementChangeExt(x, y, e, ev, -1, s, -1)
303 #define CheckTriggeredElementChangePage(x, y, e, ev, p) \
304 CheckTriggeredElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, p)
306 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
307 #define CheckElementChange(x, y, e, ev) \
308 CheckElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, -1)
309 #define CheckElementChangePlayer(x, y, e, ev, p, s) \
310 CheckElementChangeExt(x, y, e, ev, p, s, -1)
311 #define CheckElementChangeSide(x, y, e, ev, s) \
312 CheckElementChangeExt(x, y, e, ev, -1, s, -1)
313 #define CheckElementChangePage(x, y, e, ev, p) \
314 CheckElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, p)
316 static void PlayLevelSound(int, int, int);
317 static void PlayLevelSoundNearest(int, int, int);
318 static void PlayLevelSoundAction(int, int, int);
319 static void PlayLevelSoundElementAction(int, int, int, int);
320 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
321 static void PlayLevelSoundActionIfLoop(int, int, int);
322 static void StopLevelSoundActionIfLoop(int, int, int);
323 static void PlayLevelMusic();
325 static void MapGameButtons();
326 static void HandleGameButtons(struct GadgetInfo *);
328 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
331 /* ------------------------------------------------------------------------- */
332 /* definition of elements that automatically change to other elements after */
333 /* a specified time, eventually calling a function when changing */
334 /* ------------------------------------------------------------------------- */
336 /* forward declaration for changer functions */
337 static void InitBuggyBase(int x, int y);
338 static void WarnBuggyBase(int x, int y);
340 static void InitTrap(int x, int y);
341 static void ActivateTrap(int x, int y);
342 static void ChangeActiveTrap(int x, int y);
344 static void InitRobotWheel(int x, int y);
345 static void RunRobotWheel(int x, int y);
346 static void StopRobotWheel(int x, int y);
348 static void InitTimegateWheel(int x, int y);
349 static void RunTimegateWheel(int x, int y);
351 struct ChangingElementInfo
356 void (*pre_change_function)(int x, int y);
357 void (*change_function)(int x, int y);
358 void (*post_change_function)(int x, int y);
361 static struct ChangingElementInfo change_delay_list[] =
412 EL_SWITCHGATE_OPENING,
420 EL_SWITCHGATE_CLOSING,
421 EL_SWITCHGATE_CLOSED,
453 EL_ACID_SPLASH_RIGHT,
462 EL_SP_BUGGY_BASE_ACTIVATING,
469 EL_SP_BUGGY_BASE_ACTIVATING,
470 EL_SP_BUGGY_BASE_ACTIVE,
477 EL_SP_BUGGY_BASE_ACTIVE,
501 EL_ROBOT_WHEEL_ACTIVE,
509 EL_TIMEGATE_SWITCH_ACTIVE,
530 int push_delay_fixed, push_delay_random;
535 { EL_BALLOON, 0, 0 },
537 { EL_SOKOBAN_OBJECT, 2, 0 },
538 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
539 { EL_SATELLITE, 2, 0 },
540 { EL_SP_DISK_YELLOW, 2, 0 },
542 { EL_UNDEFINED, 0, 0 },
550 move_stepsize_list[] =
552 { EL_AMOEBA_DROP, 2 },
553 { EL_AMOEBA_DROPPING, 2 },
554 { EL_QUICKSAND_FILLING, 1 },
555 { EL_QUICKSAND_EMPTYING, 1 },
556 { EL_MAGIC_WALL_FILLING, 2 },
557 { EL_BD_MAGIC_WALL_FILLING, 2 },
558 { EL_MAGIC_WALL_EMPTYING, 2 },
559 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
569 collect_count_list[] =
572 { EL_BD_DIAMOND, 1 },
573 { EL_EMERALD_YELLOW, 1 },
574 { EL_EMERALD_RED, 1 },
575 { EL_EMERALD_PURPLE, 1 },
577 { EL_SP_INFOTRON, 1 },
591 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
592 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
593 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
594 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
595 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
596 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
597 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
598 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
599 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
600 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
601 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
606 static unsigned long trigger_events[MAX_NUM_ELEMENTS];
608 #define IS_AUTO_CHANGING(e) (element_info[e].change_events & \
609 CH_EVENT_BIT(CE_DELAY))
610 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
611 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Feld[x][y]) || \
612 IS_JUST_CHANGING(x, y))
614 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
617 void GetPlayerConfig()
619 if (!audio.sound_available)
620 setup.sound_simple = FALSE;
622 if (!audio.loops_available)
623 setup.sound_loops = FALSE;
625 if (!audio.music_available)
626 setup.sound_music = FALSE;
628 if (!video.fullscreen_available)
629 setup.fullscreen = FALSE;
631 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
633 SetAudioMode(setup.sound);
637 static int getBeltNrFromBeltElement(int element)
639 return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
640 element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
641 element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
644 static int getBeltNrFromBeltActiveElement(int element)
646 return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
647 element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
648 element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
651 static int getBeltNrFromBeltSwitchElement(int element)
653 return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
654 element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
655 element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
658 static int getBeltDirNrFromBeltSwitchElement(int element)
660 static int belt_base_element[4] =
662 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
663 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
664 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
665 EL_CONVEYOR_BELT_4_SWITCH_LEFT
668 int belt_nr = getBeltNrFromBeltSwitchElement(element);
669 int belt_dir_nr = element - belt_base_element[belt_nr];
671 return (belt_dir_nr % 3);
674 static int getBeltDirFromBeltSwitchElement(int element)
676 static int belt_move_dir[3] =
683 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
685 return belt_move_dir[belt_dir_nr];
688 static void InitPlayerField(int x, int y, int element, boolean init_game)
690 if (element == EL_SP_MURPHY)
694 if (stored_player[0].present)
696 Feld[x][y] = EL_SP_MURPHY_CLONE;
702 stored_player[0].use_murphy_graphic = TRUE;
705 Feld[x][y] = EL_PLAYER_1;
711 struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_PLAYER_1];
712 int jx = player->jx, jy = player->jy;
714 player->present = TRUE;
716 player->block_last_field = (element == EL_SP_MURPHY ?
717 level.sp_block_last_field :
718 level.block_last_field);
720 if (!options.network || player->connected)
722 player->active = TRUE;
724 /* remove potentially duplicate players */
725 if (StorePlayer[jx][jy] == Feld[x][y])
726 StorePlayer[jx][jy] = 0;
728 StorePlayer[x][y] = Feld[x][y];
732 printf("Player %d activated.\n", player->element_nr);
733 printf("[Local player is %d and currently %s.]\n",
734 local_player->element_nr,
735 local_player->active ? "active" : "not active");
739 Feld[x][y] = EL_EMPTY;
740 player->jx = player->last_jx = x;
741 player->jy = player->last_jy = y;
745 static void InitField(int x, int y, boolean init_game)
747 int element = Feld[x][y];
756 InitPlayerField(x, y, element, init_game);
759 case EL_SOKOBAN_FIELD_PLAYER:
760 element = Feld[x][y] = EL_PLAYER_1;
761 InitField(x, y, init_game);
763 element = Feld[x][y] = EL_SOKOBAN_FIELD_EMPTY;
764 InitField(x, y, init_game);
767 case EL_SOKOBAN_FIELD_EMPTY:
768 local_player->sokobanfields_still_needed++;
772 if (x < lev_fieldx-1 && Feld[x+1][y] == EL_ACID)
773 Feld[x][y] = EL_ACID_POOL_TOPLEFT;
774 else if (x > 0 && Feld[x-1][y] == EL_ACID)
775 Feld[x][y] = EL_ACID_POOL_TOPRIGHT;
776 else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPLEFT)
777 Feld[x][y] = EL_ACID_POOL_BOTTOMLEFT;
778 else if (y > 0 && Feld[x][y-1] == EL_ACID)
779 Feld[x][y] = EL_ACID_POOL_BOTTOM;
780 else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPRIGHT)
781 Feld[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
789 case EL_SPACESHIP_RIGHT:
790 case EL_SPACESHIP_UP:
791 case EL_SPACESHIP_LEFT:
792 case EL_SPACESHIP_DOWN:
794 case EL_BD_BUTTERFLY_RIGHT:
795 case EL_BD_BUTTERFLY_UP:
796 case EL_BD_BUTTERFLY_LEFT:
797 case EL_BD_BUTTERFLY_DOWN:
798 case EL_BD_BUTTERFLY:
799 case EL_BD_FIREFLY_RIGHT:
800 case EL_BD_FIREFLY_UP:
801 case EL_BD_FIREFLY_LEFT:
802 case EL_BD_FIREFLY_DOWN:
804 case EL_PACMAN_RIGHT:
828 if (y == lev_fieldy - 1)
830 Feld[x][y] = EL_AMOEBA_GROWING;
831 Store[x][y] = EL_AMOEBA_WET;
835 case EL_DYNAMITE_ACTIVE:
836 case EL_SP_DISK_RED_ACTIVE:
837 case EL_DYNABOMB_PLAYER_1_ACTIVE:
838 case EL_DYNABOMB_PLAYER_2_ACTIVE:
839 case EL_DYNABOMB_PLAYER_3_ACTIVE:
840 case EL_DYNABOMB_PLAYER_4_ACTIVE:
845 local_player->lights_still_needed++;
849 local_player->friends_still_needed++;
854 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
859 Feld[x][y] = EL_EMPTY;
864 case EL_EM_KEY_1_FILE:
865 Feld[x][y] = EL_EM_KEY_1;
867 case EL_EM_KEY_2_FILE:
868 Feld[x][y] = EL_EM_KEY_2;
870 case EL_EM_KEY_3_FILE:
871 Feld[x][y] = EL_EM_KEY_3;
873 case EL_EM_KEY_4_FILE:
874 Feld[x][y] = EL_EM_KEY_4;
878 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
879 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
880 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
881 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
882 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
883 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
884 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
885 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
886 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
887 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
888 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
889 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
892 int belt_nr = getBeltNrFromBeltSwitchElement(Feld[x][y]);
893 int belt_dir = getBeltDirFromBeltSwitchElement(Feld[x][y]);
894 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Feld[x][y]);
896 if (game.belt_dir_nr[belt_nr] == 3) /* initial value */
898 game.belt_dir[belt_nr] = belt_dir;
899 game.belt_dir_nr[belt_nr] = belt_dir_nr;
901 else /* more than one switch -- set it like the first switch */
903 Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
908 case EL_SWITCHGATE_SWITCH_DOWN: /* always start with same switch pos */
910 Feld[x][y] = EL_SWITCHGATE_SWITCH_UP;
913 case EL_LIGHT_SWITCH_ACTIVE:
915 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
919 if (IS_CUSTOM_ELEMENT(element) && CAN_MOVE(element))
921 else if (IS_GROUP_ELEMENT(element))
923 struct ElementGroupInfo *group = element_info[element].group;
924 int last_anim_random_frame = gfx.anim_random_frame;
927 if (group->choice_mode == ANIM_RANDOM)
928 gfx.anim_random_frame = RND(group->num_elements_resolved);
930 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
931 group->choice_mode, 0,
934 if (group->choice_mode == ANIM_RANDOM)
935 gfx.anim_random_frame = last_anim_random_frame;
939 Feld[x][y] = group->element_resolved[element_pos];
941 InitField(x, y, init_game);
947 static inline void InitField_WithBug1(int x, int y, boolean init_game)
949 InitField(x, y, init_game);
951 /* not needed to call InitMovDir() -- already done by InitField()! */
952 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
953 CAN_MOVE(Feld[x][y]))
957 static inline void InitField_WithBug2(int x, int y, boolean init_game)
959 int old_element = Feld[x][y];
961 InitField(x, y, init_game);
963 /* not needed to call InitMovDir() -- already done by InitField()! */
964 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
965 CAN_MOVE(old_element) &&
966 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
969 /* this case is in fact a combination of not less than three bugs:
970 first, it calls InitMovDir() for elements that can move, although this is
971 already done by InitField(); then, it checks the element that was at this
972 field _before_ the call to InitField() (which can change it)
977 inline void DrawGameValue_Emeralds(int value)
979 DrawText(DX_EMERALDS, DY_EMERALDS, int2str(value, 3), FONT_TEXT_2);
982 inline void DrawGameValue_Dynamite(int value)
984 DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(value, 3), FONT_TEXT_2);
987 inline void DrawGameValue_Keys(struct PlayerInfo *player)
991 for (i = 0; i < MAX_KEYS; i++)
993 DrawMiniGraphicExt(drawto, DX_KEYS + i * MINI_TILEX, DY_KEYS,
994 el2edimg(EL_KEY_1 + i));
997 inline void DrawGameValue_Score(int value)
999 DrawText(DX_SCORE, DY_SCORE, int2str(value, 5), FONT_TEXT_2);
1002 inline void DrawGameValue_Time(int value)
1005 DrawText(DX_TIME1, DY_TIME, int2str(value, 3), FONT_TEXT_2);
1007 DrawText(DX_TIME2, DY_TIME, int2str(value, 4), FONT_LEVEL_NUMBER);
1010 inline void DrawGameValue_Level(int value)
1013 DrawText(DX_LEVEL, DY_LEVEL, int2str(value, 2), FONT_TEXT_2);
1016 /* misuse area for displaying emeralds to draw bigger level number */
1017 DrawTextExt(drawto, DX_EMERALDS, DY_EMERALDS,
1018 int2str(value, 3), FONT_LEVEL_NUMBER, BLIT_OPAQUE);
1020 /* now copy it to the area for displaying level number */
1021 BlitBitmap(drawto, drawto,
1022 DX_EMERALDS, DY_EMERALDS + 1,
1023 getFontWidth(FONT_LEVEL_NUMBER) * 3,
1024 getFontHeight(FONT_LEVEL_NUMBER) - 1,
1025 DX_LEVEL - 1, DY_LEVEL + 1);
1027 /* restore the area for displaying emeralds */
1028 DrawGameValue_Emeralds(local_player->gems_still_needed);
1030 /* yes, this is all really ugly :-) */
1034 void DrawGameDoorValues()
1038 DrawGameValue_Level(level_nr);
1040 for (i = 0; i < MAX_PLAYERS; i++)
1041 DrawGameValue_Keys(&stored_player[i]);
1043 DrawGameValue_Emeralds(local_player->gems_still_needed);
1044 DrawGameValue_Dynamite(local_player->inventory_size);
1045 DrawGameValue_Score(local_player->score);
1046 DrawGameValue_Time(TimeLeft);
1049 static void resolve_group_element(int group_element, int recursion_depth)
1051 static int group_nr;
1052 static struct ElementGroupInfo *group;
1053 struct ElementGroupInfo *actual_group = element_info[group_element].group;
1056 if (recursion_depth > NUM_GROUP_ELEMENTS) /* recursion too deep */
1058 Error(ERR_WARN, "recursion too deep when resolving group element %d",
1059 group_element - EL_GROUP_START + 1);
1061 /* replace element which caused too deep recursion by question mark */
1062 group->element_resolved[group->num_elements_resolved++] = EL_UNKNOWN;
1067 if (recursion_depth == 0) /* initialization */
1069 group = element_info[group_element].group;
1070 group_nr = group_element - EL_GROUP_START;
1072 group->num_elements_resolved = 0;
1073 group->choice_pos = 0;
1076 for (i = 0; i < actual_group->num_elements; i++)
1078 int element = actual_group->element[i];
1080 if (group->num_elements_resolved == NUM_FILE_ELEMENTS)
1083 if (IS_GROUP_ELEMENT(element))
1084 resolve_group_element(element, recursion_depth + 1);
1087 group->element_resolved[group->num_elements_resolved++] = element;
1088 element_info[element].in_group[group_nr] = TRUE;
1093 if (recursion_depth == 0 && group_element <= EL_GROUP_4)
1095 printf("::: group %d: %d resolved elements\n",
1096 group_element - EL_GROUP_START, group->num_elements_resolved);
1097 for (i = 0; i < group->num_elements_resolved; i++)
1098 printf("::: - %d ['%s']\n", group->element_resolved[i],
1099 element_info[group->element_resolved[i]].token_name);
1106 =============================================================================
1108 -----------------------------------------------------------------------------
1109 initialize game engine due to level / tape version number
1110 =============================================================================
1113 static void InitGameEngine()
1117 /* set game engine from tape file when re-playing, else from level file */
1118 game.engine_version = (tape.playing ? tape.engine_version :
1119 level.game_version);
1121 /* dynamically adjust element properties according to game engine version */
1122 InitElementPropertiesEngine(game.engine_version);
1125 printf("level %d: level version == %06d\n", level_nr, level.game_version);
1126 printf(" tape version == %06d [%s] [file: %06d]\n",
1127 tape.engine_version, (tape.playing ? "PLAYING" : "RECORDING"),
1129 printf(" => game.engine_version == %06d\n", game.engine_version);
1132 /* ---------- recursively resolve group elements ------------------------- */
1134 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1135 for (j = 0; j < NUM_GROUP_ELEMENTS; j++)
1136 element_info[i].in_group[j] = FALSE;
1138 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
1139 resolve_group_element(EL_GROUP_START + i, 0);
1141 /* ---------- initialize player's initial move delay --------------------- */
1143 /* dynamically adjust player properties according to game engine version */
1144 game.initial_move_delay =
1145 (game.engine_version <= VERSION_IDENT(2,0,1,0) ? INITIAL_MOVE_DELAY_ON :
1146 INITIAL_MOVE_DELAY_OFF);
1148 /* dynamically adjust player properties according to level information */
1149 game.initial_move_delay_value =
1150 (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
1152 /* ---------- initialize player's initial push delay --------------------- */
1154 /* dynamically adjust player properties according to game engine version */
1155 game.initial_push_delay_value =
1156 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
1158 /* ---------- initialize changing elements ------------------------------- */
1160 /* initialize changing elements information */
1161 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1163 struct ElementInfo *ei = &element_info[i];
1165 /* this pointer might have been changed in the level editor */
1166 ei->change = &ei->change_page[0];
1168 if (!IS_CUSTOM_ELEMENT(i))
1170 ei->change->target_element = EL_EMPTY_SPACE;
1171 ei->change->delay_fixed = 0;
1172 ei->change->delay_random = 0;
1173 ei->change->delay_frames = 1;
1176 ei->change_events = CE_BITMASK_DEFAULT;
1177 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
1179 ei->event_page_nr[j] = 0;
1180 ei->event_page[j] = &ei->change_page[0];
1184 /* add changing elements from pre-defined list */
1185 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
1187 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
1188 struct ElementInfo *ei = &element_info[ch_delay->element];
1190 ei->change->target_element = ch_delay->target_element;
1191 ei->change->delay_fixed = ch_delay->change_delay;
1193 ei->change->pre_change_function = ch_delay->pre_change_function;
1194 ei->change->change_function = ch_delay->change_function;
1195 ei->change->post_change_function = ch_delay->post_change_function;
1197 ei->change_events |= CH_EVENT_BIT(CE_DELAY);
1201 /* add change events from custom element configuration */
1202 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1204 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
1206 for (j = 0; j < ei->num_change_pages; j++)
1208 if (!ei->change_page[j].can_change)
1211 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
1213 /* only add event page for the first page found with this event */
1214 if (ei->change_page[j].events & CH_EVENT_BIT(k) &&
1215 !(ei->change_events & CH_EVENT_BIT(k)))
1217 ei->change_events |= CH_EVENT_BIT(k);
1218 ei->event_page_nr[k] = j;
1219 ei->event_page[k] = &ei->change_page[j];
1227 /* add change events from custom element configuration */
1228 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1230 int element = EL_CUSTOM_START + i;
1232 /* only add custom elements that change after fixed/random frame delay */
1233 if (CAN_CHANGE(element) && HAS_CHANGE_EVENT(element, CE_DELAY))
1234 element_info[element].change_events |= CH_EVENT_BIT(CE_DELAY);
1238 /* ---------- initialize trigger events ---------------------------------- */
1240 /* initialize trigger events information */
1241 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1242 trigger_events[i] = EP_BITMASK_DEFAULT;
1245 /* add trigger events from element change event properties */
1246 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1248 struct ElementInfo *ei = &element_info[i];
1250 for (j = 0; j < ei->num_change_pages; j++)
1252 if (!ei->change_page[j].can_change)
1255 if (ei->change_page[j].events & CH_EVENT_BIT(CE_BY_OTHER_ACTION))
1257 int trigger_element = ei->change_page[j].trigger_element;
1259 if (IS_GROUP_ELEMENT(trigger_element))
1261 struct ElementGroupInfo *group = element_info[trigger_element].group;
1263 for (k = 0; k < group->num_elements_resolved; k++)
1264 trigger_events[group->element_resolved[k]]
1265 |= ei->change_page[j].events;
1268 trigger_events[trigger_element] |= ei->change_page[j].events;
1273 /* add trigger events from element change event properties */
1274 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1275 if (HAS_CHANGE_EVENT(i, CE_BY_OTHER_ACTION))
1276 trigger_events[element_info[i].change->trigger_element] |=
1277 element_info[i].change->events;
1280 /* ---------- initialize push delay -------------------------------------- */
1282 /* initialize push delay values to default */
1283 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1285 if (!IS_CUSTOM_ELEMENT(i))
1287 element_info[i].push_delay_fixed = game.default_push_delay_fixed;
1288 element_info[i].push_delay_random = game.default_push_delay_random;
1292 /* set push delay value for certain elements from pre-defined list */
1293 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
1295 int e = push_delay_list[i].element;
1297 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
1298 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
1301 /* set push delay value for Supaplex elements for newer engine versions */
1302 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
1304 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1306 if (IS_SP_ELEMENT(i))
1308 element_info[i].push_delay_fixed = 6; /* just enough to escape ... */
1309 element_info[i].push_delay_random = 0; /* ... from falling zonk */
1314 /* ---------- initialize move stepsize ----------------------------------- */
1316 /* initialize move stepsize values to default */
1317 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1318 if (!IS_CUSTOM_ELEMENT(i))
1319 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
1321 /* set move stepsize value for certain elements from pre-defined list */
1322 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
1324 int e = move_stepsize_list[i].element;
1326 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
1329 /* ---------- initialize move dig/leave ---------------------------------- */
1331 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1333 element_info[i].can_leave_element = FALSE;
1334 element_info[i].can_leave_element_last = FALSE;
1337 /* ---------- initialize gem count --------------------------------------- */
1339 /* initialize gem count values for each element */
1340 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1341 if (!IS_CUSTOM_ELEMENT(i))
1342 element_info[i].collect_count = 0;
1344 /* add gem count values for all elements from pre-defined list */
1345 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
1346 element_info[collect_count_list[i].element].collect_count =
1347 collect_count_list[i].count;
1349 /* ---------- initialize access direction -------------------------------- */
1351 /* initialize access direction values to default */
1352 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1353 if (!IS_CUSTOM_ELEMENT(i))
1354 element_info[i].access_direction = MV_ALL_DIRECTIONS;
1356 /* set access direction value for certain elements from pre-defined list */
1357 for (i = 0; tube_access[i].element != EL_UNDEFINED; i++)
1358 element_info[tube_access[i].element].access_direction =
1359 tube_access[i].direction;
1364 =============================================================================
1366 -----------------------------------------------------------------------------
1367 initialize and start new game
1368 =============================================================================
1373 boolean emulate_bd = TRUE; /* unless non-BOULDERDASH elements found */
1374 boolean emulate_sb = TRUE; /* unless non-SOKOBAN elements found */
1375 boolean emulate_sp = TRUE; /* unless non-SUPAPLEX elements found */
1382 #if USE_NEW_AMOEBA_CODE
1383 printf("Using new amoeba code.\n");
1385 printf("Using old amoeba code.\n");
1390 /* don't play tapes over network */
1391 network_playing = (options.network && !tape.playing);
1393 for (i = 0; i < MAX_PLAYERS; i++)
1395 struct PlayerInfo *player = &stored_player[i];
1397 player->index_nr = i;
1398 player->index_bit = (1 << i);
1399 player->element_nr = EL_PLAYER_1 + i;
1401 player->present = FALSE;
1402 player->active = FALSE;
1405 player->effective_action = 0;
1406 player->programmed_action = 0;
1409 player->gems_still_needed = level.gems_needed;
1410 player->sokobanfields_still_needed = 0;
1411 player->lights_still_needed = 0;
1412 player->friends_still_needed = 0;
1414 for (j = 0; j < MAX_KEYS; j++)
1415 player->key[j] = FALSE;
1417 player->dynabomb_count = 0;
1418 player->dynabomb_size = 1;
1419 player->dynabombs_left = 0;
1420 player->dynabomb_xl = FALSE;
1422 player->MovDir = MV_NO_MOVING;
1425 player->GfxDir = MV_NO_MOVING;
1426 player->GfxAction = ACTION_DEFAULT;
1428 player->StepFrame = 0;
1430 player->use_murphy_graphic = FALSE;
1432 player->block_last_field = FALSE;
1433 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
1435 player->actual_frame_counter = 0;
1437 player->step_counter = 0;
1439 player->last_move_dir = MV_NO_MOVING;
1441 player->is_waiting = FALSE;
1442 player->is_moving = FALSE;
1443 player->is_digging = FALSE;
1444 player->is_snapping = FALSE;
1445 player->is_collecting = FALSE;
1446 player->is_pushing = FALSE;
1447 player->is_switching = FALSE;
1448 player->is_dropping = FALSE;
1450 player->is_bored = FALSE;
1451 player->is_sleeping = FALSE;
1453 player->frame_counter_bored = -1;
1454 player->frame_counter_sleeping = -1;
1456 player->anim_delay_counter = 0;
1457 player->post_delay_counter = 0;
1459 player->action_waiting = ACTION_DEFAULT;
1460 player->last_action_waiting = ACTION_DEFAULT;
1461 player->special_action_bored = ACTION_DEFAULT;
1462 player->special_action_sleeping = ACTION_DEFAULT;
1464 player->num_special_action_bored = 0;
1465 player->num_special_action_sleeping = 0;
1467 /* determine number of special actions for bored and sleeping animation */
1468 for (j = ACTION_BORING_1; j <= ACTION_BORING_LAST; j++)
1470 boolean found = FALSE;
1472 for (k = 0; k < NUM_DIRECTIONS; k++)
1473 if (el_act_dir2img(player->element_nr, j, k) !=
1474 el_act_dir2img(player->element_nr, ACTION_DEFAULT, k))
1478 player->num_special_action_bored++;
1482 for (j = ACTION_SLEEPING_1; j <= ACTION_SLEEPING_LAST; j++)
1484 boolean found = FALSE;
1486 for (k = 0; k < NUM_DIRECTIONS; k++)
1487 if (el_act_dir2img(player->element_nr, j, k) !=
1488 el_act_dir2img(player->element_nr, ACTION_DEFAULT, k))
1492 player->num_special_action_sleeping++;
1497 player->switch_x = -1;
1498 player->switch_y = -1;
1500 player->show_envelope = 0;
1502 player->move_delay = game.initial_move_delay;
1503 player->move_delay_value = game.initial_move_delay_value;
1505 player->move_delay_reset_counter = 0;
1507 player->push_delay = 0;
1508 player->push_delay_value = game.initial_push_delay_value;
1510 player->drop_delay = 0;
1512 player->last_jx = player->last_jy = 0;
1513 player->jx = player->jy = 0;
1515 player->shield_normal_time_left = 0;
1516 player->shield_deadly_time_left = 0;
1518 player->inventory_infinite_element = EL_UNDEFINED;
1519 player->inventory_size = 0;
1521 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
1522 SnapField(player, 0, 0);
1524 player->LevelSolved = FALSE;
1525 player->GameOver = FALSE;
1528 network_player_action_received = FALSE;
1530 #if defined(PLATFORM_UNIX)
1531 /* initial null action */
1532 if (network_playing)
1533 SendToServer_MovePlayer(MV_NO_MOVING);
1541 TimeLeft = level.time;
1544 ScreenMovDir = MV_NO_MOVING;
1548 ScrollStepSize = 0; /* will be correctly initialized by ScrollScreen() */
1550 AllPlayersGone = FALSE;
1552 game.yamyam_content_nr = 0;
1553 game.magic_wall_active = FALSE;
1554 game.magic_wall_time_left = 0;
1555 game.light_time_left = 0;
1556 game.timegate_time_left = 0;
1557 game.switchgate_pos = 0;
1558 game.balloon_dir = MV_NO_MOVING;
1559 game.gravity = level.initial_gravity;
1560 game.explosions_delayed = TRUE;
1562 game.envelope_active = FALSE;
1564 for (i = 0; i < NUM_BELTS; i++)
1566 game.belt_dir[i] = MV_NO_MOVING;
1567 game.belt_dir_nr[i] = 3; /* not moving, next moving left */
1570 for (i = 0; i < MAX_NUM_AMOEBA; i++)
1571 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
1573 for (x = 0; x < lev_fieldx; x++)
1575 for (y = 0; y < lev_fieldy; y++)
1577 Feld[x][y] = level.field[x][y];
1578 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
1579 ChangeDelay[x][y] = 0;
1580 ChangePage[x][y] = -1;
1581 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
1583 WasJustMoving[x][y] = 0;
1584 WasJustFalling[x][y] = 0;
1586 Pushed[x][y] = FALSE;
1588 Changed[x][y] = CE_BITMASK_DEFAULT;
1589 ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
1591 ExplodePhase[x][y] = 0;
1592 ExplodeDelay[x][y] = 0;
1593 ExplodeField[x][y] = EX_NO_EXPLOSION;
1595 RunnerVisit[x][y] = 0;
1596 PlayerVisit[x][y] = 0;
1599 GfxRandom[x][y] = INIT_GFX_RANDOM();
1600 GfxElement[x][y] = EL_UNDEFINED;
1601 GfxAction[x][y] = ACTION_DEFAULT;
1602 GfxDir[x][y] = MV_NO_MOVING;
1606 for (y = 0; y < lev_fieldy; y++)
1608 for (x = 0; x < lev_fieldx; x++)
1610 if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y]))
1612 if (emulate_sb && !IS_SB_ELEMENT(Feld[x][y]))
1614 if (emulate_sp && !IS_SP_ELEMENT(Feld[x][y]))
1617 InitField(x, y, TRUE);
1623 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
1624 emulate_sb ? EMU_SOKOBAN :
1625 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
1627 /* initialize explosion and ignition delay */
1628 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1630 if (!IS_CUSTOM_ELEMENT(i))
1633 int delay = ((IS_SP_ELEMENT(i) &&
1634 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
1635 game.emulation == EMU_SUPAPLEX ? 3 : 2);
1636 int last_phase = (num_phase + 1) * delay;
1637 int half_phase = (num_phase / 2) * delay;
1639 element_info[i].explosion_delay = last_phase - 1;
1640 element_info[i].ignition_delay = half_phase;
1643 if (i == EL_BLACK_ORB)
1644 element_info[i].ignition_delay = 0;
1646 if (i == EL_BLACK_ORB)
1647 element_info[i].ignition_delay = 1;
1652 if (element_info[i].explosion_delay < 1) /* !!! check again !!! */
1653 element_info[i].explosion_delay = 1;
1655 if (element_info[i].ignition_delay < 1) /* !!! check again !!! */
1656 element_info[i].ignition_delay = 1;
1660 /* correct non-moving belts to start moving left */
1661 for (i = 0; i < NUM_BELTS; i++)
1662 if (game.belt_dir[i] == MV_NO_MOVING)
1663 game.belt_dir_nr[i] = 3; /* not moving, next moving left */
1665 /* check if any connected player was not found in playfield */
1666 for (i = 0; i < MAX_PLAYERS; i++)
1668 struct PlayerInfo *player = &stored_player[i];
1670 if (player->connected && !player->present)
1672 for (j = 0; j < MAX_PLAYERS; j++)
1674 struct PlayerInfo *some_player = &stored_player[j];
1675 int jx = some_player->jx, jy = some_player->jy;
1677 /* assign first free player found that is present in the playfield */
1678 if (some_player->present && !some_player->connected)
1680 player->present = TRUE;
1681 player->active = TRUE;
1683 some_player->present = FALSE;
1684 some_player->active = FALSE;
1687 player->element_nr = some_player->element_nr;
1690 StorePlayer[jx][jy] = player->element_nr;
1691 player->jx = player->last_jx = jx;
1692 player->jy = player->last_jy = jy;
1702 /* when playing a tape, eliminate all players which do not participate */
1704 for (i = 0; i < MAX_PLAYERS; i++)
1706 if (stored_player[i].active && !tape.player_participates[i])
1708 struct PlayerInfo *player = &stored_player[i];
1709 int jx = player->jx, jy = player->jy;
1711 player->active = FALSE;
1712 StorePlayer[jx][jy] = 0;
1713 Feld[jx][jy] = EL_EMPTY;
1717 else if (!options.network && !setup.team_mode) /* && !tape.playing */
1719 /* when in single player mode, eliminate all but the first active player */
1721 for (i = 0; i < MAX_PLAYERS; i++)
1723 if (stored_player[i].active)
1725 for (j = i + 1; j < MAX_PLAYERS; j++)
1727 if (stored_player[j].active)
1729 struct PlayerInfo *player = &stored_player[j];
1730 int jx = player->jx, jy = player->jy;
1732 player->active = FALSE;
1733 player->present = FALSE;
1735 StorePlayer[jx][jy] = 0;
1736 Feld[jx][jy] = EL_EMPTY;
1743 /* when recording the game, store which players take part in the game */
1746 for (i = 0; i < MAX_PLAYERS; i++)
1747 if (stored_player[i].active)
1748 tape.player_participates[i] = TRUE;
1753 for (i = 0; i < MAX_PLAYERS; i++)
1755 struct PlayerInfo *player = &stored_player[i];
1757 printf("Player %d: present == %d, connected == %d, active == %d.\n",
1762 if (local_player == player)
1763 printf("Player %d is local player.\n", i+1);
1767 if (BorderElement == EL_EMPTY)
1770 SBX_Right = lev_fieldx - SCR_FIELDX;
1772 SBY_Lower = lev_fieldy - SCR_FIELDY;
1777 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
1779 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
1782 if (lev_fieldx + (SBX_Left == -1 ? 2 : 0) <= SCR_FIELDX)
1783 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
1785 if (lev_fieldy + (SBY_Upper == -1 ? 2 : 0) <= SCR_FIELDY)
1786 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
1788 /* if local player not found, look for custom element that might create
1789 the player (make some assumptions about the right custom element) */
1790 if (!local_player->present)
1792 int start_x = 0, start_y = 0;
1793 int found_rating = 0;
1794 int found_element = EL_UNDEFINED;
1796 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
1798 int element = Feld[x][y];
1803 if (!IS_CUSTOM_ELEMENT(element))
1806 if (CAN_CHANGE(element))
1808 for (i = 0; i < element_info[element].num_change_pages; i++)
1810 content = element_info[element].change_page[i].target_element;
1811 is_player = ELEM_IS_PLAYER(content);
1813 if (is_player && (found_rating < 3 || element < found_element))
1819 found_element = element;
1824 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
1826 content = element_info[element].content[xx][yy];
1827 is_player = ELEM_IS_PLAYER(content);
1829 if (is_player && (found_rating < 2 || element < found_element))
1831 start_x = x + xx - 1;
1832 start_y = y + yy - 1;
1835 found_element = element;
1838 if (!CAN_CHANGE(element))
1841 for (i = 0; i < element_info[element].num_change_pages; i++)
1843 content = element_info[element].change_page[i].content[xx][yy];
1844 is_player = ELEM_IS_PLAYER(content);
1846 if (is_player && (found_rating < 1 || element < found_element))
1848 start_x = x + xx - 1;
1849 start_y = y + yy - 1;
1852 found_element = element;
1858 scroll_x = (start_x < SBX_Left + MIDPOSX ? SBX_Left :
1859 start_x > SBX_Right + MIDPOSX ? SBX_Right :
1862 scroll_y = (start_y < SBY_Upper + MIDPOSY ? SBY_Upper :
1863 start_y > SBY_Lower + MIDPOSY ? SBY_Lower :
1869 scroll_x = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
1870 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
1871 local_player->jx - MIDPOSX);
1873 scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
1874 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
1875 local_player->jy - MIDPOSY);
1877 scroll_x = SBX_Left;
1878 scroll_y = SBY_Upper;
1879 if (local_player->jx >= SBX_Left + MIDPOSX)
1880 scroll_x = (local_player->jx <= SBX_Right + MIDPOSX ?
1881 local_player->jx - MIDPOSX :
1883 if (local_player->jy >= SBY_Upper + MIDPOSY)
1884 scroll_y = (local_player->jy <= SBY_Lower + MIDPOSY ?
1885 local_player->jy - MIDPOSY :
1890 CloseDoor(DOOR_CLOSE_1);
1895 /* after drawing the level, correct some elements */
1896 if (game.timegate_time_left == 0)
1897 CloseAllOpenTimegates();
1899 if (setup.soft_scrolling)
1900 BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
1902 redraw_mask |= REDRAW_FROM_BACKBUFFER;
1905 /* copy default game door content to main double buffer */
1906 BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
1907 DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
1909 DrawGameDoorValues();
1913 game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
1914 game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
1915 game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
1919 /* copy actual game door content to door double buffer for OpenDoor() */
1920 BlitBitmap(drawto, bitmap_db_door,
1921 DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
1923 OpenDoor(DOOR_OPEN_ALL);
1925 PlaySoundStereo(SND_GAME_STARTING, SOUND_MIDDLE);
1927 if (setup.sound_music)
1930 KeyboardAutoRepeatOffUnlessAutoplay();
1934 for (i = 0; i < MAX_PLAYERS; i++)
1935 printf("Player %d %sactive.\n",
1936 i + 1, (stored_player[i].active ? "" : "not "));
1940 printf("::: starting game [%d]\n", FrameCounter);
1944 void InitMovDir(int x, int y)
1946 int i, element = Feld[x][y];
1947 static int xy[4][2] =
1954 static int direction[3][4] =
1956 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
1957 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
1958 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
1967 Feld[x][y] = EL_BUG;
1968 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
1971 case EL_SPACESHIP_RIGHT:
1972 case EL_SPACESHIP_UP:
1973 case EL_SPACESHIP_LEFT:
1974 case EL_SPACESHIP_DOWN:
1975 Feld[x][y] = EL_SPACESHIP;
1976 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
1979 case EL_BD_BUTTERFLY_RIGHT:
1980 case EL_BD_BUTTERFLY_UP:
1981 case EL_BD_BUTTERFLY_LEFT:
1982 case EL_BD_BUTTERFLY_DOWN:
1983 Feld[x][y] = EL_BD_BUTTERFLY;
1984 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
1987 case EL_BD_FIREFLY_RIGHT:
1988 case EL_BD_FIREFLY_UP:
1989 case EL_BD_FIREFLY_LEFT:
1990 case EL_BD_FIREFLY_DOWN:
1991 Feld[x][y] = EL_BD_FIREFLY;
1992 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
1995 case EL_PACMAN_RIGHT:
1997 case EL_PACMAN_LEFT:
1998 case EL_PACMAN_DOWN:
1999 Feld[x][y] = EL_PACMAN;
2000 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
2003 case EL_SP_SNIKSNAK:
2004 MovDir[x][y] = MV_UP;
2007 case EL_SP_ELECTRON:
2008 MovDir[x][y] = MV_LEFT;
2015 Feld[x][y] = EL_MOLE;
2016 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
2020 if (IS_CUSTOM_ELEMENT(element))
2022 struct ElementInfo *ei = &element_info[element];
2023 int move_direction_initial = ei->move_direction_initial;
2024 int move_pattern = ei->move_pattern;
2026 if (move_direction_initial == MV_START_PREVIOUS)
2028 if (MovDir[x][y] != MV_NO_MOVING)
2031 move_direction_initial = MV_START_AUTOMATIC;
2034 if (move_direction_initial == MV_START_RANDOM)
2035 MovDir[x][y] = 1 << RND(4);
2036 else if (move_direction_initial & MV_ANY_DIRECTION)
2037 MovDir[x][y] = move_direction_initial;
2038 else if (move_pattern == MV_ALL_DIRECTIONS ||
2039 move_pattern == MV_TURNING_LEFT ||
2040 move_pattern == MV_TURNING_RIGHT ||
2041 move_pattern == MV_TURNING_LEFT_RIGHT ||
2042 move_pattern == MV_TURNING_RIGHT_LEFT ||
2043 move_pattern == MV_TURNING_RANDOM)
2044 MovDir[x][y] = 1 << RND(4);
2045 else if (move_pattern == MV_HORIZONTAL)
2046 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
2047 else if (move_pattern == MV_VERTICAL)
2048 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
2049 else if (move_pattern & MV_ANY_DIRECTION)
2050 MovDir[x][y] = element_info[element].move_pattern;
2051 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
2052 move_pattern == MV_ALONG_RIGHT_SIDE)
2054 for (i = 0; i < NUM_DIRECTIONS; i++)
2056 int x1 = x + xy[i][0];
2057 int y1 = y + xy[i][1];
2059 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
2061 if (move_pattern == MV_ALONG_RIGHT_SIDE)
2062 MovDir[x][y] = direction[0][i];
2064 MovDir[x][y] = direction[1][i];
2073 MovDir[x][y] = 1 << RND(4);
2075 if (element != EL_BUG &&
2076 element != EL_SPACESHIP &&
2077 element != EL_BD_BUTTERFLY &&
2078 element != EL_BD_FIREFLY)
2081 for (i = 0; i < NUM_DIRECTIONS; i++)
2083 int x1 = x + xy[i][0];
2084 int y1 = y + xy[i][1];
2086 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
2088 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
2090 MovDir[x][y] = direction[0][i];
2093 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
2094 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
2096 MovDir[x][y] = direction[1][i];
2105 GfxDir[x][y] = MovDir[x][y];
2108 void InitAmoebaNr(int x, int y)
2111 int group_nr = AmoebeNachbarNr(x, y);
2115 for (i = 1; i < MAX_NUM_AMOEBA; i++)
2117 if (AmoebaCnt[i] == 0)
2125 AmoebaNr[x][y] = group_nr;
2126 AmoebaCnt[group_nr]++;
2127 AmoebaCnt2[group_nr]++;
2133 boolean raise_level = FALSE;
2135 if (local_player->MovPos)
2139 if (tape.auto_play) /* tape might already be stopped here */
2140 tape.auto_play_level_solved = TRUE;
2142 if (tape.playing && tape.auto_play)
2143 tape.auto_play_level_solved = TRUE;
2146 local_player->LevelSolved = FALSE;
2148 PlaySoundStereo(SND_GAME_WINNING, SOUND_MIDDLE);
2152 if (!tape.playing && setup.sound_loops)
2153 PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
2154 SND_CTRL_PLAY_LOOP);
2156 while (TimeLeft > 0)
2158 if (!tape.playing && !setup.sound_loops)
2159 PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
2160 if (TimeLeft > 0 && !(TimeLeft % 10))
2161 RaiseScore(level.score[SC_TIME_BONUS]);
2162 if (TimeLeft > 100 && !(TimeLeft % 10))
2167 DrawGameValue_Time(TimeLeft);
2175 if (!tape.playing && setup.sound_loops)
2176 StopSound(SND_GAME_LEVELTIME_BONUS);
2178 else if (level.time == 0) /* level without time limit */
2180 if (!tape.playing && setup.sound_loops)
2181 PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
2182 SND_CTRL_PLAY_LOOP);
2184 while (TimePlayed < 999)
2186 if (!tape.playing && !setup.sound_loops)
2187 PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
2188 if (TimePlayed < 999 && !(TimePlayed % 10))
2189 RaiseScore(level.score[SC_TIME_BONUS]);
2190 if (TimePlayed < 900 && !(TimePlayed % 10))
2195 DrawGameValue_Time(TimePlayed);
2203 if (!tape.playing && setup.sound_loops)
2204 StopSound(SND_GAME_LEVELTIME_BONUS);
2207 /* close exit door after last player */
2208 if ((Feld[ExitX][ExitY] == EL_EXIT_OPEN ||
2209 Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN) && AllPlayersGone)
2211 int element = Feld[ExitX][ExitY];
2213 Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
2214 EL_SP_EXIT_CLOSING);
2216 PlayLevelSoundElementAction(ExitX, ExitY, element, ACTION_CLOSING);
2219 /* Hero disappears */
2220 DrawLevelField(ExitX, ExitY);
2226 CloseDoor(DOOR_CLOSE_1);
2231 SaveTape(tape.level_nr); /* Ask to save tape */
2234 if (level_nr == leveldir_current->handicap_level)
2236 leveldir_current->handicap_level++;
2237 SaveLevelSetup_SeriesInfo();
2240 if (level_editor_test_game)
2241 local_player->score = -1; /* no highscore when playing from editor */
2242 else if (level_nr < leveldir_current->last_level)
2243 raise_level = TRUE; /* advance to next level */
2245 if ((hi_pos = NewHiScore()) >= 0)
2247 game_status = GAME_MODE_SCORES;
2248 DrawHallOfFame(hi_pos);
2257 game_status = GAME_MODE_MAIN;
2274 LoadScore(level_nr);
2276 if (strcmp(setup.player_name, EMPTY_PLAYER_NAME) == 0 ||
2277 local_player->score < highscore[MAX_SCORE_ENTRIES - 1].Score)
2280 for (k = 0; k < MAX_SCORE_ENTRIES; k++)
2282 if (local_player->score > highscore[k].Score)
2284 /* player has made it to the hall of fame */
2286 if (k < MAX_SCORE_ENTRIES - 1)
2288 int m = MAX_SCORE_ENTRIES - 1;
2291 for (l = k; l < MAX_SCORE_ENTRIES; l++)
2292 if (!strcmp(setup.player_name, highscore[l].Name))
2294 if (m == k) /* player's new highscore overwrites his old one */
2298 for (l = m; l > k; l--)
2300 strcpy(highscore[l].Name, highscore[l - 1].Name);
2301 highscore[l].Score = highscore[l - 1].Score;
2308 strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
2309 highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
2310 highscore[k].Score = local_player->score;
2316 else if (!strncmp(setup.player_name, highscore[k].Name,
2317 MAX_PLAYER_NAME_LEN))
2318 break; /* player already there with a higher score */
2324 SaveScore(level_nr);
2329 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
2331 if (player->GfxAction != action || player->GfxDir != dir)
2334 printf("Player frame reset! (%d => %d, %d => %d)\n",
2335 player->GfxAction, action, player->GfxDir, dir);
2338 player->GfxAction = action;
2339 player->GfxDir = dir;
2341 player->StepFrame = 0;
2345 static void ResetRandomAnimationValue(int x, int y)
2347 GfxRandom[x][y] = INIT_GFX_RANDOM();
2350 static void ResetGfxAnimation(int x, int y)
2353 GfxAction[x][y] = ACTION_DEFAULT;
2354 GfxDir[x][y] = MovDir[x][y];
2357 void InitMovingField(int x, int y, int direction)
2359 int element = Feld[x][y];
2360 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2361 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
2365 if (!WasJustMoving[x][y] || direction != MovDir[x][y])
2366 ResetGfxAnimation(x, y);
2368 MovDir[newx][newy] = MovDir[x][y] = direction;
2369 GfxDir[x][y] = direction;
2371 if (Feld[newx][newy] == EL_EMPTY)
2372 Feld[newx][newy] = EL_BLOCKED;
2374 if (direction == MV_DOWN && CAN_FALL(element))
2375 GfxAction[x][y] = ACTION_FALLING;
2377 GfxAction[x][y] = ACTION_MOVING;
2379 GfxFrame[newx][newy] = GfxFrame[x][y];
2380 GfxRandom[newx][newy] = GfxRandom[x][y];
2381 GfxAction[newx][newy] = GfxAction[x][y];
2382 GfxDir[newx][newy] = GfxDir[x][y];
2385 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
2387 int direction = MovDir[x][y];
2388 int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2389 int newy = y + (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
2395 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
2397 int oldx = x, oldy = y;
2398 int direction = MovDir[x][y];
2400 if (direction == MV_LEFT)
2402 else if (direction == MV_RIGHT)
2404 else if (direction == MV_UP)
2406 else if (direction == MV_DOWN)
2409 *comes_from_x = oldx;
2410 *comes_from_y = oldy;
2413 int MovingOrBlocked2Element(int x, int y)
2415 int element = Feld[x][y];
2417 if (element == EL_BLOCKED)
2421 Blocked2Moving(x, y, &oldx, &oldy);
2422 return Feld[oldx][oldy];
2428 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
2430 /* like MovingOrBlocked2Element(), but if element is moving
2431 and (x,y) is the field the moving element is just leaving,
2432 return EL_BLOCKED instead of the element value */
2433 int element = Feld[x][y];
2435 if (IS_MOVING(x, y))
2437 if (element == EL_BLOCKED)
2441 Blocked2Moving(x, y, &oldx, &oldy);
2442 return Feld[oldx][oldy];
2451 static void RemoveField(int x, int y)
2453 Feld[x][y] = EL_EMPTY;
2460 ChangeDelay[x][y] = 0;
2461 ChangePage[x][y] = -1;
2462 Pushed[x][y] = FALSE;
2464 GfxElement[x][y] = EL_UNDEFINED;
2465 GfxAction[x][y] = ACTION_DEFAULT;
2466 GfxDir[x][y] = MV_NO_MOVING;
2469 void RemoveMovingField(int x, int y)
2471 int oldx = x, oldy = y, newx = x, newy = y;
2472 int element = Feld[x][y];
2473 int next_element = EL_UNDEFINED;
2475 if (element != EL_BLOCKED && !IS_MOVING(x, y))
2478 if (IS_MOVING(x, y))
2480 Moving2Blocked(x, y, &newx, &newy);
2482 if (Feld[newx][newy] != EL_BLOCKED)
2485 if (Feld[newx][newy] != EL_BLOCKED)
2487 /* element is moving, but target field is not free (blocked), but
2488 already occupied by something different (example: acid pool);
2489 in this case, only remove the moving field, but not the target */
2491 RemoveField(oldx, oldy);
2493 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
2495 DrawLevelField(oldx, oldy);
2501 else if (element == EL_BLOCKED)
2503 Blocked2Moving(x, y, &oldx, &oldy);
2504 if (!IS_MOVING(oldx, oldy))
2508 if (element == EL_BLOCKED &&
2509 (Feld[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
2510 Feld[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
2511 Feld[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
2512 Feld[oldx][oldy] == EL_AMOEBA_DROPPING))
2513 next_element = get_next_element(Feld[oldx][oldy]);
2515 RemoveField(oldx, oldy);
2516 RemoveField(newx, newy);
2518 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
2520 if (next_element != EL_UNDEFINED)
2521 Feld[oldx][oldy] = next_element;
2523 DrawLevelField(oldx, oldy);
2524 DrawLevelField(newx, newy);
2527 void DrawDynamite(int x, int y)
2529 int sx = SCREENX(x), sy = SCREENY(y);
2530 int graphic = el2img(Feld[x][y]);
2533 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
2536 if (IS_WALKABLE_INSIDE(Back[x][y]))
2540 DrawGraphic(sx, sy, el2img(Back[x][y]), 0);
2541 else if (Store[x][y])
2542 DrawGraphic(sx, sy, el2img(Store[x][y]), 0);
2544 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
2547 if (Back[x][y] || Store[x][y])
2548 DrawGraphicThruMask(sx, sy, graphic, frame);
2550 DrawGraphic(sx, sy, graphic, frame);
2552 if (game.emulation == EMU_SUPAPLEX)
2553 DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
2554 else if (Store[x][y])
2555 DrawGraphicThruMask(sx, sy, graphic, frame);
2557 DrawGraphic(sx, sy, graphic, frame);
2561 void CheckDynamite(int x, int y)
2563 if (MovDelay[x][y] != 0) /* dynamite is still waiting to explode */
2567 if (MovDelay[x][y] != 0)
2570 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
2577 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
2579 if (Feld[x][y] == EL_DYNAMITE_ACTIVE ||
2580 Feld[x][y] == EL_SP_DISK_RED_ACTIVE)
2581 StopSound(SND_DYNAMITE_ACTIVE);
2583 StopSound(SND_DYNABOMB_ACTIVE);
2589 void RelocatePlayer(int x, int y, int element_raw)
2591 int element = (element_raw == EL_SP_MURPHY ? EL_PLAYER_1 : element_raw);
2592 struct PlayerInfo *player = &stored_player[element - EL_PLAYER_1];
2593 boolean ffwd_delay = (tape.playing && tape.fast_forward);
2594 boolean no_delay = (tape.index_search);
2595 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2596 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
2601 if (player->GameOver) /* do not reanimate dead player */
2605 RemoveField(x, y); /* temporarily remove newly placed player */
2606 DrawLevelField(x, y);
2609 if (player->present)
2611 while (player->MovPos)
2613 ScrollPlayer(player, SCROLL_GO_ON);
2614 ScrollScreen(NULL, SCROLL_GO_ON);
2620 Delay(wait_delay_value);
2623 DrawPlayer(player); /* needed here only to cleanup last field */
2624 DrawLevelField(player->jx, player->jy); /* remove player graphic */
2626 player->is_moving = FALSE;
2630 old_jx = player->jx;
2631 old_jy = player->jy;
2634 Feld[x][y] = element;
2635 InitPlayerField(x, y, element, TRUE);
2638 if (player == local_player)
2642 scroll_x += (local_player->jx - old_jx);
2643 scroll_y += (local_player->jy - old_jy);
2645 /* don't scroll over playfield boundaries */
2646 if (scroll_x < SBX_Left || scroll_x > SBX_Right)
2647 scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
2649 /* don't scroll over playfield boundaries */
2650 if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
2651 scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
2654 scroll_x = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
2655 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
2656 local_player->jx - MIDPOSX);
2658 scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
2659 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
2660 local_player->jy - MIDPOSY);
2663 RedrawPlayfield(TRUE, 0,0,0,0);
2672 if (player == local_player)
2674 int scroll_xx = -999, scroll_yy = -999;
2676 while (scroll_xx != scroll_x || scroll_yy != scroll_y)
2679 int fx = FX, fy = FY;
2681 scroll_xx = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
2682 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
2683 local_player->jx - MIDPOSX);
2685 scroll_yy = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
2686 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
2687 local_player->jy - MIDPOSY);
2689 dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
2690 dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
2695 fx += dx * TILEX / 2;
2696 fy += dy * TILEY / 2;
2698 ScrollLevel(dx, dy);
2701 /* scroll in two steps of half tile size to make things smoother */
2702 BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
2704 Delay(wait_delay_value);
2706 /* scroll second step to align at full tile size */
2708 Delay(wait_delay_value);
2714 void Explode(int ex, int ey, int phase, int mode)
2721 /* !!! eliminate this variable !!! */
2722 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
2727 int last_phase = num_phase * delay;
2728 int half_phase = (num_phase / 2) * delay;
2729 int first_phase_after_start = EX_PHASE_START + 1;
2733 if (game.explosions_delayed)
2735 ExplodeField[ex][ey] = mode;
2739 if (phase == EX_PHASE_START) /* initialize 'Store[][]' field */
2741 int center_element = Feld[ex][ey];
2744 printf("::: start explosion %d,%d [%d]\n", ex, ey, FrameCounter);
2748 /* --- This is only really needed (and now handled) in "Impact()". --- */
2749 /* do not explode moving elements that left the explode field in time */
2750 if (game.engine_version >= VERSION_IDENT(2,2,0,7) &&
2751 center_element == EL_EMPTY && (mode == EX_NORMAL || mode == EX_CENTER))
2755 if (mode == EX_NORMAL || mode == EX_CENTER)
2756 PlayLevelSoundAction(ex, ey, ACTION_EXPLODING);
2758 /* remove things displayed in background while burning dynamite */
2759 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
2762 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
2764 /* put moving element to center field (and let it explode there) */
2765 center_element = MovingOrBlocked2Element(ex, ey);
2766 RemoveMovingField(ex, ey);
2767 Feld[ex][ey] = center_element;
2773 last_phase = element_info[center_element].explosion_delay + 1;
2775 last_phase = element_info[center_element].explosion_delay;
2779 printf("::: %d -> %d\n", center_element, last_phase);
2783 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
2785 int xx = x - ex + 1;
2786 int yy = y - ey + 1;
2790 if (!IN_LEV_FIELD(x, y) || (mode != EX_NORMAL && (x != ex || y != ey)))
2793 if (!IN_LEV_FIELD(x, y) ||
2794 ((mode != EX_NORMAL || center_element == EL_AMOEBA_TO_DIAMOND) &&
2795 (x != ex || y != ey)))
2799 element = Feld[x][y];
2801 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
2803 element = MovingOrBlocked2Element(x, y);
2805 if (!IS_EXPLOSION_PROOF(element))
2806 RemoveMovingField(x, y);
2812 if (IS_EXPLOSION_PROOF(element))
2815 /* indestructible elements can only explode in center (but not flames) */
2816 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey)) ||
2817 element == EL_FLAMES)
2822 if ((IS_INDESTRUCTIBLE(element) &&
2823 (game.engine_version < VERSION_IDENT(2,2,0,0) ||
2824 (!IS_WALKABLE_OVER(element) && !IS_WALKABLE_UNDER(element)))) ||
2825 element == EL_FLAMES)
2829 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
2831 if (IS_ACTIVE_BOMB(element))
2833 /* re-activate things under the bomb like gate or penguin */
2834 Feld[x][y] = (Store[x][y] ? Store[x][y] : EL_EMPTY);
2841 /* save walkable background elements while explosion on same tile */
2843 if (IS_INDESTRUCTIBLE(element))
2844 Back[x][y] = element;
2846 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element))
2847 Back[x][y] = element;
2850 /* ignite explodable elements reached by other explosion */
2851 if (element == EL_EXPLOSION)
2852 element = Store2[x][y];
2855 if (AmoebaNr[x][y] &&
2856 (element == EL_AMOEBA_FULL ||
2857 element == EL_BD_AMOEBA ||
2858 element == EL_AMOEBA_GROWING))
2860 AmoebaCnt[AmoebaNr[x][y]]--;
2861 AmoebaCnt2[AmoebaNr[x][y]]--;
2867 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
2869 switch(StorePlayer[ex][ey])
2872 Store[x][y] = EL_PLAYER_IS_EXPLODING_2;
2875 Store[x][y] = EL_PLAYER_IS_EXPLODING_3;
2878 Store[x][y] = EL_PLAYER_IS_EXPLODING_4;
2882 Store[x][y] = EL_PLAYER_IS_EXPLODING_1;
2887 if (PLAYERINFO(ex, ey)->use_murphy_graphic)
2888 Store[x][y] = EL_EMPTY;
2890 if (game.emulation == EMU_SUPAPLEX)
2891 Store[x][y] = EL_EMPTY;
2894 else if (center_element == EL_MOLE)
2895 Store[x][y] = EL_EMERALD_RED;
2896 else if (center_element == EL_PENGUIN)
2897 Store[x][y] = EL_EMERALD_PURPLE;
2898 else if (center_element == EL_BUG)
2899 Store[x][y] = ((x == ex && y == ey) ? EL_DIAMOND : EL_EMERALD);
2900 else if (center_element == EL_BD_BUTTERFLY)
2901 Store[x][y] = EL_BD_DIAMOND;
2902 else if (center_element == EL_SP_ELECTRON)
2903 Store[x][y] = EL_SP_INFOTRON;
2904 else if (center_element == EL_AMOEBA_TO_DIAMOND)
2905 Store[x][y] = level.amoeba_content;
2906 else if (center_element == EL_YAMYAM)
2907 Store[x][y] = level.yamyam_content[game.yamyam_content_nr][xx][yy];
2908 else if (IS_CUSTOM_ELEMENT(center_element) &&
2909 element_info[center_element].content[xx][yy] != EL_EMPTY)
2910 Store[x][y] = element_info[center_element].content[xx][yy];
2911 else if (element == EL_WALL_EMERALD)
2912 Store[x][y] = EL_EMERALD;
2913 else if (element == EL_WALL_DIAMOND)
2914 Store[x][y] = EL_DIAMOND;
2915 else if (element == EL_WALL_BD_DIAMOND)
2916 Store[x][y] = EL_BD_DIAMOND;
2917 else if (element == EL_WALL_EMERALD_YELLOW)
2918 Store[x][y] = EL_EMERALD_YELLOW;
2919 else if (element == EL_WALL_EMERALD_RED)
2920 Store[x][y] = EL_EMERALD_RED;
2921 else if (element == EL_WALL_EMERALD_PURPLE)
2922 Store[x][y] = EL_EMERALD_PURPLE;
2923 else if (element == EL_WALL_PEARL)
2924 Store[x][y] = EL_PEARL;
2925 else if (element == EL_WALL_CRYSTAL)
2926 Store[x][y] = EL_CRYSTAL;
2927 else if (IS_CUSTOM_ELEMENT(element) && !CAN_EXPLODE(element))
2928 Store[x][y] = element_info[element].content[1][1];
2930 Store[x][y] = EL_EMPTY;
2932 if (x != ex || y != ey ||
2933 center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_BORDER)
2934 Store2[x][y] = element;
2937 if (AmoebaNr[x][y] &&
2938 (element == EL_AMOEBA_FULL ||
2939 element == EL_BD_AMOEBA ||
2940 element == EL_AMOEBA_GROWING))
2942 AmoebaCnt[AmoebaNr[x][y]]--;
2943 AmoebaCnt2[AmoebaNr[x][y]]--;
2949 MovDir[x][y] = MovPos[x][y] = 0;
2950 GfxDir[x][y] = MovDir[x][y];
2955 Feld[x][y] = EL_EXPLOSION;
2957 GfxElement[x][y] = center_element;
2959 GfxElement[x][y] = EL_UNDEFINED;
2962 ExplodePhase[x][y] = 1;
2964 ExplodeDelay[x][y] = last_phase;
2969 GfxFrame[x][y] = 0; /* animation does not start until next frame */
2971 GfxFrame[x][y] = -1; /* animation does not start until next frame */
2978 if (center_element == EL_YAMYAM)
2979 game.yamyam_content_nr =
2980 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
2993 GfxFrame[x][y] = 0; /* restart explosion animation */
2997 printf(":X: phase == %d [%d]\n", phase, GfxFrame[x][y]);
3001 last_phase = ExplodeDelay[x][y];
3004 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
3008 /* activate this even in non-DEBUG version until cause for crash in
3009 getGraphicAnimationFrame() (see below) is found and eliminated */
3013 if (GfxElement[x][y] == EL_UNDEFINED)
3016 printf("Explode(): x = %d, y = %d: GfxElement == EL_UNDEFINED\n", x, y);
3017 printf("Explode(): This should never happen!\n");
3020 GfxElement[x][y] = EL_EMPTY;
3026 border_element = Store2[x][y];
3027 if (IS_PLAYER(x, y))
3028 border_element = StorePlayer[x][y];
3031 printf("::: phase == %d\n", phase);
3034 if (phase == element_info[border_element].ignition_delay ||
3035 phase == last_phase)
3037 boolean border_explosion = FALSE;
3040 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present)
3042 if (IS_PLAYER(x, y))
3045 KillHeroUnlessExplosionProtected(x, y);
3046 border_explosion = TRUE;
3049 if (phase == last_phase)
3050 printf("::: IS_PLAYER\n");
3053 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
3055 Feld[x][y] = Store2[x][y];
3058 border_explosion = TRUE;
3061 if (phase == last_phase)
3062 printf("::: CAN_EXPLODE_BY_EXPLOSION\n");
3065 else if (border_element == EL_AMOEBA_TO_DIAMOND)
3067 AmoebeUmwandeln(x, y);
3069 border_explosion = TRUE;
3072 if (phase == last_phase)
3073 printf("::: EL_AMOEBA_TO_DIAMOND [%d, %d] [%d]\n",
3074 element_info[border_element].explosion_delay,
3075 element_info[border_element].ignition_delay,
3081 /* if an element just explodes due to another explosion (chain-reaction),
3082 do not immediately end the new explosion when it was the last frame of
3083 the explosion (as it would be done in the following "if"-statement!) */
3084 if (border_explosion && phase == last_phase)
3091 if (phase == first_phase_after_start)
3093 int element = Store2[x][y];
3095 if (element == EL_BLACK_ORB)
3097 Feld[x][y] = Store2[x][y];
3102 else if (phase == half_phase)
3104 int element = Store2[x][y];
3106 if (IS_PLAYER(x, y))
3107 KillHeroUnlessExplosionProtected(x, y);
3108 else if (CAN_EXPLODE_BY_EXPLOSION(element))
3110 Feld[x][y] = Store2[x][y];
3114 else if (element == EL_AMOEBA_TO_DIAMOND)
3115 AmoebeUmwandeln(x, y);
3119 if (phase == last_phase)
3124 printf("::: explosion %d,%d done [%d]\n", x, y, FrameCounter);
3127 element = Feld[x][y] = Store[x][y];
3128 Store[x][y] = Store2[x][y] = 0;
3129 GfxElement[x][y] = EL_UNDEFINED;
3131 /* player can escape from explosions and might therefore be still alive */
3132 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
3133 element <= EL_PLAYER_IS_EXPLODING_4)
3134 Feld[x][y] = (stored_player[element - EL_PLAYER_IS_EXPLODING_1].active ?
3136 element == EL_PLAYER_IS_EXPLODING_1 ? EL_EMERALD_YELLOW :
3137 element == EL_PLAYER_IS_EXPLODING_2 ? EL_EMERALD_RED :
3138 element == EL_PLAYER_IS_EXPLODING_3 ? EL_EMERALD :
3141 /* restore probably existing indestructible background element */
3142 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
3143 element = Feld[x][y] = Back[x][y];
3146 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
3147 GfxDir[x][y] = MV_NO_MOVING;
3148 ChangeDelay[x][y] = 0;
3149 ChangePage[x][y] = -1;
3152 InitField_WithBug2(x, y, FALSE);
3154 InitField(x, y, FALSE);
3156 /* !!! not needed !!! */
3158 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3159 CAN_MOVE(Feld[x][y]) && Feld[x][y] != EL_MOLE)
3162 if (CAN_MOVE(element))
3167 DrawLevelField(x, y);
3169 TestIfElementTouchesCustomElement(x, y);
3171 if (GFX_CRUMBLED(element))
3172 DrawLevelFieldCrumbledSandNeighbours(x, y);
3174 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
3175 StorePlayer[x][y] = 0;
3177 if (ELEM_IS_PLAYER(element))
3178 RelocatePlayer(x, y, element);
3181 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3183 else if (phase >= delay && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3187 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
3189 int stored = Store[x][y];
3190 int graphic = (game.emulation != EMU_SUPAPLEX ? IMG_EXPLOSION :
3191 stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
3195 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
3197 int frame = getGraphicAnimationFrame(graphic, phase - delay);
3201 printf("::: phase == %d [%d]\n", phase, GfxFrame[x][y]);
3205 printf("::: %d / %d [%d - %d]\n",
3206 GfxFrame[x][y], phase - delay, phase, delay);
3210 printf("::: %d ['%s'] -> %d\n", GfxElement[x][y],
3211 element_info[GfxElement[x][y]].token_name,
3216 DrawLevelFieldCrumbledSand(x, y);
3218 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
3220 DrawLevelElement(x, y, Back[x][y]);
3221 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
3223 else if (IS_WALKABLE_UNDER(Back[x][y]))
3225 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
3226 DrawLevelElementThruMask(x, y, Back[x][y]);
3228 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
3229 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
3233 void DynaExplode(int ex, int ey)
3236 int dynabomb_element = Feld[ex][ey];
3237 int dynabomb_size = 1;
3238 boolean dynabomb_xl = FALSE;
3239 struct PlayerInfo *player;
3240 static int xy[4][2] =
3248 if (IS_ACTIVE_BOMB(dynabomb_element))
3250 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
3251 dynabomb_size = player->dynabomb_size;
3252 dynabomb_xl = player->dynabomb_xl;
3253 player->dynabombs_left++;
3256 Explode(ex, ey, EX_PHASE_START, EX_CENTER);
3258 for (i = 0; i < NUM_DIRECTIONS; i++)
3260 for (j = 1; j <= dynabomb_size; j++)
3262 int x = ex + j * xy[i][0];
3263 int y = ey + j * xy[i][1];
3266 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Feld[x][y]))
3269 element = Feld[x][y];
3271 /* do not restart explosions of fields with active bombs */
3272 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
3275 Explode(x, y, EX_PHASE_START, EX_BORDER);
3277 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
3278 if (element != EL_EMPTY &&
3279 element != EL_SAND &&
3280 element != EL_EXPLOSION &&
3287 void Bang(int x, int y)
3290 int element = MovingOrBlocked2Element(x, y);
3292 int element = Feld[x][y];
3296 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
3298 if (IS_PLAYER(x, y))
3301 struct PlayerInfo *player = PLAYERINFO(x, y);
3303 element = Feld[x][y] = (player->use_murphy_graphic ? EL_SP_MURPHY :
3304 player->element_nr);
3309 PlayLevelSoundAction(x, y, ACTION_EXPLODING);
3311 if (game.emulation == EMU_SUPAPLEX)
3312 PlayLevelSound(x, y, SND_SP_ELEMENT_EXPLODING);
3314 PlayLevelSound(x, y, SND_ELEMENT_EXPLODING);
3319 if (IS_PLAYER(x, y)) /* remove objects that might cause smaller explosion */
3327 case EL_BD_BUTTERFLY:
3330 case EL_DARK_YAMYAM:
3334 RaiseScoreElement(element);
3335 Explode(x, y, EX_PHASE_START, EX_NORMAL);
3337 case EL_DYNABOMB_PLAYER_1_ACTIVE:
3338 case EL_DYNABOMB_PLAYER_2_ACTIVE:
3339 case EL_DYNABOMB_PLAYER_3_ACTIVE:
3340 case EL_DYNABOMB_PLAYER_4_ACTIVE:
3341 case EL_DYNABOMB_INCREASE_NUMBER:
3342 case EL_DYNABOMB_INCREASE_SIZE:
3343 case EL_DYNABOMB_INCREASE_POWER:
3348 case EL_LAMP_ACTIVE:
3350 case EL_AMOEBA_TO_DIAMOND:
3352 if (IS_PLAYER(x, y))
3353 Explode(x, y, EX_PHASE_START, EX_NORMAL);
3355 Explode(x, y, EX_PHASE_START, EX_CENTER);
3358 if (CAN_EXPLODE_DYNA(element))
3360 else if (CAN_EXPLODE_1X1(element))
3361 Explode(x, y, EX_PHASE_START, EX_CENTER);
3363 Explode(x, y, EX_PHASE_START, EX_NORMAL);
3367 CheckTriggeredElementChange(x, y, element, CE_OTHER_IS_EXPLODING);
3370 void SplashAcid(int x, int y)
3373 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
3374 (!IN_LEV_FIELD(x - 1, y - 2) ||
3375 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
3376 Feld[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
3378 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
3379 (!IN_LEV_FIELD(x + 1, y - 2) ||
3380 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
3381 Feld[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
3383 PlayLevelSound(x, y, SND_ACID_SPLASHING);
3385 /* input: position of element entering acid (obsolete) */
3387 int element = Feld[x][y];
3389 if (!IN_LEV_FIELD(x, y + 1) || Feld[x][y + 1] != EL_ACID)
3392 if (element != EL_ACID_SPLASH_LEFT &&
3393 element != EL_ACID_SPLASH_RIGHT)
3395 PlayLevelSound(x, y, SND_ACID_SPLASHING);
3397 if (IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y) &&
3398 (!IN_LEV_FIELD(x - 1, y - 1) ||
3399 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 1))))
3400 Feld[x - 1][y] = EL_ACID_SPLASH_LEFT;
3402 if (IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y) &&
3403 (!IN_LEV_FIELD(x + 1, y - 1) ||
3404 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 1))))
3405 Feld[x + 1][y] = EL_ACID_SPLASH_RIGHT;
3410 static void InitBeltMovement()
3412 static int belt_base_element[4] =
3414 EL_CONVEYOR_BELT_1_LEFT,
3415 EL_CONVEYOR_BELT_2_LEFT,
3416 EL_CONVEYOR_BELT_3_LEFT,
3417 EL_CONVEYOR_BELT_4_LEFT
3419 static int belt_base_active_element[4] =
3421 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
3422 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
3423 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
3424 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
3429 /* set frame order for belt animation graphic according to belt direction */
3430 for (i = 0; i < NUM_BELTS; i++)
3434 for (j = 0; j < NUM_BELT_PARTS; j++)
3436 int element = belt_base_active_element[belt_nr] + j;
3437 int graphic = el2img(element);
3439 if (game.belt_dir[i] == MV_LEFT)
3440 graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
3442 graphic_info[graphic].anim_mode |= ANIM_REVERSE;
3446 for (y = 0; y < lev_fieldy; y++)
3448 for (x = 0; x < lev_fieldx; x++)
3450 int element = Feld[x][y];
3452 for (i = 0; i < NUM_BELTS; i++)
3454 if (IS_BELT(element) && game.belt_dir[i] != MV_NO_MOVING)
3456 int e_belt_nr = getBeltNrFromBeltElement(element);
3459 if (e_belt_nr == belt_nr)
3461 int belt_part = Feld[x][y] - belt_base_element[belt_nr];
3463 Feld[x][y] = belt_base_active_element[belt_nr] + belt_part;
3471 static void ToggleBeltSwitch(int x, int y)
3473 static int belt_base_element[4] =
3475 EL_CONVEYOR_BELT_1_LEFT,
3476 EL_CONVEYOR_BELT_2_LEFT,
3477 EL_CONVEYOR_BELT_3_LEFT,
3478 EL_CONVEYOR_BELT_4_LEFT
3480 static int belt_base_active_element[4] =
3482 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
3483 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
3484 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
3485 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
3487 static int belt_base_switch_element[4] =
3489 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
3490 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
3491 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
3492 EL_CONVEYOR_BELT_4_SWITCH_LEFT
3494 static int belt_move_dir[4] =
3502 int element = Feld[x][y];
3503 int belt_nr = getBeltNrFromBeltSwitchElement(element);
3504 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
3505 int belt_dir = belt_move_dir[belt_dir_nr];
3508 if (!IS_BELT_SWITCH(element))
3511 game.belt_dir_nr[belt_nr] = belt_dir_nr;
3512 game.belt_dir[belt_nr] = belt_dir;
3514 if (belt_dir_nr == 3)
3517 /* set frame order for belt animation graphic according to belt direction */
3518 for (i = 0; i < NUM_BELT_PARTS; i++)
3520 int element = belt_base_active_element[belt_nr] + i;
3521 int graphic = el2img(element);
3523 if (belt_dir == MV_LEFT)
3524 graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
3526 graphic_info[graphic].anim_mode |= ANIM_REVERSE;
3529 for (yy = 0; yy < lev_fieldy; yy++)
3531 for (xx = 0; xx < lev_fieldx; xx++)
3533 int element = Feld[xx][yy];
3535 if (IS_BELT_SWITCH(element))
3537 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
3539 if (e_belt_nr == belt_nr)
3541 Feld[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
3542 DrawLevelField(xx, yy);
3545 else if (IS_BELT(element) && belt_dir != MV_NO_MOVING)
3547 int e_belt_nr = getBeltNrFromBeltElement(element);
3549 if (e_belt_nr == belt_nr)
3551 int belt_part = Feld[xx][yy] - belt_base_element[belt_nr];
3553 Feld[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
3554 DrawLevelField(xx, yy);
3557 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NO_MOVING)
3559 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
3561 if (e_belt_nr == belt_nr)
3563 int belt_part = Feld[xx][yy] - belt_base_active_element[belt_nr];
3565 Feld[xx][yy] = belt_base_element[belt_nr] + belt_part;
3566 DrawLevelField(xx, yy);
3573 static void ToggleSwitchgateSwitch(int x, int y)
3577 game.switchgate_pos = !game.switchgate_pos;
3579 for (yy = 0; yy < lev_fieldy; yy++)
3581 for (xx = 0; xx < lev_fieldx; xx++)
3583 int element = Feld[xx][yy];
3585 if (element == EL_SWITCHGATE_SWITCH_UP ||
3586 element == EL_SWITCHGATE_SWITCH_DOWN)
3588 Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
3589 DrawLevelField(xx, yy);
3591 else if (element == EL_SWITCHGATE_OPEN ||
3592 element == EL_SWITCHGATE_OPENING)
3594 Feld[xx][yy] = EL_SWITCHGATE_CLOSING;
3596 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
3598 PlayLevelSound(xx, yy, SND_SWITCHGATE_CLOSING);
3601 else if (element == EL_SWITCHGATE_CLOSED ||
3602 element == EL_SWITCHGATE_CLOSING)
3604 Feld[xx][yy] = EL_SWITCHGATE_OPENING;
3606 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
3608 PlayLevelSound(xx, yy, SND_SWITCHGATE_OPENING);
3615 static int getInvisibleActiveFromInvisibleElement(int element)
3617 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
3618 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
3619 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
3623 static int getInvisibleFromInvisibleActiveElement(int element)
3625 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
3626 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
3627 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
3631 static void RedrawAllLightSwitchesAndInvisibleElements()
3635 for (y = 0; y < lev_fieldy; y++)
3637 for (x = 0; x < lev_fieldx; x++)
3639 int element = Feld[x][y];
3641 if (element == EL_LIGHT_SWITCH &&
3642 game.light_time_left > 0)
3644 Feld[x][y] = EL_LIGHT_SWITCH_ACTIVE;
3645 DrawLevelField(x, y);
3647 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
3648 game.light_time_left == 0)
3650 Feld[x][y] = EL_LIGHT_SWITCH;
3651 DrawLevelField(x, y);
3653 else if (element == EL_INVISIBLE_STEELWALL ||
3654 element == EL_INVISIBLE_WALL ||
3655 element == EL_INVISIBLE_SAND)
3657 if (game.light_time_left > 0)
3658 Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
3660 DrawLevelField(x, y);
3662 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
3663 element == EL_INVISIBLE_WALL_ACTIVE ||
3664 element == EL_INVISIBLE_SAND_ACTIVE)
3666 if (game.light_time_left == 0)
3667 Feld[x][y] = getInvisibleFromInvisibleActiveElement(element);
3669 DrawLevelField(x, y);
3675 static void ToggleLightSwitch(int x, int y)
3677 int element = Feld[x][y];
3679 game.light_time_left =
3680 (element == EL_LIGHT_SWITCH ?
3681 level.time_light * FRAMES_PER_SECOND : 0);
3683 RedrawAllLightSwitchesAndInvisibleElements();
3686 static void ActivateTimegateSwitch(int x, int y)
3690 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
3692 for (yy = 0; yy < lev_fieldy; yy++)
3694 for (xx = 0; xx < lev_fieldx; xx++)
3696 int element = Feld[xx][yy];
3698 if (element == EL_TIMEGATE_CLOSED ||
3699 element == EL_TIMEGATE_CLOSING)
3701 Feld[xx][yy] = EL_TIMEGATE_OPENING;
3702 PlayLevelSound(xx, yy, SND_TIMEGATE_OPENING);
3706 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
3708 Feld[xx][yy] = EL_TIMEGATE_SWITCH;
3709 DrawLevelField(xx, yy);
3716 Feld[x][y] = EL_TIMEGATE_SWITCH_ACTIVE;
3719 inline static int getElementMoveStepsize(int x, int y)
3721 int element = Feld[x][y];
3722 int direction = MovDir[x][y];
3723 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
3724 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
3725 int horiz_move = (dx != 0);
3726 int sign = (horiz_move ? dx : dy);
3727 int step = sign * element_info[element].move_stepsize;
3729 /* special values for move stepsize for spring and things on conveyor belt */
3733 if (element == EL_SPRING)
3734 step = sign * MOVE_STEPSIZE_NORMAL * 2;
3735 else if (CAN_FALL(element) && !CAN_MOVE(element) &&
3736 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
3737 step = sign * MOVE_STEPSIZE_NORMAL / 2;
3739 if (CAN_FALL(element) &&
3740 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
3741 step = sign * MOVE_STEPSIZE_NORMAL / 2;
3742 else if (element == EL_SPRING)
3743 step = sign * MOVE_STEPSIZE_NORMAL * 2;
3750 void Impact(int x, int y)
3752 boolean lastline = (y == lev_fieldy-1);
3753 boolean object_hit = FALSE;
3754 boolean impact = (lastline || object_hit);
3755 int element = Feld[x][y];
3756 int smashed = EL_UNDEFINED;
3758 if (!lastline) /* check if element below was hit */
3760 if (Feld[x][y + 1] == EL_PLAYER_IS_LEAVING)
3763 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
3764 MovDir[x][y + 1] != MV_DOWN ||
3765 MovPos[x][y + 1] <= TILEY / 2));
3768 object_hit = !IS_FREE(x, y + 1);
3771 /* do not smash moving elements that left the smashed field in time */
3772 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
3773 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
3777 smashed = MovingOrBlocked2Element(x, y + 1);
3779 impact = (lastline || object_hit);
3782 if (!lastline && smashed == EL_ACID) /* element falls into acid */
3784 SplashAcid(x, y + 1);
3788 /* only reset graphic animation if graphic really changes after impact */
3790 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
3792 ResetGfxAnimation(x, y);
3793 DrawLevelField(x, y);
3796 if (impact && CAN_EXPLODE_IMPACT(element))
3801 else if (impact && element == EL_PEARL)
3803 Feld[x][y] = EL_PEARL_BREAKING;
3804 PlayLevelSound(x, y, SND_PEARL_BREAKING);
3807 else if (impact && CheckElementChange(x, y, element, CE_IMPACT))
3809 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
3814 if (impact && element == EL_AMOEBA_DROP)
3816 if (object_hit && IS_PLAYER(x, y + 1))
3817 KillHeroUnlessEnemyProtected(x, y + 1);
3818 else if (object_hit && smashed == EL_PENGUIN)
3822 Feld[x][y] = EL_AMOEBA_GROWING;
3823 Store[x][y] = EL_AMOEBA_WET;
3825 ResetRandomAnimationValue(x, y);
3830 if (object_hit) /* check which object was hit */
3832 if (CAN_PASS_MAGIC_WALL(element) &&
3833 (smashed == EL_MAGIC_WALL ||
3834 smashed == EL_BD_MAGIC_WALL))
3837 int activated_magic_wall =
3838 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
3839 EL_BD_MAGIC_WALL_ACTIVE);
3841 /* activate magic wall / mill */
3842 for (yy = 0; yy < lev_fieldy; yy++)
3843 for (xx = 0; xx < lev_fieldx; xx++)
3844 if (Feld[xx][yy] == smashed)
3845 Feld[xx][yy] = activated_magic_wall;
3847 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
3848 game.magic_wall_active = TRUE;
3850 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
3851 SND_MAGIC_WALL_ACTIVATING :
3852 SND_BD_MAGIC_WALL_ACTIVATING));
3855 if (IS_PLAYER(x, y + 1))
3857 if (CAN_SMASH_PLAYER(element))
3859 KillHeroUnlessEnemyProtected(x, y + 1);
3863 else if (smashed == EL_PENGUIN)
3865 if (CAN_SMASH_PLAYER(element))
3871 else if (element == EL_BD_DIAMOND)
3873 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
3879 else if (((element == EL_SP_INFOTRON ||
3880 element == EL_SP_ZONK) &&
3881 (smashed == EL_SP_SNIKSNAK ||
3882 smashed == EL_SP_ELECTRON ||
3883 smashed == EL_SP_DISK_ORANGE)) ||
3884 (element == EL_SP_INFOTRON &&
3885 smashed == EL_SP_DISK_YELLOW))
3891 else if (CAN_SMASH_ENEMIES(element) && IS_CLASSIC_ENEMY(smashed))
3897 else if (CAN_SMASH_EVERYTHING(element))
3899 if (IS_CLASSIC_ENEMY(smashed) ||
3900 CAN_EXPLODE_SMASHED(smashed))
3905 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
3907 if (smashed == EL_LAMP ||
3908 smashed == EL_LAMP_ACTIVE)
3913 else if (smashed == EL_NUT)
3915 Feld[x][y + 1] = EL_NUT_BREAKING;
3916 PlayLevelSound(x, y, SND_NUT_BREAKING);
3917 RaiseScoreElement(EL_NUT);
3920 else if (smashed == EL_PEARL)
3922 Feld[x][y + 1] = EL_PEARL_BREAKING;
3923 PlayLevelSound(x, y, SND_PEARL_BREAKING);
3926 else if (smashed == EL_DIAMOND)
3928 Feld[x][y + 1] = EL_DIAMOND_BREAKING;
3929 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
3932 else if (IS_BELT_SWITCH(smashed))
3934 ToggleBeltSwitch(x, y + 1);
3936 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
3937 smashed == EL_SWITCHGATE_SWITCH_DOWN)
3939 ToggleSwitchgateSwitch(x, y + 1);
3941 else if (smashed == EL_LIGHT_SWITCH ||
3942 smashed == EL_LIGHT_SWITCH_ACTIVE)
3944 ToggleLightSwitch(x, y + 1);
3949 TestIfElementSmashesCustomElement(x, y, MV_DOWN);
3952 CheckElementChange(x, y + 1, smashed, CE_SMASHED);
3954 CheckTriggeredElementChangeSide(x, y + 1, smashed,
3955 CE_OTHER_IS_SWITCHING, CH_SIDE_TOP);
3956 CheckElementChangeSide(x, y + 1, smashed, CE_SWITCHED, CH_SIDE_TOP);
3961 CheckElementChange(x, y + 1, smashed, CE_SMASHED);
3966 /* play sound of magic wall / mill */
3968 (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
3969 Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
3971 if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
3972 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
3973 else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
3974 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
3979 /* play sound of object that hits the ground */
3980 if (lastline || object_hit)
3981 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
3984 inline static void TurnRoundExt(int x, int y)
3996 { 0, 0 }, { 0, 0 }, { 0, 0 },
4001 int left, right, back;
4005 { MV_DOWN, MV_UP, MV_RIGHT },
4006 { MV_UP, MV_DOWN, MV_LEFT },
4008 { MV_LEFT, MV_RIGHT, MV_DOWN },
4012 { MV_RIGHT, MV_LEFT, MV_UP }
4015 int element = Feld[x][y];
4016 int move_pattern = element_info[element].move_pattern;
4018 int old_move_dir = MovDir[x][y];
4019 int left_dir = turn[old_move_dir].left;
4020 int right_dir = turn[old_move_dir].right;
4021 int back_dir = turn[old_move_dir].back;
4023 int left_dx = move_xy[left_dir].x, left_dy = move_xy[left_dir].y;
4024 int right_dx = move_xy[right_dir].x, right_dy = move_xy[right_dir].y;
4025 int move_dx = move_xy[old_move_dir].x, move_dy = move_xy[old_move_dir].y;
4026 int back_dx = move_xy[back_dir].x, back_dy = move_xy[back_dir].y;
4028 int left_x = x + left_dx, left_y = y + left_dy;
4029 int right_x = x + right_dx, right_y = y + right_dy;
4030 int move_x = x + move_dx, move_y = y + move_dy;
4034 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4036 TestIfBadThingTouchesOtherBadThing(x, y);
4038 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
4039 MovDir[x][y] = right_dir;
4040 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
4041 MovDir[x][y] = left_dir;
4043 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
4045 else if (element == EL_BD_BUTTERFLY) /* && MovDir[x][y] == left_dir) */
4049 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4050 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4052 TestIfBadThingTouchesOtherBadThing(x, y);
4054 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
4055 MovDir[x][y] = left_dir;
4056 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
4057 MovDir[x][y] = right_dir;
4059 if ((element == EL_SPACESHIP ||
4060 element == EL_SP_SNIKSNAK ||
4061 element == EL_SP_ELECTRON)
4062 && MovDir[x][y] != old_move_dir)
4064 else if (element == EL_BD_FIREFLY) /* && MovDir[x][y] == right_dir) */
4068 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
4070 TestIfBadThingTouchesOtherBadThing(x, y);
4072 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
4073 MovDir[x][y] = left_dir;
4074 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
4075 MovDir[x][y] = right_dir;
4077 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
4079 else if (element == EL_BD_FIREFLY) /* && MovDir[x][y] == right_dir) */
4082 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4084 TestIfBadThingTouchesOtherBadThing(x, y);
4086 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
4087 MovDir[x][y] = left_dir;
4088 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
4089 MovDir[x][y] = right_dir;
4091 if (MovDir[x][y] != old_move_dir)
4095 else if (element == EL_YAMYAM)
4097 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
4098 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
4100 if (can_turn_left && can_turn_right)
4101 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4102 else if (can_turn_left)
4103 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4104 else if (can_turn_right)
4105 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4107 MovDir[x][y] = back_dir;
4109 MovDelay[x][y] = 16 + 16 * RND(3);
4111 else if (element == EL_DARK_YAMYAM)
4113 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
4115 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
4118 if (can_turn_left && can_turn_right)
4119 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4120 else if (can_turn_left)
4121 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4122 else if (can_turn_right)
4123 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4125 MovDir[x][y] = back_dir;
4127 MovDelay[x][y] = 16 + 16 * RND(3);
4129 else if (element == EL_PACMAN)
4131 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
4132 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
4134 if (can_turn_left && can_turn_right)
4135 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4136 else if (can_turn_left)
4137 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4138 else if (can_turn_right)
4139 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4141 MovDir[x][y] = back_dir;
4143 MovDelay[x][y] = 6 + RND(40);
4145 else if (element == EL_PIG)
4147 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
4148 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
4149 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
4150 boolean should_turn_left, should_turn_right, should_move_on;
4152 int rnd = RND(rnd_value);
4154 should_turn_left = (can_turn_left &&
4156 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
4157 y + back_dy + left_dy)));
4158 should_turn_right = (can_turn_right &&
4160 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
4161 y + back_dy + right_dy)));
4162 should_move_on = (can_move_on &&
4165 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
4166 y + move_dy + left_dy) ||
4167 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
4168 y + move_dy + right_dy)));
4170 if (should_turn_left || should_turn_right || should_move_on)
4172 if (should_turn_left && should_turn_right && should_move_on)
4173 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
4174 rnd < 2 * rnd_value / 3 ? right_dir :
4176 else if (should_turn_left && should_turn_right)
4177 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4178 else if (should_turn_left && should_move_on)
4179 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
4180 else if (should_turn_right && should_move_on)
4181 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
4182 else if (should_turn_left)
4183 MovDir[x][y] = left_dir;
4184 else if (should_turn_right)
4185 MovDir[x][y] = right_dir;
4186 else if (should_move_on)
4187 MovDir[x][y] = old_move_dir;
4189 else if (can_move_on && rnd > rnd_value / 8)
4190 MovDir[x][y] = old_move_dir;
4191 else if (can_turn_left && can_turn_right)
4192 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4193 else if (can_turn_left && rnd > rnd_value / 8)
4194 MovDir[x][y] = left_dir;
4195 else if (can_turn_right && rnd > rnd_value/8)
4196 MovDir[x][y] = right_dir;
4198 MovDir[x][y] = back_dir;
4200 xx = x + move_xy[MovDir[x][y]].x;
4201 yy = y + move_xy[MovDir[x][y]].y;
4203 if (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Feld[xx][yy]))
4204 MovDir[x][y] = old_move_dir;
4208 else if (element == EL_DRAGON)
4210 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
4211 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
4212 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
4214 int rnd = RND(rnd_value);
4217 if (FrameCounter < 1 && x == 0 && y == 29)
4218 printf(":2: %d/%d: %d [%d]\n", x, y, MovDir[x][y], FrameCounter);
4221 if (can_move_on && rnd > rnd_value / 8)
4222 MovDir[x][y] = old_move_dir;
4223 else if (can_turn_left && can_turn_right)
4224 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4225 else if (can_turn_left && rnd > rnd_value / 8)
4226 MovDir[x][y] = left_dir;
4227 else if (can_turn_right && rnd > rnd_value / 8)
4228 MovDir[x][y] = right_dir;
4230 MovDir[x][y] = back_dir;
4232 xx = x + move_xy[MovDir[x][y]].x;
4233 yy = y + move_xy[MovDir[x][y]].y;
4236 if (FrameCounter < 1 && x == 0 && y == 29)
4237 printf(":3: %d/%d: %d (%d/%d: %d) [%d]\n", x, y, MovDir[x][y],
4238 xx, yy, Feld[xx][yy],
4243 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
4244 MovDir[x][y] = old_move_dir;
4246 if (!IS_FREE(xx, yy))
4247 MovDir[x][y] = old_move_dir;
4251 if (FrameCounter < 1 && x == 0 && y == 29)
4252 printf(":4: %d/%d: %d [%d]\n", x, y, MovDir[x][y], FrameCounter);
4257 else if (element == EL_MOLE)
4259 boolean can_move_on =
4260 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
4261 IS_AMOEBOID(Feld[move_x][move_y]) ||
4262 Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
4265 boolean can_turn_left =
4266 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
4267 IS_AMOEBOID(Feld[left_x][left_y])));
4269 boolean can_turn_right =
4270 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
4271 IS_AMOEBOID(Feld[right_x][right_y])));
4273 if (can_turn_left && can_turn_right)
4274 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
4275 else if (can_turn_left)
4276 MovDir[x][y] = left_dir;
4278 MovDir[x][y] = right_dir;
4281 if (MovDir[x][y] != old_move_dir)
4284 else if (element == EL_BALLOON)
4286 MovDir[x][y] = game.balloon_dir;
4289 else if (element == EL_SPRING)
4292 if (MovDir[x][y] & MV_HORIZONTAL &&
4293 !SPRING_CAN_ENTER_FIELD(element, move_x, move_y))
4294 MovDir[x][y] = MV_NO_MOVING;
4296 if (MovDir[x][y] & MV_HORIZONTAL &&
4297 (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
4298 SPRING_CAN_ENTER_FIELD(element, x, y + 1)))
4299 MovDir[x][y] = MV_NO_MOVING;
4304 else if (element == EL_ROBOT ||
4305 element == EL_SATELLITE ||
4306 element == EL_PENGUIN)
4308 int attr_x = -1, attr_y = -1;
4319 for (i = 0; i < MAX_PLAYERS; i++)
4321 struct PlayerInfo *player = &stored_player[i];
4322 int jx = player->jx, jy = player->jy;
4324 if (!player->active)
4328 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
4336 if (element == EL_ROBOT && ZX >= 0 && ZY >= 0)
4342 if (element == EL_PENGUIN)
4345 static int xy[4][2] =
4353 for (i = 0; i < NUM_DIRECTIONS; i++)
4355 int ex = x + xy[i][0];
4356 int ey = y + xy[i][1];
4358 if (IN_LEV_FIELD(ex, ey) && Feld[ex][ey] == EL_EXIT_OPEN)
4367 MovDir[x][y] = MV_NO_MOVING;
4369 MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
4370 else if (attr_x > x)
4371 MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
4373 MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
4374 else if (attr_y > y)
4375 MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
4377 if (element == EL_ROBOT)
4381 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4382 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
4383 Moving2Blocked(x, y, &newx, &newy);
4385 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
4386 MovDelay[x][y] = 8 + 8 * !RND(3);
4388 MovDelay[x][y] = 16;
4390 else if (element == EL_PENGUIN)
4396 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4398 boolean first_horiz = RND(2);
4399 int new_move_dir = MovDir[x][y];
4402 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4403 Moving2Blocked(x, y, &newx, &newy);
4405 if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
4409 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4410 Moving2Blocked(x, y, &newx, &newy);
4412 if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
4415 MovDir[x][y] = old_move_dir;
4419 else /* (element == EL_SATELLITE) */
4425 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4427 boolean first_horiz = RND(2);
4428 int new_move_dir = MovDir[x][y];
4431 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4432 Moving2Blocked(x, y, &newx, &newy);
4434 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
4438 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4439 Moving2Blocked(x, y, &newx, &newy);
4441 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
4444 MovDir[x][y] = old_move_dir;
4449 else if (move_pattern == MV_TURNING_LEFT ||
4450 move_pattern == MV_TURNING_RIGHT ||
4451 move_pattern == MV_TURNING_LEFT_RIGHT ||
4452 move_pattern == MV_TURNING_RIGHT_LEFT ||
4453 move_pattern == MV_TURNING_RANDOM ||
4454 move_pattern == MV_ALL_DIRECTIONS)
4456 boolean can_turn_left =
4457 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
4458 boolean can_turn_right =
4459 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
4461 if (move_pattern == MV_TURNING_LEFT)
4462 MovDir[x][y] = left_dir;
4463 else if (move_pattern == MV_TURNING_RIGHT)
4464 MovDir[x][y] = right_dir;
4465 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
4466 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
4467 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
4468 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
4469 else if (move_pattern == MV_TURNING_RANDOM)
4470 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
4471 can_turn_right && !can_turn_left ? right_dir :
4472 RND(2) ? left_dir : right_dir);
4473 else if (can_turn_left && can_turn_right)
4474 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4475 else if (can_turn_left)
4476 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4477 else if (can_turn_right)
4478 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4480 MovDir[x][y] = back_dir;
4482 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4484 else if (move_pattern == MV_HORIZONTAL ||
4485 move_pattern == MV_VERTICAL)
4487 if (move_pattern & old_move_dir)
4488 MovDir[x][y] = back_dir;
4489 else if (move_pattern == MV_HORIZONTAL)
4490 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4491 else if (move_pattern == MV_VERTICAL)
4492 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4494 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4496 else if (move_pattern & MV_ANY_DIRECTION)
4498 MovDir[x][y] = move_pattern;
4499 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4501 else if (move_pattern == MV_ALONG_LEFT_SIDE)
4503 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
4504 MovDir[x][y] = left_dir;
4505 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4506 MovDir[x][y] = right_dir;
4508 if (MovDir[x][y] != old_move_dir)
4509 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4511 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
4513 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
4514 MovDir[x][y] = right_dir;
4515 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4516 MovDir[x][y] = left_dir;
4518 if (MovDir[x][y] != old_move_dir)
4519 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4521 else if (move_pattern == MV_TOWARDS_PLAYER ||
4522 move_pattern == MV_AWAY_FROM_PLAYER)
4524 int attr_x = -1, attr_y = -1;
4526 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
4537 for (i = 0; i < MAX_PLAYERS; i++)
4539 struct PlayerInfo *player = &stored_player[i];
4540 int jx = player->jx, jy = player->jy;
4542 if (!player->active)
4546 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
4554 MovDir[x][y] = MV_NO_MOVING;
4556 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
4557 else if (attr_x > x)
4558 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
4560 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
4561 else if (attr_y > y)
4562 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
4564 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4566 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4568 boolean first_horiz = RND(2);
4569 int new_move_dir = MovDir[x][y];
4572 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4573 Moving2Blocked(x, y, &newx, &newy);
4575 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
4579 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4580 Moving2Blocked(x, y, &newx, &newy);
4582 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
4585 MovDir[x][y] = old_move_dir;
4588 else if (move_pattern == MV_WHEN_PUSHED ||
4589 move_pattern == MV_WHEN_DROPPED)
4591 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4592 MovDir[x][y] = MV_NO_MOVING;
4596 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
4598 static int test_xy[7][2] =
4608 static int test_dir[7] =
4618 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
4619 int move_preference = -1000000; /* start with very low preference */
4620 int new_move_dir = MV_NO_MOVING;
4621 int start_test = RND(4);
4624 for (i = 0; i < NUM_DIRECTIONS; i++)
4626 int move_dir = test_dir[start_test + i];
4627 int move_dir_preference;
4629 xx = x + test_xy[start_test + i][0];
4630 yy = y + test_xy[start_test + i][1];
4632 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
4633 (IS_PLAYER(xx, yy) || Feld[xx][yy] == EL_PLAYER_IS_LEAVING))
4635 new_move_dir = move_dir;
4640 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
4643 move_dir_preference = -1 * RunnerVisit[xx][yy];
4644 if (hunter_mode && PlayerVisit[xx][yy] > 0)
4645 move_dir_preference = PlayerVisit[xx][yy];
4647 if (move_dir_preference > move_preference)
4649 /* prefer field that has not been visited for the longest time */
4650 move_preference = move_dir_preference;
4651 new_move_dir = move_dir;
4653 else if (move_dir_preference == move_preference &&
4654 move_dir == old_move_dir)
4656 /* prefer last direction when all directions are preferred equally */
4657 move_preference = move_dir_preference;
4658 new_move_dir = move_dir;
4662 MovDir[x][y] = new_move_dir;
4663 if (old_move_dir != new_move_dir)
4668 static void TurnRound(int x, int y)
4670 int direction = MovDir[x][y];
4673 GfxDir[x][y] = MovDir[x][y];
4679 GfxDir[x][y] = MovDir[x][y];
4682 if (direction != MovDir[x][y])
4687 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_BIT(direction);
4690 GfxAction[x][y] = ACTION_WAITING;
4694 static boolean JustBeingPushed(int x, int y)
4698 for (i = 0; i < MAX_PLAYERS; i++)
4700 struct PlayerInfo *player = &stored_player[i];
4702 if (player->active && player->is_pushing && player->MovPos)
4704 int next_jx = player->jx + (player->jx - player->last_jx);
4705 int next_jy = player->jy + (player->jy - player->last_jy);
4707 if (x == next_jx && y == next_jy)
4715 void StartMoving(int x, int y)
4718 boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0,0));
4720 boolean started_moving = FALSE; /* some elements can fall _and_ move */
4721 int element = Feld[x][y];
4727 if (MovDelay[x][y] == 0)
4728 GfxAction[x][y] = ACTION_DEFAULT;
4730 /* !!! this should be handled more generic (not only for mole) !!! */
4731 if (element != EL_MOLE && GfxAction[x][y] != ACTION_DIGGING)
4732 GfxAction[x][y] = ACTION_DEFAULT;
4735 if (CAN_FALL(element) && y < lev_fieldy - 1)
4737 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
4738 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
4739 if (JustBeingPushed(x, y))
4742 if (element == EL_QUICKSAND_FULL)
4744 if (IS_FREE(x, y + 1))
4746 InitMovingField(x, y, MV_DOWN);
4747 started_moving = TRUE;
4749 Feld[x][y] = EL_QUICKSAND_EMPTYING;
4750 Store[x][y] = EL_ROCK;
4752 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
4754 PlayLevelSound(x, y, SND_QUICKSAND_EMPTYING);
4757 else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
4759 if (!MovDelay[x][y])
4760 MovDelay[x][y] = TILEY + 1;
4769 Feld[x][y] = EL_QUICKSAND_EMPTY;
4770 Feld[x][y + 1] = EL_QUICKSAND_FULL;
4771 Store[x][y + 1] = Store[x][y];
4774 PlayLevelSoundAction(x, y, ACTION_FILLING);
4776 PlayLevelSound(x, y, SND_QUICKSAND_FILLING);
4780 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
4781 Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
4783 InitMovingField(x, y, MV_DOWN);
4784 started_moving = TRUE;
4786 Feld[x][y] = EL_QUICKSAND_FILLING;
4787 Store[x][y] = element;
4789 PlayLevelSoundAction(x, y, ACTION_FILLING);
4791 PlayLevelSound(x, y, SND_QUICKSAND_FILLING);
4794 else if (element == EL_MAGIC_WALL_FULL)
4796 if (IS_FREE(x, y + 1))
4798 InitMovingField(x, y, MV_DOWN);
4799 started_moving = TRUE;
4801 Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
4802 Store[x][y] = EL_CHANGED(Store[x][y]);
4804 else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
4806 if (!MovDelay[x][y])
4807 MovDelay[x][y] = TILEY/4 + 1;
4816 Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
4817 Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
4818 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
4822 else if (element == EL_BD_MAGIC_WALL_FULL)
4824 if (IS_FREE(x, y + 1))
4826 InitMovingField(x, y, MV_DOWN);
4827 started_moving = TRUE;
4829 Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
4830 Store[x][y] = EL_CHANGED2(Store[x][y]);
4832 else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
4834 if (!MovDelay[x][y])
4835 MovDelay[x][y] = TILEY/4 + 1;
4844 Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
4845 Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
4846 Store[x][y + 1] = EL_CHANGED2(Store[x][y]);
4850 else if (CAN_PASS_MAGIC_WALL(element) &&
4851 (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
4852 Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
4854 InitMovingField(x, y, MV_DOWN);
4855 started_moving = TRUE;
4858 (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
4859 EL_BD_MAGIC_WALL_FILLING);
4860 Store[x][y] = element;
4863 else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_ACID)
4865 else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
4868 SplashAcid(x, y + 1);
4870 InitMovingField(x, y, MV_DOWN);
4871 started_moving = TRUE;
4873 Store[x][y] = EL_ACID;
4875 /* !!! TEST !!! better use "_FALLING" etc. !!! */
4876 GfxAction[x][y + 1] = ACTION_ACTIVE;
4880 else if ((game.engine_version < VERSION_IDENT(2,2,0,7) &&
4881 CAN_SMASH(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
4882 (Feld[x][y + 1] == EL_BLOCKED)) ||
4883 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
4884 CAN_SMASH(element) && WasJustFalling[x][y] &&
4885 (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))))
4889 else if (game.engine_version < VERSION_IDENT(2,2,0,7) &&
4890 CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
4891 WasJustMoving[x][y] && !Pushed[x][y + 1])
4893 else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
4894 WasJustMoving[x][y])
4899 /* this is needed for a special case not covered by calling "Impact()"
4900 from "ContinueMoving()": if an element moves to a tile directly below
4901 another element which was just falling on that tile (which was empty
4902 in the previous frame), the falling element above would just stop
4903 instead of smashing the element below (in previous version, the above
4904 element was just checked for "moving" instead of "falling", resulting
4905 in incorrect smashes caused by horizontal movement of the above
4906 element; also, the case of the player being the element to smash was
4907 simply not covered here... :-/ ) */
4910 WasJustMoving[x][y] = 0;
4911 WasJustFalling[x][y] = 0;
4916 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
4918 if (MovDir[x][y] == MV_NO_MOVING)
4920 InitMovingField(x, y, MV_DOWN);
4921 started_moving = TRUE;
4924 else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
4926 if (WasJustFalling[x][y]) /* prevent animation from being restarted */
4927 MovDir[x][y] = MV_DOWN;
4929 InitMovingField(x, y, MV_DOWN);
4930 started_moving = TRUE;
4932 else if (element == EL_AMOEBA_DROP)
4934 Feld[x][y] = EL_AMOEBA_GROWING;
4935 Store[x][y] = EL_AMOEBA_WET;
4937 /* Store[x][y + 1] must be zero, because:
4938 (EL_QUICKSAND_FULL -> EL_ROCK): Store[x][y + 1] == EL_QUICKSAND_EMPTY
4941 #if OLD_GAME_BEHAVIOUR
4942 else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1])
4944 else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1] &&
4945 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
4946 element != EL_DX_SUPABOMB)
4949 else if (((IS_SLIPPERY(Feld[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
4950 (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
4951 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
4952 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
4955 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
4956 (IS_FREE(x - 1, y + 1) ||
4957 Feld[x - 1][y + 1] == EL_ACID));
4958 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
4959 (IS_FREE(x + 1, y + 1) ||
4960 Feld[x + 1][y + 1] == EL_ACID));
4961 boolean can_fall_any = (can_fall_left || can_fall_right);
4962 boolean can_fall_both = (can_fall_left && can_fall_right);
4964 if (can_fall_any && IS_CUSTOM_ELEMENT(Feld[x][y + 1]))
4966 int slippery_type = element_info[Feld[x][y + 1]].slippery_type;
4968 if (slippery_type == SLIPPERY_ONLY_LEFT)
4969 can_fall_right = FALSE;
4970 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
4971 can_fall_left = FALSE;
4972 else if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
4973 can_fall_right = FALSE;
4974 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
4975 can_fall_left = FALSE;
4977 can_fall_any = (can_fall_left || can_fall_right);
4978 can_fall_both = (can_fall_left && can_fall_right);
4983 if (can_fall_both &&
4984 (game.emulation != EMU_BOULDERDASH &&
4985 element != EL_BD_ROCK && element != EL_BD_DIAMOND))
4986 can_fall_left = !(can_fall_right = RND(2));
4988 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
4989 started_moving = TRUE;
4993 else if (IS_BELT_ACTIVE(Feld[x][y + 1]) && !CAN_MOVE(element))
4995 else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
4998 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
4999 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
5000 int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
5001 int belt_dir = game.belt_dir[belt_nr];
5003 if ((belt_dir == MV_LEFT && left_is_free) ||
5004 (belt_dir == MV_RIGHT && right_is_free))
5007 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
5010 InitMovingField(x, y, belt_dir);
5011 started_moving = TRUE;
5014 Pushed[x][y] = TRUE;
5015 Pushed[nextx][y] = TRUE;
5018 GfxAction[x][y] = ACTION_DEFAULT;
5022 MovDir[x][y] = 0; /* if element was moving, stop it */
5027 /* not "else if" because of elements that can fall and move (EL_SPRING) */
5028 if (CAN_MOVE(element) && !started_moving)
5030 int move_pattern = element_info[element].move_pattern;
5033 Moving2Blocked(x, y, &newx, &newy);
5036 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
5039 if ((element == EL_SATELLITE ||
5040 element == EL_BALLOON ||
5041 element == EL_SPRING)
5042 && JustBeingPushed(x, y))
5047 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
5048 WasJustMoving[x][y] && IN_LEV_FIELD(newx, newy) &&
5049 (Feld[newx][newy] == EL_BLOCKED || IS_PLAYER(newx, newy)))
5052 printf("::: element %d '%s' WasJustMoving %d [%d, %d, %d, %d]\n",
5053 element, element_info[element].token_name,
5054 WasJustMoving[x][y],
5055 HAS_ANY_CHANGE_EVENT(element, CE_HITTING_SOMETHING),
5056 HAS_ANY_CHANGE_EVENT(element, CE_HIT_BY_SOMETHING),
5057 HAS_ANY_CHANGE_EVENT(element, CE_OTHER_IS_HITTING),
5058 HAS_ANY_CHANGE_EVENT(element, CE_OTHER_GETS_HIT));
5062 WasJustMoving[x][y] = 0;
5065 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
5068 if (Feld[x][y] != element) /* element has changed */
5070 element = Feld[x][y];
5071 move_pattern = element_info[element].move_pattern;
5073 if (!CAN_MOVE(element))
5077 if (Feld[x][y] != element) /* element has changed */
5085 if (element == EL_SPRING && MovDir[x][y] == MV_DOWN)
5086 Feld[x][y + 1] = EL_EMPTY; /* was set to EL_BLOCKED above */
5088 if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
5090 Moving2Blocked(x, y, &newx, &newy);
5091 if (Feld[newx][newy] == EL_BLOCKED)
5092 Feld[newx][newy] = EL_EMPTY; /* was set to EL_BLOCKED above */
5098 if (FrameCounter < 1 && x == 0 && y == 29)
5099 printf(":1: %d/%d: %d [%d]\n", x, y, MovDir[x][y], FrameCounter);
5102 if (!MovDelay[x][y]) /* start new movement phase */
5104 /* all objects that can change their move direction after each step
5105 (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall */
5107 if (element != EL_YAMYAM &&
5108 element != EL_DARK_YAMYAM &&
5109 element != EL_PACMAN &&
5110 !(move_pattern & MV_ANY_DIRECTION) &&
5111 move_pattern != MV_TURNING_LEFT &&
5112 move_pattern != MV_TURNING_RIGHT &&
5113 move_pattern != MV_TURNING_LEFT_RIGHT &&
5114 move_pattern != MV_TURNING_RIGHT_LEFT &&
5115 move_pattern != MV_TURNING_RANDOM)
5120 if (FrameCounter < 1 && x == 0 && y == 29)
5121 printf(":9: %d: %d [%d]\n", y, MovDir[x][y], FrameCounter);
5124 if (MovDelay[x][y] && (element == EL_BUG ||
5125 element == EL_SPACESHIP ||
5126 element == EL_SP_SNIKSNAK ||
5127 element == EL_SP_ELECTRON ||
5128 element == EL_MOLE))
5129 DrawLevelField(x, y);
5133 if (MovDelay[x][y]) /* wait some time before next movement */
5138 if (element == EL_YAMYAM)
5141 el_act_dir2img(EL_YAMYAM, ACTION_WAITING, MV_LEFT));
5142 DrawLevelElementAnimation(x, y, element);
5146 if (MovDelay[x][y]) /* element still has to wait some time */
5149 /* !!! PLACE THIS SOMEWHERE AFTER "TurnRound()" !!! */
5150 ResetGfxAnimation(x, y);
5154 if (GfxAction[x][y] != ACTION_WAITING)
5155 printf("::: %d: %d != ACTION_WAITING\n", element, GfxAction[x][y]);
5157 GfxAction[x][y] = ACTION_WAITING;
5161 if (element == EL_ROBOT ||
5163 element == EL_PACMAN ||
5165 element == EL_YAMYAM ||
5166 element == EL_DARK_YAMYAM)
5169 DrawLevelElementAnimation(x, y, element);
5171 DrawLevelElementAnimationIfNeeded(x, y, element);
5173 PlayLevelSoundAction(x, y, ACTION_WAITING);
5175 else if (element == EL_SP_ELECTRON)
5176 DrawLevelElementAnimationIfNeeded(x, y, element);
5177 else if (element == EL_DRAGON)
5180 int dir = MovDir[x][y];
5181 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
5182 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
5183 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
5184 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
5185 dir == MV_UP ? IMG_FLAMES_1_UP :
5186 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
5187 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5190 printf("::: %d, %d\n", GfxAction[x][y], GfxFrame[x][y]);
5193 GfxAction[x][y] = ACTION_ATTACKING;
5195 if (IS_PLAYER(x, y))
5196 DrawPlayerField(x, y);
5198 DrawLevelField(x, y);
5200 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
5202 for (i = 1; i <= 3; i++)
5204 int xx = x + i * dx;
5205 int yy = y + i * dy;
5206 int sx = SCREENX(xx);
5207 int sy = SCREENY(yy);
5208 int flame_graphic = graphic + (i - 1);
5210 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
5215 int flamed = MovingOrBlocked2Element(xx, yy);
5217 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
5220 RemoveMovingField(xx, yy);
5222 Feld[xx][yy] = EL_FLAMES;
5223 if (IN_SCR_FIELD(sx, sy))
5225 DrawLevelFieldCrumbledSand(xx, yy);
5226 DrawGraphic(sx, sy, flame_graphic, frame);
5231 if (Feld[xx][yy] == EL_FLAMES)
5232 Feld[xx][yy] = EL_EMPTY;
5233 DrawLevelField(xx, yy);
5238 if (MovDelay[x][y]) /* element still has to wait some time */
5240 PlayLevelSoundAction(x, y, ACTION_WAITING);
5246 /* special case of "moving" animation of waiting elements (FIX THIS !!!);
5247 for all other elements GfxAction will be set by InitMovingField() */
5248 if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY)
5249 GfxAction[x][y] = ACTION_MOVING;
5253 /* now make next step */
5255 Moving2Blocked(x, y, &newx, &newy); /* get next screen position */
5257 if (DONT_COLLIDE_WITH(element) &&
5258 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
5259 !PLAYER_ENEMY_PROTECTED(newx, newy))
5262 TestIfBadThingRunsIntoHero(x, y, MovDir[x][y]);
5266 /* player killed by element which is deadly when colliding with */
5268 KillHero(PLAYERINFO(newx, newy));
5275 else if (CAN_MOVE_INTO_ACID(element) &&
5276 IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID &&
5277 (MovDir[x][y] == MV_DOWN ||
5278 game.engine_version >= VERSION_IDENT(3,1,0,0)))
5280 else if (CAN_MOVE_INTO_ACID(element) && MovDir[x][y] == MV_DOWN &&
5281 IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID)
5285 else if ((element == EL_PENGUIN ||
5286 element == EL_ROBOT ||
5287 element == EL_SATELLITE ||
5288 element == EL_BALLOON ||
5289 IS_CUSTOM_ELEMENT(element)) &&
5290 IN_LEV_FIELD(newx, newy) &&
5291 MovDir[x][y] == MV_DOWN && Feld[newx][newy] == EL_ACID)
5294 SplashAcid(newx, newy);
5295 Store[x][y] = EL_ACID;
5297 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
5299 if (Feld[newx][newy] == EL_EXIT_OPEN)
5303 DrawLevelField(x, y);
5305 Feld[x][y] = EL_EMPTY;
5306 DrawLevelField(x, y);
5309 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
5310 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
5311 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
5313 local_player->friends_still_needed--;
5314 if (!local_player->friends_still_needed &&
5315 !local_player->GameOver && AllPlayersGone)
5316 local_player->LevelSolved = local_player->GameOver = TRUE;
5320 else if (IS_FOOD_PENGUIN(Feld[newx][newy]))
5322 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MF_MOVING)
5323 DrawLevelField(newx, newy);
5325 GfxDir[x][y] = MovDir[x][y] = MV_NO_MOVING;
5327 else if (!IS_FREE(newx, newy))
5329 GfxAction[x][y] = ACTION_WAITING;
5331 if (IS_PLAYER(x, y))
5332 DrawPlayerField(x, y);
5334 DrawLevelField(x, y);
5339 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
5341 if (IS_FOOD_PIG(Feld[newx][newy]))
5343 if (IS_MOVING(newx, newy))
5344 RemoveMovingField(newx, newy);
5347 Feld[newx][newy] = EL_EMPTY;
5348 DrawLevelField(newx, newy);
5351 PlayLevelSound(x, y, SND_PIG_DIGGING);
5353 else if (!IS_FREE(newx, newy))
5355 if (IS_PLAYER(x, y))
5356 DrawPlayerField(x, y);
5358 DrawLevelField(x, y);
5367 else if (move_pattern & MV_MAZE_RUNNER_STYLE && IN_LEV_FIELD(newx, newy))
5370 else if (IS_CUSTOM_ELEMENT(element) &&
5371 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy)
5375 !IS_FREE(newx, newy)
5380 int new_element = Feld[newx][newy];
5383 printf("::: '%s' digs '%s' [%d]\n",
5384 element_info[element].token_name,
5385 element_info[Feld[newx][newy]].token_name,
5386 StorePlayer[newx][newy]);
5389 if (!IS_FREE(newx, newy))
5391 int action = (IS_DIGGABLE(new_element) ? ACTION_DIGGING :
5392 IS_COLLECTIBLE(new_element) ? ACTION_COLLECTING :
5395 /* no element can dig solid indestructible elements */
5396 if (IS_INDESTRUCTIBLE(new_element) &&
5397 !IS_DIGGABLE(new_element) &&
5398 !IS_COLLECTIBLE(new_element))
5401 if (AmoebaNr[newx][newy] &&
5402 (new_element == EL_AMOEBA_FULL ||
5403 new_element == EL_BD_AMOEBA ||
5404 new_element == EL_AMOEBA_GROWING))
5406 AmoebaCnt[AmoebaNr[newx][newy]]--;
5407 AmoebaCnt2[AmoebaNr[newx][newy]]--;
5410 if (IS_MOVING(newx, newy))
5411 RemoveMovingField(newx, newy);
5414 RemoveField(newx, newy);
5415 DrawLevelField(newx, newy);
5418 PlayLevelSoundAction(x, y, action);
5421 if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element)))
5422 element_info[element].can_leave_element = TRUE;
5424 if (move_pattern & MV_MAZE_RUNNER_STYLE)
5426 RunnerVisit[x][y] = FrameCounter;
5427 PlayerVisit[x][y] /= 8; /* expire player visit path */
5433 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
5435 if (!IS_FREE(newx, newy))
5437 if (IS_PLAYER(x, y))
5438 DrawPlayerField(x, y);
5440 DrawLevelField(x, y);
5446 boolean wanna_flame = !RND(10);
5447 int dx = newx - x, dy = newy - y;
5448 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
5449 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
5450 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
5451 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
5452 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
5453 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
5456 IS_CLASSIC_ENEMY(element1) ||
5457 IS_CLASSIC_ENEMY(element2)) &&
5458 element1 != EL_DRAGON && element2 != EL_DRAGON &&
5459 element1 != EL_FLAMES && element2 != EL_FLAMES)
5462 ResetGfxAnimation(x, y);
5463 GfxAction[x][y] = ACTION_ATTACKING;
5466 if (IS_PLAYER(x, y))
5467 DrawPlayerField(x, y);
5469 DrawLevelField(x, y);
5471 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
5473 MovDelay[x][y] = 50;
5475 Feld[newx][newy] = EL_FLAMES;
5476 if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
5477 Feld[newx1][newy1] = EL_FLAMES;
5478 if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
5479 Feld[newx2][newy2] = EL_FLAMES;
5485 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
5486 Feld[newx][newy] == EL_DIAMOND)
5488 if (IS_MOVING(newx, newy))
5489 RemoveMovingField(newx, newy);
5492 Feld[newx][newy] = EL_EMPTY;
5493 DrawLevelField(newx, newy);
5496 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
5498 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
5499 IS_FOOD_DARK_YAMYAM(Feld[newx][newy]))
5501 if (AmoebaNr[newx][newy])
5503 AmoebaCnt2[AmoebaNr[newx][newy]]--;
5504 if (Feld[newx][newy] == EL_AMOEBA_FULL ||
5505 Feld[newx][newy] == EL_BD_AMOEBA)
5506 AmoebaCnt[AmoebaNr[newx][newy]]--;
5511 if (IS_MOVING(newx, newy) || IS_BLOCKED(newx, newy))
5513 if (IS_MOVING(newx, newy))
5516 RemoveMovingField(newx, newy);
5520 Feld[newx][newy] = EL_EMPTY;
5521 DrawLevelField(newx, newy);
5524 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
5526 else if ((element == EL_PACMAN || element == EL_MOLE)
5527 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
5529 if (AmoebaNr[newx][newy])
5531 AmoebaCnt2[AmoebaNr[newx][newy]]--;
5532 if (Feld[newx][newy] == EL_AMOEBA_FULL ||
5533 Feld[newx][newy] == EL_BD_AMOEBA)
5534 AmoebaCnt[AmoebaNr[newx][newy]]--;
5537 if (element == EL_MOLE)
5539 Feld[newx][newy] = EL_AMOEBA_SHRINKING;
5540 PlayLevelSound(x, y, SND_MOLE_DIGGING);
5542 ResetGfxAnimation(x, y);
5543 GfxAction[x][y] = ACTION_DIGGING;
5544 DrawLevelField(x, y);
5546 MovDelay[newx][newy] = 0; /* start amoeba shrinking delay */
5548 return; /* wait for shrinking amoeba */
5550 else /* element == EL_PACMAN */
5552 Feld[newx][newy] = EL_EMPTY;
5553 DrawLevelField(newx, newy);
5554 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
5557 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
5558 (Feld[newx][newy] == EL_AMOEBA_SHRINKING ||
5559 (Feld[newx][newy] == EL_EMPTY && Stop[newx][newy])))
5561 /* wait for shrinking amoeba to completely disappear */
5564 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
5566 /* object was running against a wall */
5571 if (GFX_ELEMENT(element) != EL_SAND) /* !!! FIX THIS (crumble) !!! */
5572 DrawLevelElementAnimation(x, y, element);
5574 if (element == EL_BUG ||
5575 element == EL_SPACESHIP ||
5576 element == EL_SP_SNIKSNAK)
5577 DrawLevelField(x, y);
5578 else if (element == EL_MOLE)
5579 DrawLevelField(x, y);
5580 else if (element == EL_BD_BUTTERFLY ||
5581 element == EL_BD_FIREFLY)
5582 DrawLevelElementAnimationIfNeeded(x, y, element);
5583 else if (element == EL_SATELLITE)
5584 DrawLevelElementAnimationIfNeeded(x, y, element);
5585 else if (element == EL_SP_ELECTRON)
5586 DrawLevelElementAnimationIfNeeded(x, y, element);
5589 if (DONT_TOUCH(element))
5590 TestIfBadThingTouchesHero(x, y);
5593 PlayLevelSoundAction(x, y, ACTION_WAITING);
5599 InitMovingField(x, y, MovDir[x][y]);
5601 PlayLevelSoundAction(x, y, ACTION_MOVING);
5605 ContinueMoving(x, y);
5608 void ContinueMoving(int x, int y)
5610 int element = Feld[x][y];
5611 struct ElementInfo *ei = &element_info[element];
5612 int direction = MovDir[x][y];
5613 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5614 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5615 int newx = x + dx, newy = y + dy;
5617 int nextx = newx + dx, nexty = newy + dy;
5620 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
5621 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
5623 boolean pushed_by_player = Pushed[x][y];
5626 MovPos[x][y] += getElementMoveStepsize(x, y);
5629 if (pushed_by_player && IS_PLAYER(x, y))
5631 /* special case: moving object pushed by player */
5632 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
5635 if (pushed_by_player) /* special case: moving object pushed by player */
5636 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
5639 if (ABS(MovPos[x][y]) < TILEX)
5641 DrawLevelField(x, y);
5643 return; /* element is still moving */
5646 /* element reached destination field */
5648 Feld[x][y] = EL_EMPTY;
5649 Feld[newx][newy] = element;
5650 MovPos[x][y] = 0; /* force "not moving" for "crumbled sand" */
5652 if (element == EL_MOLE)
5654 Feld[x][y] = EL_SAND;
5656 DrawLevelFieldCrumbledSandNeighbours(x, y);
5658 else if (element == EL_QUICKSAND_FILLING)
5660 element = Feld[newx][newy] = get_next_element(element);
5661 Store[newx][newy] = Store[x][y];
5663 else if (element == EL_QUICKSAND_EMPTYING)
5665 Feld[x][y] = get_next_element(element);
5666 element = Feld[newx][newy] = Store[x][y];
5668 else if (element == EL_MAGIC_WALL_FILLING)
5670 element = Feld[newx][newy] = get_next_element(element);
5671 if (!game.magic_wall_active)
5672 element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
5673 Store[newx][newy] = Store[x][y];
5675 else if (element == EL_MAGIC_WALL_EMPTYING)
5677 Feld[x][y] = get_next_element(element);
5678 if (!game.magic_wall_active)
5679 Feld[x][y] = EL_MAGIC_WALL_DEAD;
5680 element = Feld[newx][newy] = Store[x][y];
5682 else if (element == EL_BD_MAGIC_WALL_FILLING)
5684 element = Feld[newx][newy] = get_next_element(element);
5685 if (!game.magic_wall_active)
5686 element = Feld[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
5687 Store[newx][newy] = Store[x][y];
5689 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
5691 Feld[x][y] = get_next_element(element);
5692 if (!game.magic_wall_active)
5693 Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
5694 element = Feld[newx][newy] = Store[x][y];
5696 else if (element == EL_AMOEBA_DROPPING)
5698 Feld[x][y] = get_next_element(element);
5699 element = Feld[newx][newy] = Store[x][y];
5701 else if (element == EL_SOKOBAN_OBJECT)
5704 Feld[x][y] = Back[x][y];
5706 if (Back[newx][newy])
5707 Feld[newx][newy] = EL_SOKOBAN_FIELD_FULL;
5709 Back[x][y] = Back[newx][newy] = 0;
5711 else if (Store[x][y] == EL_ACID)
5713 element = Feld[newx][newy] = EL_ACID;
5717 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
5718 MovDelay[newx][newy] = 0;
5720 /* copy element change control values to new field */
5721 ChangeDelay[newx][newy] = ChangeDelay[x][y];
5722 ChangePage[newx][newy] = ChangePage[x][y];
5723 Changed[newx][newy] = Changed[x][y];
5724 ChangeEvent[newx][newy] = ChangeEvent[x][y];
5726 ChangeDelay[x][y] = 0;
5727 ChangePage[x][y] = -1;
5728 Changed[x][y] = CE_BITMASK_DEFAULT;
5729 ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
5731 /* copy animation control values to new field */
5732 GfxFrame[newx][newy] = GfxFrame[x][y];
5733 GfxRandom[newx][newy] = GfxRandom[x][y]; /* keep same random value */
5734 GfxAction[newx][newy] = GfxAction[x][y]; /* keep action one frame */
5735 GfxDir[newx][newy] = GfxDir[x][y]; /* keep element direction */
5737 Pushed[x][y] = Pushed[newx][newy] = FALSE;
5739 ResetGfxAnimation(x, y); /* reset animation values for old field */
5742 /* some elements can leave other elements behind after moving */
5743 if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) &&
5744 ei->move_leave_element != EL_EMPTY &&
5745 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED ||
5746 ei->can_leave_element_last))
5748 Feld[x][y] = ei->move_leave_element;
5749 InitField(x, y, FALSE);
5751 if (GFX_CRUMBLED(Feld[x][y]))
5752 DrawLevelFieldCrumbledSandNeighbours(x, y);
5755 ei->can_leave_element_last = ei->can_leave_element;
5756 ei->can_leave_element = FALSE;
5760 /* 2.1.1 (does not work correctly for spring) */
5761 if (!CAN_MOVE(element))
5762 MovDir[newx][newy] = 0;
5766 /* (does not work for falling objects that slide horizontally) */
5767 if (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN)
5768 MovDir[newx][newy] = 0;
5771 if (!CAN_MOVE(element) ||
5772 (element == EL_SPRING && MovDir[newx][newy] == MV_DOWN))
5773 MovDir[newx][newy] = 0;
5776 if (!CAN_MOVE(element) ||
5777 (CAN_FALL(element) && direction == MV_DOWN))
5778 GfxDir[x][y] = MovDir[newx][newy] = 0;
5783 DrawLevelField(x, y);
5784 DrawLevelField(newx, newy);
5786 Stop[newx][newy] = TRUE; /* ignore this element until the next frame */
5788 /* prevent pushed element from moving on in pushed direction */
5789 if (pushed_by_player && CAN_MOVE(element) &&
5790 element_info[element].move_pattern & MV_ANY_DIRECTION &&
5791 !(element_info[element].move_pattern & direction))
5792 TurnRound(newx, newy);
5795 /* prevent elements on conveyor belt from moving on in last direction */
5796 if (pushed_by_conveyor && CAN_FALL(element) &&
5797 direction & MV_HORIZONTAL)
5798 MovDir[newx][newy] = 0;
5801 if (!pushed_by_player)
5803 WasJustMoving[newx][newy] = 3;
5805 if (CAN_FALL(element) && direction == MV_DOWN)
5806 WasJustFalling[newx][newy] = 3;
5809 if (DONT_TOUCH(element)) /* object may be nasty to player or others */
5811 TestIfBadThingTouchesHero(newx, newy);
5812 TestIfBadThingTouchesFriend(newx, newy);
5814 if (!IS_CUSTOM_ELEMENT(element))
5815 TestIfBadThingTouchesOtherBadThing(newx, newy);
5817 else if (element == EL_PENGUIN)
5818 TestIfFriendTouchesBadThing(newx, newy);
5820 if (CAN_FALL(element) && direction == MV_DOWN &&
5821 (newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
5825 TestIfElementTouchesCustomElement(x, y); /* empty or new element */
5829 if (ChangePage[newx][newy] != -1) /* delayed change */
5830 ChangeElement(newx, newy, ChangePage[newx][newy]);
5835 TestIfElementHitsCustomElement(newx, newy, direction);
5839 if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
5841 int hitting_element = Feld[newx][newy];
5843 /* !!! fix side (direction) orientation here and elsewhere !!! */
5844 CheckElementChangeSide(newx, newy, hitting_element, CE_HITTING_SOMETHING,
5848 if (IN_LEV_FIELD(nextx, nexty))
5850 int opposite_direction = MV_DIR_OPPOSITE(direction);
5851 int hitting_side = direction;
5852 int touched_side = opposite_direction;
5853 int touched_element = MovingOrBlocked2Element(nextx, nexty);
5854 boolean object_hit = (!IS_MOVING(nextx, nexty) ||
5855 MovDir[nextx][nexty] != direction ||
5856 ABS(MovPos[nextx][nexty]) <= TILEY / 2);
5862 CheckElementChangeSide(nextx, nexty, touched_element,
5863 CE_HIT_BY_SOMETHING, opposite_direction);
5865 if (IS_CUSTOM_ELEMENT(hitting_element) &&
5866 HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING))
5868 for (i = 0; i < element_info[hitting_element].num_change_pages; i++)
5870 struct ElementChangeInfo *change =
5871 &element_info[hitting_element].change_page[i];
5873 if (change->can_change &&
5874 change->events & CH_EVENT_BIT(CE_OTHER_IS_HITTING) &&
5875 change->trigger_side & touched_side &&
5876 change->trigger_element == touched_element)
5878 CheckElementChangePage(newx, newy, hitting_element,
5879 CE_OTHER_IS_HITTING, i);
5885 if (IS_CUSTOM_ELEMENT(touched_element) &&
5886 HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_HIT))
5888 for (i = 0; i < element_info[touched_element].num_change_pages; i++)
5890 struct ElementChangeInfo *change =
5891 &element_info[touched_element].change_page[i];
5893 if (change->can_change &&
5894 change->events & CH_EVENT_BIT(CE_OTHER_GETS_HIT) &&
5895 change->trigger_side & hitting_side &&
5896 change->trigger_element == hitting_element)
5898 CheckElementChangePage(nextx, nexty, touched_element,
5899 CE_OTHER_GETS_HIT, i);
5910 TestIfPlayerTouchesCustomElement(newx, newy);
5911 TestIfElementTouchesCustomElement(newx, newy);
5914 int AmoebeNachbarNr(int ax, int ay)
5917 int element = Feld[ax][ay];
5919 static int xy[4][2] =
5927 for (i = 0; i < NUM_DIRECTIONS; i++)
5929 int x = ax + xy[i][0];
5930 int y = ay + xy[i][1];
5932 if (!IN_LEV_FIELD(x, y))
5935 if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
5936 group_nr = AmoebaNr[x][y];
5942 void AmoebenVereinigen(int ax, int ay)
5944 int i, x, y, xx, yy;
5945 int new_group_nr = AmoebaNr[ax][ay];
5946 static int xy[4][2] =
5954 if (new_group_nr == 0)
5957 for (i = 0; i < NUM_DIRECTIONS; i++)
5962 if (!IN_LEV_FIELD(x, y))
5965 if ((Feld[x][y] == EL_AMOEBA_FULL ||
5966 Feld[x][y] == EL_BD_AMOEBA ||
5967 Feld[x][y] == EL_AMOEBA_DEAD) &&
5968 AmoebaNr[x][y] != new_group_nr)
5970 int old_group_nr = AmoebaNr[x][y];
5972 if (old_group_nr == 0)
5975 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
5976 AmoebaCnt[old_group_nr] = 0;
5977 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
5978 AmoebaCnt2[old_group_nr] = 0;
5980 for (yy = 0; yy < lev_fieldy; yy++)
5982 for (xx = 0; xx < lev_fieldx; xx++)
5984 if (AmoebaNr[xx][yy] == old_group_nr)
5985 AmoebaNr[xx][yy] = new_group_nr;
5992 void AmoebeUmwandeln(int ax, int ay)
5996 if (Feld[ax][ay] == EL_AMOEBA_DEAD)
5998 int group_nr = AmoebaNr[ax][ay];
6003 printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
6004 printf("AmoebeUmwandeln(): This should never happen!\n");
6009 for (y = 0; y < lev_fieldy; y++)
6011 for (x = 0; x < lev_fieldx; x++)
6013 if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
6016 Feld[x][y] = EL_AMOEBA_TO_DIAMOND;
6020 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
6021 SND_AMOEBA_TURNING_TO_GEM :
6022 SND_AMOEBA_TURNING_TO_ROCK));
6027 static int xy[4][2] =
6035 for (i = 0; i < NUM_DIRECTIONS; i++)
6040 if (!IN_LEV_FIELD(x, y))
6043 if (Feld[x][y] == EL_AMOEBA_TO_DIAMOND)
6045 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
6046 SND_AMOEBA_TURNING_TO_GEM :
6047 SND_AMOEBA_TURNING_TO_ROCK));
6054 void AmoebeUmwandelnBD(int ax, int ay, int new_element)
6057 int group_nr = AmoebaNr[ax][ay];
6058 boolean done = FALSE;
6063 printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
6064 printf("AmoebeUmwandelnBD(): This should never happen!\n");
6069 for (y = 0; y < lev_fieldy; y++)
6071 for (x = 0; x < lev_fieldx; x++)
6073 if (AmoebaNr[x][y] == group_nr &&
6074 (Feld[x][y] == EL_AMOEBA_DEAD ||
6075 Feld[x][y] == EL_BD_AMOEBA ||
6076 Feld[x][y] == EL_AMOEBA_GROWING))
6079 Feld[x][y] = new_element;
6080 InitField(x, y, FALSE);
6081 DrawLevelField(x, y);
6088 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
6089 SND_BD_AMOEBA_TURNING_TO_ROCK :
6090 SND_BD_AMOEBA_TURNING_TO_GEM));
6093 void AmoebeWaechst(int x, int y)
6095 static unsigned long sound_delay = 0;
6096 static unsigned long sound_delay_value = 0;
6098 if (!MovDelay[x][y]) /* start new growing cycle */
6102 if (DelayReached(&sound_delay, sound_delay_value))
6105 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
6107 if (Store[x][y] == EL_BD_AMOEBA)
6108 PlayLevelSound(x, y, SND_BD_AMOEBA_GROWING);
6110 PlayLevelSound(x, y, SND_AMOEBA_GROWING);
6112 sound_delay_value = 30;
6116 if (MovDelay[x][y]) /* wait some time before growing bigger */
6119 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6121 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
6122 6 - MovDelay[x][y]);
6124 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
6127 if (!MovDelay[x][y])
6129 Feld[x][y] = Store[x][y];
6131 DrawLevelField(x, y);
6136 void AmoebaDisappearing(int x, int y)
6138 static unsigned long sound_delay = 0;
6139 static unsigned long sound_delay_value = 0;
6141 if (!MovDelay[x][y]) /* start new shrinking cycle */
6145 if (DelayReached(&sound_delay, sound_delay_value))
6146 sound_delay_value = 30;
6149 if (MovDelay[x][y]) /* wait some time before shrinking */
6152 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6154 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
6155 6 - MovDelay[x][y]);
6157 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
6160 if (!MovDelay[x][y])
6162 Feld[x][y] = EL_EMPTY;
6163 DrawLevelField(x, y);
6165 /* don't let mole enter this field in this cycle;
6166 (give priority to objects falling to this field from above) */
6172 void AmoebeAbleger(int ax, int ay)
6175 int element = Feld[ax][ay];
6176 int graphic = el2img(element);
6177 int newax = ax, neway = ay;
6178 static int xy[4][2] =
6186 if (!level.amoeba_speed)
6188 Feld[ax][ay] = EL_AMOEBA_DEAD;
6189 DrawLevelField(ax, ay);
6193 if (IS_ANIMATED(graphic))
6194 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6196 if (!MovDelay[ax][ay]) /* start making new amoeba field */
6197 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
6199 if (MovDelay[ax][ay]) /* wait some time before making new amoeba */
6202 if (MovDelay[ax][ay])
6206 if (element == EL_AMOEBA_WET) /* object is an acid / amoeba drop */
6209 int x = ax + xy[start][0];
6210 int y = ay + xy[start][1];
6212 if (!IN_LEV_FIELD(x, y))
6215 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6216 if (IS_FREE(x, y) ||
6217 Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
6223 if (newax == ax && neway == ay)
6226 else /* normal or "filled" (BD style) amoeba */
6229 boolean waiting_for_player = FALSE;
6231 for (i = 0; i < NUM_DIRECTIONS; i++)
6233 int j = (start + i) % 4;
6234 int x = ax + xy[j][0];
6235 int y = ay + xy[j][1];
6237 if (!IN_LEV_FIELD(x, y))
6240 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6241 if (IS_FREE(x, y) ||
6242 Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
6248 else if (IS_PLAYER(x, y))
6249 waiting_for_player = TRUE;
6252 if (newax == ax && neway == ay) /* amoeba cannot grow */
6254 if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
6256 Feld[ax][ay] = EL_AMOEBA_DEAD;
6257 DrawLevelField(ax, ay);
6258 AmoebaCnt[AmoebaNr[ax][ay]]--;
6260 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) /* amoeba is completely dead */
6262 if (element == EL_AMOEBA_FULL)
6263 AmoebeUmwandeln(ax, ay);
6264 else if (element == EL_BD_AMOEBA)
6265 AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
6270 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
6272 /* amoeba gets larger by growing in some direction */
6274 int new_group_nr = AmoebaNr[ax][ay];
6277 if (new_group_nr == 0)
6279 printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
6280 printf("AmoebeAbleger(): This should never happen!\n");
6285 AmoebaNr[newax][neway] = new_group_nr;
6286 AmoebaCnt[new_group_nr]++;
6287 AmoebaCnt2[new_group_nr]++;
6289 /* if amoeba touches other amoeba(s) after growing, unify them */
6290 AmoebenVereinigen(newax, neway);
6292 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
6294 AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
6300 if (element != EL_AMOEBA_WET || neway < ay || !IS_FREE(newax, neway) ||
6301 (neway == lev_fieldy - 1 && newax != ax))
6303 Feld[newax][neway] = EL_AMOEBA_GROWING; /* creation of new amoeba */
6304 Store[newax][neway] = element;
6306 else if (neway == ay)
6308 Feld[newax][neway] = EL_AMOEBA_DROP; /* drop left/right of amoeba */
6310 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
6312 PlayLevelSound(newax, neway, SND_AMOEBA_GROWING);
6317 InitMovingField(ax, ay, MV_DOWN); /* drop dripping from amoeba */
6318 Feld[ax][ay] = EL_AMOEBA_DROPPING;
6319 Store[ax][ay] = EL_AMOEBA_DROP;
6320 ContinueMoving(ax, ay);
6324 DrawLevelField(newax, neway);
6327 void Life(int ax, int ay)
6330 static int life[4] = { 2, 3, 3, 3 }; /* parameters for "game of life" */
6332 int element = Feld[ax][ay];
6333 int graphic = el2img(element);
6334 boolean changed = FALSE;
6336 if (IS_ANIMATED(graphic))
6337 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6342 if (!MovDelay[ax][ay]) /* start new "game of life" cycle */
6343 MovDelay[ax][ay] = life_time;
6345 if (MovDelay[ax][ay]) /* wait some time before next cycle */
6348 if (MovDelay[ax][ay])
6352 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
6354 int xx = ax+x1, yy = ay+y1;
6357 if (!IN_LEV_FIELD(xx, yy))
6360 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
6362 int x = xx+x2, y = yy+y2;
6364 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
6367 if (((Feld[x][y] == element ||
6368 (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y))) &&
6370 (IS_FREE(x, y) && Stop[x][y]))
6374 if (xx == ax && yy == ay) /* field in the middle */
6376 if (nachbarn < life[0] || nachbarn > life[1])
6378 Feld[xx][yy] = EL_EMPTY;
6380 DrawLevelField(xx, yy);
6381 Stop[xx][yy] = TRUE;
6385 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6386 else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_SAND)
6387 { /* free border field */
6388 if (nachbarn >= life[2] && nachbarn <= life[3])
6390 Feld[xx][yy] = element;
6391 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
6393 DrawLevelField(xx, yy);
6394 Stop[xx][yy] = TRUE;
6401 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
6402 SND_GAME_OF_LIFE_GROWING);
6405 static void InitRobotWheel(int x, int y)
6407 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
6410 static void RunRobotWheel(int x, int y)
6412 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
6415 static void StopRobotWheel(int x, int y)
6417 if (ZX == x && ZY == y)
6421 static void InitTimegateWheel(int x, int y)
6423 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
6426 static void RunTimegateWheel(int x, int y)
6428 PlayLevelSound(x, y, SND_TIMEGATE_SWITCH_ACTIVE);
6431 void CheckExit(int x, int y)
6433 if (local_player->gems_still_needed > 0 ||
6434 local_player->sokobanfields_still_needed > 0 ||
6435 local_player->lights_still_needed > 0)
6437 int element = Feld[x][y];
6438 int graphic = el2img(element);
6440 if (IS_ANIMATED(graphic))
6441 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6446 if (AllPlayersGone) /* do not re-open exit door closed after last player */
6449 Feld[x][y] = EL_EXIT_OPENING;
6451 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
6454 void CheckExitSP(int x, int y)
6456 if (local_player->gems_still_needed > 0)
6458 int element = Feld[x][y];
6459 int graphic = el2img(element);
6461 if (IS_ANIMATED(graphic))
6462 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6467 if (AllPlayersGone) /* do not re-open exit door closed after last player */
6470 Feld[x][y] = EL_SP_EXIT_OPENING;
6472 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
6475 static void CloseAllOpenTimegates()
6479 for (y = 0; y < lev_fieldy; y++)
6481 for (x = 0; x < lev_fieldx; x++)
6483 int element = Feld[x][y];
6485 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
6487 Feld[x][y] = EL_TIMEGATE_CLOSING;
6489 PlayLevelSoundAction(x, y, ACTION_CLOSING);
6491 PlayLevelSound(x, y, SND_TIMEGATE_CLOSING);
6498 void EdelsteinFunkeln(int x, int y)
6500 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
6503 if (Feld[x][y] == EL_BD_DIAMOND)
6506 if (MovDelay[x][y] == 0) /* next animation frame */
6507 MovDelay[x][y] = 11 * !SimpleRND(500);
6509 if (MovDelay[x][y] != 0) /* wait some time before next frame */
6513 if (setup.direct_draw && MovDelay[x][y])
6514 SetDrawtoField(DRAW_BUFFERED);
6516 DrawLevelElementAnimation(x, y, Feld[x][y]);
6518 if (MovDelay[x][y] != 0)
6520 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
6521 10 - MovDelay[x][y]);
6523 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
6525 if (setup.direct_draw)
6529 dest_x = FX + SCREENX(x) * TILEX;
6530 dest_y = FY + SCREENY(y) * TILEY;
6532 BlitBitmap(drawto_field, window,
6533 dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
6534 SetDrawtoField(DRAW_DIRECT);
6540 void MauerWaechst(int x, int y)
6544 if (!MovDelay[x][y]) /* next animation frame */
6545 MovDelay[x][y] = 3 * delay;
6547 if (MovDelay[x][y]) /* wait some time before next frame */
6551 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6553 int graphic = el_dir2img(Feld[x][y], GfxDir[x][y]);
6554 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
6556 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6559 if (!MovDelay[x][y])
6561 if (MovDir[x][y] == MV_LEFT)
6563 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
6564 DrawLevelField(x - 1, y);
6566 else if (MovDir[x][y] == MV_RIGHT)
6568 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y]))
6569 DrawLevelField(x + 1, y);
6571 else if (MovDir[x][y] == MV_UP)
6573 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
6574 DrawLevelField(x, y - 1);
6578 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
6579 DrawLevelField(x, y + 1);
6582 Feld[x][y] = Store[x][y];
6584 GfxDir[x][y] = MovDir[x][y] = MV_NO_MOVING;
6585 DrawLevelField(x, y);
6590 void MauerAbleger(int ax, int ay)
6592 int element = Feld[ax][ay];
6593 int graphic = el2img(element);
6594 boolean oben_frei = FALSE, unten_frei = FALSE;
6595 boolean links_frei = FALSE, rechts_frei = FALSE;
6596 boolean oben_massiv = FALSE, unten_massiv = FALSE;
6597 boolean links_massiv = FALSE, rechts_massiv = FALSE;
6598 boolean new_wall = FALSE;
6600 if (IS_ANIMATED(graphic))
6601 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6603 if (!MovDelay[ax][ay]) /* start building new wall */
6604 MovDelay[ax][ay] = 6;
6606 if (MovDelay[ax][ay]) /* wait some time before building new wall */
6609 if (MovDelay[ax][ay])
6613 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
6615 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
6617 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
6619 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
6622 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
6623 element == EL_EXPANDABLE_WALL_ANY)
6627 Feld[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
6628 Store[ax][ay-1] = element;
6629 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
6630 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
6631 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
6632 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
6637 Feld[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
6638 Store[ax][ay+1] = element;
6639 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
6640 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
6641 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
6642 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
6647 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6648 element == EL_EXPANDABLE_WALL_ANY ||
6649 element == EL_EXPANDABLE_WALL)
6653 Feld[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
6654 Store[ax-1][ay] = element;
6655 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
6656 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
6657 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
6658 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
6664 Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
6665 Store[ax+1][ay] = element;
6666 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
6667 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
6668 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
6669 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
6674 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
6675 DrawLevelField(ax, ay);
6677 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
6679 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
6680 unten_massiv = TRUE;
6681 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
6682 links_massiv = TRUE;
6683 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
6684 rechts_massiv = TRUE;
6686 if (((oben_massiv && unten_massiv) ||
6687 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6688 element == EL_EXPANDABLE_WALL) &&
6689 ((links_massiv && rechts_massiv) ||
6690 element == EL_EXPANDABLE_WALL_VERTICAL))
6691 Feld[ax][ay] = EL_WALL;
6695 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
6697 PlayLevelSound(ax, ay, SND_EXPANDABLE_WALL_GROWING);
6701 void CheckForDragon(int x, int y)
6704 boolean dragon_found = FALSE;
6705 static int xy[4][2] =
6713 for (i = 0; i < NUM_DIRECTIONS; i++)
6715 for (j = 0; j < 4; j++)
6717 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
6719 if (IN_LEV_FIELD(xx, yy) &&
6720 (Feld[xx][yy] == EL_FLAMES || Feld[xx][yy] == EL_DRAGON))
6722 if (Feld[xx][yy] == EL_DRAGON)
6723 dragon_found = TRUE;
6732 for (i = 0; i < NUM_DIRECTIONS; i++)
6734 for (j = 0; j < 3; j++)
6736 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
6738 if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES)
6740 Feld[xx][yy] = EL_EMPTY;
6741 DrawLevelField(xx, yy);
6750 static void InitBuggyBase(int x, int y)
6752 int element = Feld[x][y];
6753 int activating_delay = FRAMES_PER_SECOND / 4;
6756 (element == EL_SP_BUGGY_BASE ?
6757 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
6758 element == EL_SP_BUGGY_BASE_ACTIVATING ?
6760 element == EL_SP_BUGGY_BASE_ACTIVE ?
6761 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
6764 static void WarnBuggyBase(int x, int y)
6767 static int xy[4][2] =
6775 for (i = 0; i < NUM_DIRECTIONS; i++)
6777 int xx = x + xy[i][0], yy = y + xy[i][1];
6779 if (IS_PLAYER(xx, yy))
6781 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
6788 static void InitTrap(int x, int y)
6790 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
6793 static void ActivateTrap(int x, int y)
6795 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
6798 static void ChangeActiveTrap(int x, int y)
6800 int graphic = IMG_TRAP_ACTIVE;
6802 /* if new animation frame was drawn, correct crumbled sand border */
6803 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
6804 DrawLevelFieldCrumbledSand(x, y);
6807 static void ChangeElementNowExt(int x, int y, int target_element)
6809 int previous_move_direction = MovDir[x][y];
6811 /* check if element under player changes from accessible to unaccessible
6812 (needed for special case of dropping element which then changes) */
6813 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) &&
6814 IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
6821 Feld[x][y] = target_element;
6823 Changed[x][y] |= ChangeEvent[x][y]; /* ignore same changes in this frame */
6825 ResetGfxAnimation(x, y);
6826 ResetRandomAnimationValue(x, y);
6828 if (element_info[Feld[x][y]].move_direction_initial == MV_START_PREVIOUS)
6829 MovDir[x][y] = previous_move_direction;
6832 InitField_WithBug1(x, y, FALSE);
6834 InitField(x, y, FALSE);
6835 if (CAN_MOVE(Feld[x][y]))
6839 DrawLevelField(x, y);
6841 if (GFX_CRUMBLED(Feld[x][y]))
6842 DrawLevelFieldCrumbledSandNeighbours(x, y);
6844 TestIfBadThingTouchesHero(x, y);
6845 TestIfPlayerTouchesCustomElement(x, y);
6846 TestIfElementTouchesCustomElement(x, y);
6848 if (ELEM_IS_PLAYER(target_element))
6849 RelocatePlayer(x, y, target_element);
6852 static boolean ChangeElementNow(int x, int y, int element, int page)
6854 struct ElementChangeInfo *change = &element_info[element].change_page[page];
6856 /* always use default change event to prevent running into a loop */
6857 if (ChangeEvent[x][y] == CE_BITMASK_DEFAULT)
6858 ChangeEvent[x][y] = CH_EVENT_BIT(CE_DELAY);
6860 /* do not change already changed elements with same change event */
6862 if (Changed[x][y] & ChangeEvent[x][y])
6869 Changed[x][y] |= ChangeEvent[x][y]; /* ignore same changes in this frame */
6871 CheckTriggeredElementChangePage(x,y, Feld[x][y], CE_OTHER_IS_CHANGING, page);
6873 if (change->explode)
6880 if (change->use_content)
6882 boolean complete_change = TRUE;
6883 boolean can_change[3][3];
6886 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
6888 boolean half_destructible;
6889 int ex = x + xx - 1;
6890 int ey = y + yy - 1;
6893 can_change[xx][yy] = TRUE;
6895 if (ex == x && ey == y) /* do not check changing element itself */
6898 if (change->content[xx][yy] == EL_EMPTY_SPACE)
6900 can_change[xx][yy] = FALSE; /* do not change empty borders */
6905 if (!IN_LEV_FIELD(ex, ey))
6907 can_change[xx][yy] = FALSE;
6908 complete_change = FALSE;
6915 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
6916 e = MovingOrBlocked2Element(ex, ey);
6918 half_destructible = (IS_FREE(ex, ey) || IS_DIGGABLE(e));
6920 if ((change->power <= CP_NON_DESTRUCTIVE && !IS_FREE(ex, ey)) ||
6921 (change->power <= CP_HALF_DESTRUCTIVE && !half_destructible) ||
6922 (change->power <= CP_FULL_DESTRUCTIVE && IS_INDESTRUCTIBLE(e)))
6924 can_change[xx][yy] = FALSE;
6925 complete_change = FALSE;
6929 if (!change->only_complete || complete_change)
6931 boolean something_has_changed = FALSE;
6933 if (change->only_complete && change->use_random_change &&
6934 RND(100) < change->random)
6937 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
6939 int ex = x + xx - 1;
6940 int ey = y + yy - 1;
6942 if (can_change[xx][yy] && (!change->use_random_change ||
6943 RND(100) < change->random))
6945 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
6946 RemoveMovingField(ex, ey);
6948 ChangeEvent[ex][ey] = ChangeEvent[x][y];
6950 ChangeElementNowExt(ex, ey, change->content[xx][yy]);
6952 something_has_changed = TRUE;
6954 /* for symmetry reasons, freeze newly created border elements */
6955 if (ex != x || ey != y)
6956 Stop[ex][ey] = TRUE; /* no more moving in this frame */
6960 if (something_has_changed)
6961 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
6966 ChangeElementNowExt(x, y, change->target_element);
6968 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
6974 static void ChangeElement(int x, int y, int page)
6976 int element = MovingOrBlocked2Element(x, y);
6977 struct ElementInfo *ei = &element_info[element];
6978 struct ElementChangeInfo *change = &ei->change_page[page];
6982 if (!CAN_CHANGE(element))
6985 printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
6986 x, y, element, element_info[element].token_name);
6987 printf("ChangeElement(): This should never happen!\n");
6993 if (ChangeDelay[x][y] == 0) /* initialize element change */
6995 ChangeDelay[x][y] = ( change->delay_fixed * change->delay_frames +
6996 RND(change->delay_random * change->delay_frames)) + 1;
6998 ResetGfxAnimation(x, y);
6999 ResetRandomAnimationValue(x, y);
7001 if (change->pre_change_function)
7002 change->pre_change_function(x, y);
7005 ChangeDelay[x][y]--;
7007 if (ChangeDelay[x][y] != 0) /* continue element change */
7009 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7011 if (IS_ANIMATED(graphic))
7012 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7014 if (change->change_function)
7015 change->change_function(x, y);
7017 else /* finish element change */
7019 if (ChangePage[x][y] != -1) /* remember page from delayed change */
7021 page = ChangePage[x][y];
7022 ChangePage[x][y] = -1;
7026 if (IS_MOVING(x, y) && !change->explode)
7028 if (IS_MOVING(x, y)) /* never change a running system ;-) */
7031 ChangeDelay[x][y] = 1; /* try change after next move step */
7032 ChangePage[x][y] = page; /* remember page to use for change */
7037 if (ChangeElementNow(x, y, element, page))
7039 if (change->post_change_function)
7040 change->post_change_function(x, y);
7045 static boolean CheckTriggeredElementChangeExt(int lx, int ly,
7046 int trigger_element,
7054 if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
7057 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7059 int element = EL_CUSTOM_START + i;
7061 boolean change_element = FALSE;
7064 if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7067 for (j = 0; j < element_info[element].num_change_pages; j++)
7069 struct ElementChangeInfo *change = &element_info[element].change_page[j];
7071 if (change->can_change &&
7072 change->events & CH_EVENT_BIT(trigger_event) &&
7073 change->trigger_side & trigger_side &&
7074 change->trigger_player & trigger_player &&
7075 change->trigger_page & (1 << trigger_page) &&
7076 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
7079 if (!(change->events & CH_EVENT_BIT(trigger_event)))
7080 printf("::: !!! %d triggers %d: using wrong page %d [event %d]\n",
7081 trigger_element-EL_CUSTOM_START+1, i+1, j, trigger_event);
7084 change_element = TRUE;
7091 if (!change_element)
7094 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7097 if (x == lx && y == ly) /* do not change trigger element itself */
7101 if (Feld[x][y] == element)
7103 ChangeDelay[x][y] = 1;
7104 ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
7105 ChangeElement(x, y, page);
7113 static boolean CheckElementChangeExt(int x, int y,
7120 if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7123 if (Feld[x][y] == EL_BLOCKED)
7125 Blocked2Moving(x, y, &x, &y);
7126 element = Feld[x][y];
7130 if (trigger_page < 0)
7132 boolean change_element = FALSE;
7135 for (i = 0; i < element_info[element].num_change_pages; i++)
7137 struct ElementChangeInfo *change = &element_info[element].change_page[i];
7139 if (change->can_change &&
7140 change->events & CH_EVENT_BIT(trigger_event) &&
7141 change->trigger_side & trigger_side &&
7142 change->trigger_player & trigger_player)
7144 change_element = TRUE;
7151 if (!change_element)
7157 /* !!! this check misses pages with same event, but different side !!! */
7159 if (trigger_page < 0)
7160 trigger_page = element_info[element].event_page_nr[trigger_event];
7162 if (!(element_info[element].change_page[trigger_page].trigger_side & trigger_side))
7166 ChangeDelay[x][y] = 1;
7167 ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
7168 ChangeElement(x, y, trigger_page);
7173 static void PlayPlayerSound(struct PlayerInfo *player)
7175 int jx = player->jx, jy = player->jy;
7176 int element = player->element_nr;
7177 int last_action = player->last_action_waiting;
7178 int action = player->action_waiting;
7180 if (player->is_waiting)
7182 if (action != last_action)
7183 PlayLevelSoundElementAction(jx, jy, element, action);
7185 PlayLevelSoundElementActionIfLoop(jx, jy, element, action);
7189 if (action != last_action)
7190 StopSound(element_info[element].sound[last_action]);
7192 if (last_action == ACTION_SLEEPING)
7193 PlayLevelSoundElementAction(jx, jy, element, ACTION_AWAKENING);
7197 static void PlayAllPlayersSound()
7201 for (i = 0; i < MAX_PLAYERS; i++)
7202 if (stored_player[i].active)
7203 PlayPlayerSound(&stored_player[i]);
7206 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
7208 boolean last_waiting = player->is_waiting;
7209 int move_dir = player->MovDir;
7211 player->last_action_waiting = player->action_waiting;
7215 if (!last_waiting) /* not waiting -> waiting */
7217 player->is_waiting = TRUE;
7219 player->frame_counter_bored =
7221 game.player_boring_delay_fixed +
7222 SimpleRND(game.player_boring_delay_random);
7223 player->frame_counter_sleeping =
7225 game.player_sleeping_delay_fixed +
7226 SimpleRND(game.player_sleeping_delay_random);
7228 InitPlayerGfxAnimation(player, ACTION_WAITING, player->MovDir);
7231 if (game.player_sleeping_delay_fixed +
7232 game.player_sleeping_delay_random > 0 &&
7233 player->anim_delay_counter == 0 &&
7234 player->post_delay_counter == 0 &&
7235 FrameCounter >= player->frame_counter_sleeping)
7236 player->is_sleeping = TRUE;
7237 else if (game.player_boring_delay_fixed +
7238 game.player_boring_delay_random > 0 &&
7239 FrameCounter >= player->frame_counter_bored)
7240 player->is_bored = TRUE;
7242 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
7243 player->is_bored ? ACTION_BORING :
7246 if (player->is_sleeping)
7248 if (player->num_special_action_sleeping > 0)
7250 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7252 int last_special_action = player->special_action_sleeping;
7253 int num_special_action = player->num_special_action_sleeping;
7254 int special_action =
7255 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
7256 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
7257 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
7258 last_special_action + 1 : ACTION_SLEEPING);
7259 int special_graphic =
7260 el_act_dir2img(player->element_nr, special_action, move_dir);
7262 player->anim_delay_counter =
7263 graphic_info[special_graphic].anim_delay_fixed +
7264 SimpleRND(graphic_info[special_graphic].anim_delay_random);
7265 player->post_delay_counter =
7266 graphic_info[special_graphic].post_delay_fixed +
7267 SimpleRND(graphic_info[special_graphic].post_delay_random);
7269 player->special_action_sleeping = special_action;
7272 if (player->anim_delay_counter > 0)
7274 player->action_waiting = player->special_action_sleeping;
7275 player->anim_delay_counter--;
7277 else if (player->post_delay_counter > 0)
7279 player->post_delay_counter--;
7283 else if (player->is_bored)
7285 if (player->num_special_action_bored > 0)
7287 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7289 int special_action =
7290 ACTION_BORING_1 + SimpleRND(player->num_special_action_bored);
7291 int special_graphic =
7292 el_act_dir2img(player->element_nr, special_action, move_dir);
7294 player->anim_delay_counter =
7295 graphic_info[special_graphic].anim_delay_fixed +
7296 SimpleRND(graphic_info[special_graphic].anim_delay_random);
7297 player->post_delay_counter =
7298 graphic_info[special_graphic].post_delay_fixed +
7299 SimpleRND(graphic_info[special_graphic].post_delay_random);
7301 player->special_action_bored = special_action;
7304 if (player->anim_delay_counter > 0)
7306 player->action_waiting = player->special_action_bored;
7307 player->anim_delay_counter--;
7309 else if (player->post_delay_counter > 0)
7311 player->post_delay_counter--;
7316 else if (last_waiting) /* waiting -> not waiting */
7318 player->is_waiting = FALSE;
7319 player->is_bored = FALSE;
7320 player->is_sleeping = FALSE;
7322 player->frame_counter_bored = -1;
7323 player->frame_counter_sleeping = -1;
7325 player->anim_delay_counter = 0;
7326 player->post_delay_counter = 0;
7328 player->action_waiting = ACTION_DEFAULT;
7330 player->special_action_bored = ACTION_DEFAULT;
7331 player->special_action_sleeping = ACTION_DEFAULT;
7336 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
7339 static byte stored_player_action[MAX_PLAYERS];
7340 static int num_stored_actions = 0;
7342 boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
7343 int left = player_action & JOY_LEFT;
7344 int right = player_action & JOY_RIGHT;
7345 int up = player_action & JOY_UP;
7346 int down = player_action & JOY_DOWN;
7347 int button1 = player_action & JOY_BUTTON_1;
7348 int button2 = player_action & JOY_BUTTON_2;
7349 int dx = (left ? -1 : right ? 1 : 0);
7350 int dy = (up ? -1 : down ? 1 : 0);
7353 stored_player_action[player->index_nr] = 0;
7354 num_stored_actions++;
7358 printf("::: player %d [%d]\n", player->index_nr, FrameCounter);
7361 if (!player->active || tape.pausing)
7365 printf("::: [%d %d %d %d] [%d %d]\n",
7366 left, right, up, down, button1, button2);
7372 printf("::: player %d acts [%d]\n", player->index_nr, FrameCounter);
7377 if (player->MovPos == 0)
7378 CheckGravityMovement(player);
7381 snapped = SnapField(player, dx, dy);
7385 dropped = DropElement(player);
7387 moved = MovePlayer(player, dx, dy);
7390 if (tape.single_step && tape.recording && !tape.pausing)
7392 if (button1 || (dropped && !moved))
7394 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
7395 SnapField(player, 0, 0); /* stop snapping */
7399 SetPlayerWaiting(player, FALSE);
7402 return player_action;
7404 stored_player_action[player->index_nr] = player_action;
7410 printf("::: player %d waits [%d]\n", player->index_nr, FrameCounter);
7413 /* no actions for this player (no input at player's configured device) */
7415 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
7416 SnapField(player, 0, 0);
7417 CheckGravityMovementWhenNotMoving(player);
7419 if (player->MovPos == 0)
7420 SetPlayerWaiting(player, TRUE);
7422 if (player->MovPos == 0) /* needed for tape.playing */
7423 player->is_moving = FALSE;
7425 player->is_dropping = FALSE;
7431 if (tape.recording && num_stored_actions >= MAX_PLAYERS)
7433 printf("::: player %d recorded [%d]\n", player->index_nr, FrameCounter);
7435 TapeRecordAction(stored_player_action);
7436 num_stored_actions = 0;
7443 static void PlayerActions(struct PlayerInfo *player, byte player_action)
7445 static byte stored_player_action[MAX_PLAYERS];
7446 static int num_stored_actions = 0;
7447 boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
7448 int left = player_action & JOY_LEFT;
7449 int right = player_action & JOY_RIGHT;
7450 int up = player_action & JOY_UP;
7451 int down = player_action & JOY_DOWN;
7452 int button1 = player_action & JOY_BUTTON_1;
7453 int button2 = player_action & JOY_BUTTON_2;
7454 int dx = (left ? -1 : right ? 1 : 0);
7455 int dy = (up ? -1 : down ? 1 : 0);
7457 stored_player_action[player->index_nr] = 0;
7458 num_stored_actions++;
7460 printf("::: player %d [%d]\n", player->index_nr, FrameCounter);
7462 if (!player->active || tape.pausing)
7467 printf("::: player %d acts [%d]\n", player->index_nr, FrameCounter);
7470 snapped = SnapField(player, dx, dy);
7474 dropped = DropElement(player);
7476 moved = MovePlayer(player, dx, dy);
7479 if (tape.single_step && tape.recording && !tape.pausing)
7481 if (button1 || (dropped && !moved))
7483 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
7484 SnapField(player, 0, 0); /* stop snapping */
7488 stored_player_action[player->index_nr] = player_action;
7492 printf("::: player %d waits [%d]\n", player->index_nr, FrameCounter);
7494 /* no actions for this player (no input at player's configured device) */
7496 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
7497 SnapField(player, 0, 0);
7498 CheckGravityMovementWhenNotMoving(player);
7500 if (player->MovPos == 0)
7501 InitPlayerGfxAnimation(player, ACTION_DEFAULT, player->MovDir);
7503 if (player->MovPos == 0) /* needed for tape.playing */
7504 player->is_moving = FALSE;
7507 if (tape.recording && num_stored_actions >= MAX_PLAYERS)
7509 printf("::: player %d recorded [%d]\n", player->index_nr, FrameCounter);
7511 TapeRecordAction(stored_player_action);
7512 num_stored_actions = 0;
7519 static unsigned long action_delay = 0;
7520 unsigned long action_delay_value;
7521 int magic_wall_x = 0, magic_wall_y = 0;
7522 int i, x, y, element, graphic;
7523 byte *recorded_player_action;
7524 byte summarized_player_action = 0;
7526 byte tape_action[MAX_PLAYERS];
7529 if (game_status != GAME_MODE_PLAYING)
7532 action_delay_value =
7533 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
7535 if (tape.playing && tape.index_search && !tape.pausing)
7536 action_delay_value = 0;
7538 /* ---------- main game synchronization point ---------- */
7540 WaitUntilDelayReached(&action_delay, action_delay_value);
7542 if (network_playing && !network_player_action_received)
7546 printf("DEBUG: try to get network player actions in time\n");
7550 #if defined(PLATFORM_UNIX)
7551 /* last chance to get network player actions without main loop delay */
7555 if (game_status != GAME_MODE_PLAYING)
7558 if (!network_player_action_received)
7562 printf("DEBUG: failed to get network player actions in time\n");
7573 printf("::: getting new tape action [%d]\n", FrameCounter);
7576 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
7579 if (recorded_player_action == NULL && tape.pausing)
7584 printf("::: %d\n", stored_player[0].action);
7588 if (recorded_player_action != NULL)
7589 for (i = 0; i < MAX_PLAYERS; i++)
7590 stored_player[i].action = recorded_player_action[i];
7593 for (i = 0; i < MAX_PLAYERS; i++)
7595 summarized_player_action |= stored_player[i].action;
7597 if (!network_playing)
7598 stored_player[i].effective_action = stored_player[i].action;
7601 #if defined(PLATFORM_UNIX)
7602 if (network_playing)
7603 SendToServer_MovePlayer(summarized_player_action);
7606 if (!options.network && !setup.team_mode)
7607 local_player->effective_action = summarized_player_action;
7610 if (recorded_player_action != NULL)
7611 for (i = 0; i < MAX_PLAYERS; i++)
7612 stored_player[i].effective_action = recorded_player_action[i];
7616 for (i = 0; i < MAX_PLAYERS; i++)
7618 tape_action[i] = stored_player[i].effective_action;
7620 if (tape.recording && tape_action[i] && !tape.player_participates[i])
7621 tape.player_participates[i] = TRUE; /* player just appeared from CE */
7624 /* only save actions from input devices, but not programmed actions */
7626 TapeRecordAction(tape_action);
7629 for (i = 0; i < MAX_PLAYERS; i++)
7631 int actual_player_action = stored_player[i].effective_action;
7634 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
7635 - rnd_equinox_tetrachloride 048
7636 - rnd_equinox_tetrachloride_ii 096
7637 - rnd_emanuel_schmieg 002
7638 - doctor_sloan_ww 001, 020
7640 if (stored_player[i].MovPos == 0)
7641 CheckGravityMovement(&stored_player[i]);
7645 /* overwrite programmed action with tape action */
7646 if (stored_player[i].programmed_action)
7647 actual_player_action = stored_player[i].programmed_action;
7651 if (stored_player[i].programmed_action)
7652 printf("::: %d\n", stored_player[i].programmed_action);
7655 if (recorded_player_action)
7658 if (stored_player[i].programmed_action &&
7659 stored_player[i].programmed_action != recorded_player_action[i])
7660 printf("::: %d: %d <-> %d\n", i,
7661 stored_player[i].programmed_action, recorded_player_action[i]);
7665 actual_player_action = recorded_player_action[i];
7670 /* overwrite tape action with programmed action */
7671 if (stored_player[i].programmed_action)
7672 actual_player_action = stored_player[i].programmed_action;
7677 printf("::: action: %d: %x [%d]\n",
7678 stored_player[i].MovPos, actual_player_action, FrameCounter);
7682 PlayerActions(&stored_player[i], actual_player_action);
7684 tape_action[i] = PlayerActions(&stored_player[i], actual_player_action);
7686 if (tape.recording && tape_action[i] && !tape.player_participates[i])
7687 tape.player_participates[i] = TRUE; /* player just appeared from CE */
7690 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
7695 TapeRecordAction(tape_action);
7698 network_player_action_received = FALSE;
7700 ScrollScreen(NULL, SCROLL_GO_ON);
7706 for (i = 0; i < MAX_PLAYERS; i++)
7707 stored_player[i].Frame++;
7711 /* for downwards compatibility, the following code emulates a fixed bug that
7712 occured when pushing elements (causing elements that just made their last
7713 pushing step to already (if possible) make their first falling step in the
7714 same game frame, which is bad); this code is also needed to use the famous
7715 "spring push bug" which is used in older levels and might be wanted to be
7716 used also in newer levels, but in this case the buggy pushing code is only
7717 affecting the "spring" element and no other elements */
7720 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
7722 if (game.engine_version < VERSION_IDENT(2,2,0,7))
7725 for (i = 0; i < MAX_PLAYERS; i++)
7727 struct PlayerInfo *player = &stored_player[i];
7732 if (player->active && player->is_pushing && player->is_moving &&
7734 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
7735 Feld[x][y] == EL_SPRING))
7737 if (player->active && player->is_pushing && player->is_moving &&
7741 ContinueMoving(x, y);
7743 /* continue moving after pushing (this is actually a bug) */
7744 if (!IS_MOVING(x, y))
7753 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7755 Changed[x][y] = CE_BITMASK_DEFAULT;
7756 ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
7759 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
7761 printf("GameActions(): x = %d, y = %d: ChangePage != -1\n", x, y);
7762 printf("GameActions(): This should never happen!\n");
7764 ChangePage[x][y] = -1;
7769 if (WasJustMoving[x][y] > 0)
7770 WasJustMoving[x][y]--;
7771 if (WasJustFalling[x][y] > 0)
7772 WasJustFalling[x][y]--;
7777 /* reset finished pushing action (not done in ContinueMoving() to allow
7778 continous pushing animation for elements with zero push delay) */
7779 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
7781 ResetGfxAnimation(x, y);
7782 DrawLevelField(x, y);
7787 if (IS_BLOCKED(x, y))
7791 Blocked2Moving(x, y, &oldx, &oldy);
7792 if (!IS_MOVING(oldx, oldy))
7794 printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
7795 printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
7796 printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
7797 printf("GameActions(): This should never happen!\n");
7803 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7805 element = Feld[x][y];
7807 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7809 graphic = el2img(element);
7815 printf("::: %d,%d: %d [%d]\n", x, y, element, FrameCounter);
7817 element = graphic = 0;
7821 if (graphic_info[graphic].anim_global_sync)
7822 GfxFrame[x][y] = FrameCounter;
7824 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
7825 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
7826 ResetRandomAnimationValue(x, y);
7828 SetRandomAnimationValue(x, y);
7831 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
7834 if (IS_INACTIVE(element))
7836 if (IS_ANIMATED(graphic))
7837 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7843 /* this may take place after moving, so 'element' may have changed */
7845 if (IS_CHANGING(x, y))
7847 if (IS_CHANGING(x, y) &&
7848 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
7852 ChangeElement(x, y, ChangePage[x][y] != -1 ? ChangePage[x][y] :
7853 element_info[element].event_page_nr[CE_DELAY]);
7855 ChangeElement(x, y, element_info[element].event_page_nr[CE_DELAY]);
7858 element = Feld[x][y];
7859 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7863 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
7868 element = Feld[x][y];
7869 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7871 if (element == EL_MOLE)
7872 printf("::: %d, %d, %d [%d]\n",
7873 IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y],
7877 if (element == EL_YAMYAM)
7878 printf("::: %d, %d, %d\n",
7879 IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y]);
7883 if (IS_ANIMATED(graphic) &&
7887 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7890 if (element == EL_BUG)
7891 printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
7895 if (element == EL_MOLE)
7896 printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
7900 if (IS_GEM(element) || element == EL_SP_INFOTRON)
7901 EdelsteinFunkeln(x, y);
7903 else if ((element == EL_ACID ||
7904 element == EL_EXIT_OPEN ||
7905 element == EL_SP_EXIT_OPEN ||
7906 element == EL_SP_TERMINAL ||
7907 element == EL_SP_TERMINAL_ACTIVE ||
7908 element == EL_EXTRA_TIME ||
7909 element == EL_SHIELD_NORMAL ||
7910 element == EL_SHIELD_DEADLY) &&
7911 IS_ANIMATED(graphic))
7912 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7913 else if (IS_MOVING(x, y))
7914 ContinueMoving(x, y);
7915 else if (IS_ACTIVE_BOMB(element))
7916 CheckDynamite(x, y);
7918 else if (element == EL_EXPLOSION && !game.explosions_delayed)
7919 Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
7921 else if (element == EL_AMOEBA_GROWING)
7922 AmoebeWaechst(x, y);
7923 else if (element == EL_AMOEBA_SHRINKING)
7924 AmoebaDisappearing(x, y);
7926 #if !USE_NEW_AMOEBA_CODE
7927 else if (IS_AMOEBALIVE(element))
7928 AmoebeAbleger(x, y);
7931 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
7933 else if (element == EL_EXIT_CLOSED)
7935 else if (element == EL_SP_EXIT_CLOSED)
7937 else if (element == EL_EXPANDABLE_WALL_GROWING)
7939 else if (element == EL_EXPANDABLE_WALL ||
7940 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
7941 element == EL_EXPANDABLE_WALL_VERTICAL ||
7942 element == EL_EXPANDABLE_WALL_ANY)
7944 else if (element == EL_FLAMES)
7945 CheckForDragon(x, y);
7947 else if (IS_AUTO_CHANGING(element))
7948 ChangeElement(x, y);
7950 else if (element == EL_EXPLOSION)
7951 ; /* drawing of correct explosion animation is handled separately */
7952 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
7953 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7956 /* this may take place after moving, so 'element' may have changed */
7957 if (IS_AUTO_CHANGING(Feld[x][y]))
7958 ChangeElement(x, y);
7961 if (IS_BELT_ACTIVE(element))
7962 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
7964 if (game.magic_wall_active)
7966 int jx = local_player->jx, jy = local_player->jy;
7968 /* play the element sound at the position nearest to the player */
7969 if ((element == EL_MAGIC_WALL_FULL ||
7970 element == EL_MAGIC_WALL_ACTIVE ||
7971 element == EL_MAGIC_WALL_EMPTYING ||
7972 element == EL_BD_MAGIC_WALL_FULL ||
7973 element == EL_BD_MAGIC_WALL_ACTIVE ||
7974 element == EL_BD_MAGIC_WALL_EMPTYING) &&
7975 ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
7983 #if USE_NEW_AMOEBA_CODE
7984 /* new experimental amoeba growth stuff */
7986 if (!(FrameCounter % 8))
7989 static unsigned long random = 1684108901;
7991 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
7994 x = (random >> 10) % lev_fieldx;
7995 y = (random >> 20) % lev_fieldy;
7997 x = RND(lev_fieldx);
7998 y = RND(lev_fieldy);
8000 element = Feld[x][y];
8002 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
8003 if (!IS_PLAYER(x,y) &&
8004 (element == EL_EMPTY ||
8005 element == EL_SAND ||
8006 element == EL_QUICKSAND_EMPTY ||
8007 element == EL_ACID_SPLASH_LEFT ||
8008 element == EL_ACID_SPLASH_RIGHT))
8010 if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
8011 (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
8012 (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
8013 (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
8014 Feld[x][y] = EL_AMOEBA_DROP;
8017 random = random * 129 + 1;
8023 if (game.explosions_delayed)
8026 game.explosions_delayed = FALSE;
8028 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8030 element = Feld[x][y];
8032 if (ExplodeField[x][y])
8033 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
8034 else if (element == EL_EXPLOSION)
8035 Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
8037 ExplodeField[x][y] = EX_NO_EXPLOSION;
8040 game.explosions_delayed = TRUE;
8043 if (game.magic_wall_active)
8045 if (!(game.magic_wall_time_left % 4))
8047 int element = Feld[magic_wall_x][magic_wall_y];
8049 if (element == EL_BD_MAGIC_WALL_FULL ||
8050 element == EL_BD_MAGIC_WALL_ACTIVE ||
8051 element == EL_BD_MAGIC_WALL_EMPTYING)
8052 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
8054 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
8057 if (game.magic_wall_time_left > 0)
8059 game.magic_wall_time_left--;
8060 if (!game.magic_wall_time_left)
8062 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8064 element = Feld[x][y];
8066 if (element == EL_MAGIC_WALL_ACTIVE ||
8067 element == EL_MAGIC_WALL_FULL)
8069 Feld[x][y] = EL_MAGIC_WALL_DEAD;
8070 DrawLevelField(x, y);
8072 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
8073 element == EL_BD_MAGIC_WALL_FULL)
8075 Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
8076 DrawLevelField(x, y);
8080 game.magic_wall_active = FALSE;
8085 if (game.light_time_left > 0)
8087 game.light_time_left--;
8089 if (game.light_time_left == 0)
8090 RedrawAllLightSwitchesAndInvisibleElements();
8093 if (game.timegate_time_left > 0)
8095 game.timegate_time_left--;
8097 if (game.timegate_time_left == 0)
8098 CloseAllOpenTimegates();
8101 for (i = 0; i < MAX_PLAYERS; i++)
8103 struct PlayerInfo *player = &stored_player[i];
8105 if (SHIELD_ON(player))
8107 if (player->shield_deadly_time_left)
8108 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
8109 else if (player->shield_normal_time_left)
8110 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
8114 if (TimeFrames >= FRAMES_PER_SECOND)
8119 if (!level.use_step_counter)
8123 for (i = 0; i < MAX_PLAYERS; i++)
8125 struct PlayerInfo *player = &stored_player[i];
8127 if (SHIELD_ON(player))
8129 player->shield_normal_time_left--;
8131 if (player->shield_deadly_time_left > 0)
8132 player->shield_deadly_time_left--;
8140 if (TimeLeft <= 10 && setup.time_limit)
8141 PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
8143 DrawGameValue_Time(TimeLeft);
8145 if (!TimeLeft && setup.time_limit)
8146 for (i = 0; i < MAX_PLAYERS; i++)
8147 KillHero(&stored_player[i]);
8149 else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
8150 DrawGameValue_Time(TimePlayed);
8153 if (tape.recording || tape.playing)
8154 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
8158 PlayAllPlayersSound();
8160 if (options.debug) /* calculate frames per second */
8162 static unsigned long fps_counter = 0;
8163 static int fps_frames = 0;
8164 unsigned long fps_delay_ms = Counter() - fps_counter;
8168 if (fps_delay_ms >= 500) /* calculate fps every 0.5 seconds */
8170 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
8173 fps_counter = Counter();
8176 redraw_mask |= REDRAW_FPS;
8180 if (stored_player[0].jx != stored_player[0].last_jx ||
8181 stored_player[0].jy != stored_player[0].last_jy)
8182 printf("::: %d, %d, %d, %d, %d\n",
8183 stored_player[0].MovDir,
8184 stored_player[0].MovPos,
8185 stored_player[0].GfxPos,
8186 stored_player[0].Frame,
8187 stored_player[0].StepFrame);
8194 for (i = 0; i < MAX_PLAYERS; i++)
8197 MOVE_DELAY_NORMAL_SPEED / stored_player[i].move_delay_value;
8199 stored_player[i].Frame += move_frames;
8201 if (stored_player[i].MovPos != 0)
8202 stored_player[i].StepFrame += move_frames;
8204 if (stored_player[i].drop_delay > 0)
8205 stored_player[i].drop_delay--;
8210 if (local_player->show_envelope != 0 && local_player->MovPos == 0)
8212 ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
8214 local_player->show_envelope = 0;
8219 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
8221 int min_x = x, min_y = y, max_x = x, max_y = y;
8224 for (i = 0; i < MAX_PLAYERS; i++)
8226 int jx = stored_player[i].jx, jy = stored_player[i].jy;
8228 if (!stored_player[i].active || &stored_player[i] == player)
8231 min_x = MIN(min_x, jx);
8232 min_y = MIN(min_y, jy);
8233 max_x = MAX(max_x, jx);
8234 max_y = MAX(max_y, jy);
8237 return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
8240 static boolean AllPlayersInVisibleScreen()
8244 for (i = 0; i < MAX_PLAYERS; i++)
8246 int jx = stored_player[i].jx, jy = stored_player[i].jy;
8248 if (!stored_player[i].active)
8251 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8258 void ScrollLevel(int dx, int dy)
8260 int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
8263 BlitBitmap(drawto_field, drawto_field,
8264 FX + TILEX * (dx == -1) - softscroll_offset,
8265 FY + TILEY * (dy == -1) - softscroll_offset,
8266 SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
8267 SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
8268 FX + TILEX * (dx == 1) - softscroll_offset,
8269 FY + TILEY * (dy == 1) - softscroll_offset);
8273 x = (dx == 1 ? BX1 : BX2);
8274 for (y = BY1; y <= BY2; y++)
8275 DrawScreenField(x, y);
8280 y = (dy == 1 ? BY1 : BY2);
8281 for (x = BX1; x <= BX2; x++)
8282 DrawScreenField(x, y);
8285 redraw_mask |= REDRAW_FIELD;
8288 static boolean canEnterSupaplexPort(int x, int y, int dx, int dy)
8290 int nextx = x + dx, nexty = y + dy;
8291 int element = Feld[x][y];
8294 element != EL_SP_PORT_LEFT &&
8295 element != EL_SP_GRAVITY_PORT_LEFT &&
8296 element != EL_SP_PORT_HORIZONTAL &&
8297 element != EL_SP_PORT_ANY) ||
8299 element != EL_SP_PORT_RIGHT &&
8300 element != EL_SP_GRAVITY_PORT_RIGHT &&
8301 element != EL_SP_PORT_HORIZONTAL &&
8302 element != EL_SP_PORT_ANY) ||
8304 element != EL_SP_PORT_UP &&
8305 element != EL_SP_GRAVITY_PORT_UP &&
8306 element != EL_SP_PORT_VERTICAL &&
8307 element != EL_SP_PORT_ANY) ||
8309 element != EL_SP_PORT_DOWN &&
8310 element != EL_SP_GRAVITY_PORT_DOWN &&
8311 element != EL_SP_PORT_VERTICAL &&
8312 element != EL_SP_PORT_ANY) ||
8313 !IN_LEV_FIELD(nextx, nexty) ||
8314 !IS_FREE(nextx, nexty))
8320 static void CheckGravityMovement(struct PlayerInfo *player)
8322 if (game.gravity && !player->programmed_action)
8324 int move_dir_horizontal = player->action & MV_HORIZONTAL;
8325 int move_dir_vertical = player->action & MV_VERTICAL;
8327 (player->last_move_dir & MV_HORIZONTAL ?
8328 (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
8329 (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
8330 int jx = player->jx, jy = player->jy;
8331 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
8332 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
8333 int new_jx = jx + dx, new_jy = jy + dy;
8334 boolean player_is_snapping = player->action & JOY_BUTTON_1;
8336 boolean player_can_fall_down =
8337 (IN_LEV_FIELD(jx, jy + 1) &&
8338 (IS_FREE(jx, jy + 1) ||
8339 (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)));
8341 boolean player_can_fall_down =
8342 (IN_LEV_FIELD(jx, jy + 1) &&
8343 (IS_FREE(jx, jy + 1)));
8345 boolean player_is_moving_to_valid_field =
8348 !player_is_snapping &&
8350 IN_LEV_FIELD(new_jx, new_jy) &&
8351 (Feld[new_jx][new_jy] == EL_SP_BASE ||
8352 Feld[new_jx][new_jy] == EL_SAND ||
8353 (IS_SP_PORT(Feld[new_jx][new_jy]) &&
8354 canEnterSupaplexPort(new_jx, new_jy, dx, dy))));
8355 /* !!! extend EL_SAND to anything diggable !!! */
8357 boolean player_is_standing_on_valid_field =
8358 (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
8359 (IS_WALKABLE(Feld[jx][jy]) &&
8360 !(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
8363 printf("::: checking gravity NOW [%d, %d, %d] [%d] ...\n",
8364 player_can_fall_down,
8365 player_is_standing_on_valid_field,
8366 player_is_moving_to_valid_field,
8367 (player_is_moving_to_valid_field ? Feld[new_jx][new_jy] : -1));
8370 if (player_can_fall_down &&
8371 !player_is_standing_on_valid_field &&
8372 !player_is_moving_to_valid_field)
8375 printf("::: setting programmed_action to MV_DOWN [%d,%d - %d] ...\n",
8376 jx, jy, FrameCounter);
8379 player->programmed_action = MV_DOWN;
8384 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
8387 return CheckGravityMovement(player);
8390 if (game.gravity && !player->programmed_action)
8392 int jx = player->jx, jy = player->jy;
8393 boolean field_under_player_is_free =
8394 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
8395 boolean player_is_standing_on_valid_field =
8396 (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
8397 (IS_WALKABLE(Feld[jx][jy]) &&
8398 !(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
8400 if (field_under_player_is_free && !player_is_standing_on_valid_field)
8401 player->programmed_action = MV_DOWN;
8407 -----------------------------------------------------------------------------
8408 dx, dy: direction (non-diagonal) to try to move the player to
8409 real_dx, real_dy: direction as read from input device (can be diagonal)
8412 boolean MovePlayerOneStep(struct PlayerInfo *player,
8413 int dx, int dy, int real_dx, int real_dy)
8416 static int trigger_sides[4][2] =
8418 /* enter side leave side */
8419 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* moving left */
8420 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* moving right */
8421 { CH_SIDE_BOTTOM, CH_SIDE_TOP }, /* moving up */
8422 { CH_SIDE_TOP, CH_SIDE_BOTTOM } /* moving down */
8424 int move_direction = (dx == -1 ? MV_LEFT :
8425 dx == +1 ? MV_RIGHT :
8427 dy == +1 ? MV_DOWN : MV_NO_MOVING);
8428 int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0];
8429 int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
8431 int jx = player->jx, jy = player->jy;
8432 int new_jx = jx + dx, new_jy = jy + dy;
8436 if (!player->active || (!dx && !dy))
8437 return MF_NO_ACTION;
8439 player->MovDir = (dx < 0 ? MV_LEFT :
8442 dy > 0 ? MV_DOWN : MV_NO_MOVING);
8444 if (!IN_LEV_FIELD(new_jx, new_jy))
8445 return MF_NO_ACTION;
8447 if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
8448 return MF_NO_ACTION;
8451 element = MovingOrBlocked2Element(new_jx, new_jy);
8453 element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
8456 if (DONT_RUN_INTO(element))
8458 if (element == EL_ACID && dx == 0 && dy == 1)
8460 SplashAcid(new_jx, new_jy);
8461 Feld[jx][jy] = EL_PLAYER_1;
8462 InitMovingField(jx, jy, MV_DOWN);
8463 Store[jx][jy] = EL_ACID;
8464 ContinueMoving(jx, jy);
8468 TestIfHeroRunsIntoBadThing(jx, jy, player->MovDir);
8473 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
8474 if (can_move != MF_MOVING)
8477 /* check if DigField() has caused relocation of the player */
8478 if (player->jx != jx || player->jy != jy)
8479 return MF_NO_ACTION;
8481 StorePlayer[jx][jy] = 0;
8482 player->last_jx = jx;
8483 player->last_jy = jy;
8484 player->jx = new_jx;
8485 player->jy = new_jy;
8486 StorePlayer[new_jx][new_jy] = player->element_nr;
8489 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
8491 player->step_counter++;
8493 player->drop_delay = 0;
8495 PlayerVisit[jx][jy] = FrameCounter;
8497 ScrollPlayer(player, SCROLL_INIT);
8500 if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
8502 CheckTriggeredElementChangeSide(jx, jy, Feld[jx][jy], CE_OTHER_GETS_LEFT,
8504 CheckElementChangeSide(jx, jy, Feld[jx][jy], CE_LEFT_BY_PLAYER,leave_side);
8507 if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
8509 CheckTriggeredElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy],
8510 CE_OTHER_GETS_ENTERED, enter_side);
8511 CheckElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy],
8512 CE_ENTERED_BY_PLAYER, enter_side);
8519 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
8521 int jx = player->jx, jy = player->jy;
8522 int old_jx = jx, old_jy = jy;
8523 int moved = MF_NO_ACTION;
8526 if (!player->active)
8531 if (player->MovPos == 0)
8533 player->is_moving = FALSE;
8534 player->is_digging = FALSE;
8535 player->is_collecting = FALSE;
8536 player->is_snapping = FALSE;
8537 player->is_pushing = FALSE;
8543 if (!player->active || (!dx && !dy))
8548 if (!FrameReached(&player->move_delay, player->move_delay_value) &&
8554 if (!FrameReached(&player->move_delay, player->move_delay_value))
8557 if (!FrameReached(&player->move_delay, player->move_delay_value) &&
8558 !(tape.playing && tape.file_version < FILE_VERSION_2_0))
8564 /* remove the last programmed player action */
8565 player->programmed_action = 0;
8569 /* should only happen if pre-1.2 tape recordings are played */
8570 /* this is only for backward compatibility */
8572 int original_move_delay_value = player->move_delay_value;
8575 printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
8579 /* scroll remaining steps with finest movement resolution */
8580 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
8582 while (player->MovPos)
8584 ScrollPlayer(player, SCROLL_GO_ON);
8585 ScrollScreen(NULL, SCROLL_GO_ON);
8591 player->move_delay_value = original_move_delay_value;
8594 if (player->last_move_dir & MV_HORIZONTAL)
8596 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
8597 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
8601 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
8602 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
8608 if (moved & MF_MOVING && !ScreenMovPos &&
8609 (player == local_player || !options.network))
8611 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
8612 int offset = (setup.scroll_delay ? 3 : 0);
8614 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8616 /* actual player has left the screen -- scroll in that direction */
8617 if (jx != old_jx) /* player has moved horizontally */
8618 scroll_x += (jx - old_jx);
8619 else /* player has moved vertically */
8620 scroll_y += (jy - old_jy);
8624 if (jx != old_jx) /* player has moved horizontally */
8626 if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
8627 (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
8628 scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
8630 /* don't scroll over playfield boundaries */
8631 if (scroll_x < SBX_Left || scroll_x > SBX_Right)
8632 scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
8634 /* don't scroll more than one field at a time */
8635 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
8637 /* don't scroll against the player's moving direction */
8638 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
8639 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
8640 scroll_x = old_scroll_x;
8642 else /* player has moved vertically */
8644 if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
8645 (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
8646 scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
8648 /* don't scroll over playfield boundaries */
8649 if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
8650 scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
8652 /* don't scroll more than one field at a time */
8653 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
8655 /* don't scroll against the player's moving direction */
8656 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
8657 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
8658 scroll_y = old_scroll_y;
8662 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
8664 if (!options.network && !AllPlayersInVisibleScreen())
8666 scroll_x = old_scroll_x;
8667 scroll_y = old_scroll_y;
8671 ScrollScreen(player, SCROLL_INIT);
8672 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
8679 InitPlayerGfxAnimation(player, ACTION_DEFAULT);
8681 if (!(moved & MF_MOVING) && !player->is_pushing)
8686 player->StepFrame = 0;
8688 if (moved & MF_MOVING)
8690 if (old_jx != jx && old_jy == jy)
8691 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
8692 else if (old_jx == jx && old_jy != jy)
8693 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
8695 DrawLevelField(jx, jy); /* for "crumbled sand" */
8697 player->last_move_dir = player->MovDir;
8698 player->is_moving = TRUE;
8700 player->is_snapping = FALSE;
8704 player->is_switching = FALSE;
8707 player->is_dropping = FALSE;
8712 static int trigger_sides[4][2] =
8714 /* enter side leave side */
8715 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* moving left */
8716 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* moving right */
8717 { CH_SIDE_BOTTOM, CH_SIDE_TOP }, /* moving up */
8718 { CH_SIDE_TOP, CH_SIDE_BOTTOM } /* moving down */
8720 int move_direction = player->MovDir;
8721 int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0];
8722 int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
8725 if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
8727 CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8729 player->index_bit, leave_side);
8730 CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8732 player->index_bit, leave_side);
8735 if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
8737 CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
8738 CE_OTHER_GETS_ENTERED,
8739 player->index_bit, enter_side);
8740 CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
8741 player->index_bit, enter_side);
8752 CheckGravityMovementWhenNotMoving(player);
8755 player->last_move_dir = MV_NO_MOVING;
8757 player->is_moving = FALSE;
8760 if (game.engine_version < VERSION_IDENT(3,0,7,0))
8762 TestIfHeroTouchesBadThing(jx, jy);
8763 TestIfPlayerTouchesCustomElement(jx, jy);
8766 if (!player->active)
8772 void ScrollPlayer(struct PlayerInfo *player, int mode)
8774 int jx = player->jx, jy = player->jy;
8775 int last_jx = player->last_jx, last_jy = player->last_jy;
8776 int move_stepsize = TILEX / player->move_delay_value;
8778 if (!player->active || !player->MovPos)
8781 if (mode == SCROLL_INIT)
8783 player->actual_frame_counter = FrameCounter;
8784 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8786 if (Feld[last_jx][last_jy] == EL_EMPTY)
8787 Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
8795 else if (!FrameReached(&player->actual_frame_counter, 1))
8798 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
8799 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8801 if (!player->block_last_field &&
8802 Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
8803 Feld[last_jx][last_jy] = EL_EMPTY;
8805 /* before DrawPlayer() to draw correct player graphic for this case */
8806 if (player->MovPos == 0)
8807 CheckGravityMovement(player);
8810 DrawPlayer(player); /* needed here only to cleanup last field */
8813 if (player->MovPos == 0) /* player reached destination field */
8816 if (player->move_delay_reset_counter > 0)
8818 player->move_delay_reset_counter--;
8820 if (player->move_delay_reset_counter == 0)
8822 /* continue with normal speed after quickly moving through gate */
8823 HALVE_PLAYER_SPEED(player);
8825 /* be able to make the next move without delay */
8826 player->move_delay = 0;
8830 if (IS_PASSABLE(Feld[last_jx][last_jy]))
8832 /* continue with normal speed after quickly moving through gate */
8833 HALVE_PLAYER_SPEED(player);
8835 /* be able to make the next move without delay */
8836 player->move_delay = 0;
8840 if (player->block_last_field &&
8841 Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
8842 Feld[last_jx][last_jy] = EL_EMPTY;
8844 player->last_jx = jx;
8845 player->last_jy = jy;
8847 if (Feld[jx][jy] == EL_EXIT_OPEN ||
8848 Feld[jx][jy] == EL_SP_EXIT_OPEN ||
8849 Feld[jx][jy] == EL_SP_EXIT_OPENING) /* <-- special case */
8851 DrawPlayer(player); /* needed here only to cleanup last field */
8854 if (local_player->friends_still_needed == 0 ||
8855 IS_SP_ELEMENT(Feld[jx][jy]))
8856 player->LevelSolved = player->GameOver = TRUE;
8860 /* !!! ENABLE THIS FOR NEW VERSIONS !!! */
8862 static int trigger_sides[4][2] =
8864 /* enter side leave side */
8865 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* moving left */
8866 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* moving right */
8867 { CH_SIDE_BOTTOM, CH_SIDE_TOP }, /* moving up */
8868 { CH_SIDE_TOP, CH_SIDE_BOTTOM } /* moving down */
8870 int move_direction = player->MovDir;
8871 int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0];
8872 int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
8873 int old_jx = last_jx;
8874 int old_jy = last_jy;
8877 if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
8879 CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8881 player->index_bit, leave_side);
8882 CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8884 player->index_bit, leave_side);
8887 if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
8889 CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
8890 CE_OTHER_GETS_ENTERED,
8891 player->index_bit, enter_side);
8892 CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
8893 player->index_bit, enter_side);
8900 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
8902 TestIfHeroTouchesBadThing(jx, jy);
8903 TestIfPlayerTouchesCustomElement(jx, jy);
8905 TestIfElementTouchesCustomElement(jx, jy); /* for empty space */
8908 if (!player->active)
8912 if (level.use_step_counter)
8918 for (i = 0; i < MAX_PLAYERS; i++)
8920 struct PlayerInfo *player = &stored_player[i];
8922 if (SHIELD_ON(player))
8924 player->shield_normal_time_left--;
8926 if (player->shield_deadly_time_left > 0)
8927 player->shield_deadly_time_left--;
8935 if (TimeLeft <= 10 && setup.time_limit)
8936 PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
8938 DrawGameValue_Time(TimeLeft);
8940 if (!TimeLeft && setup.time_limit)
8941 for (i = 0; i < MAX_PLAYERS; i++)
8942 KillHero(&stored_player[i]);
8944 else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
8945 DrawGameValue_Time(TimePlayed);
8948 if (tape.single_step && tape.recording && !tape.pausing &&
8949 !player->programmed_action)
8950 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
8954 void ScrollScreen(struct PlayerInfo *player, int mode)
8956 static unsigned long screen_frame_counter = 0;
8958 if (mode == SCROLL_INIT)
8960 /* set scrolling step size according to actual player's moving speed */
8961 ScrollStepSize = TILEX / player->move_delay_value;
8963 screen_frame_counter = FrameCounter;
8964 ScreenMovDir = player->MovDir;
8965 ScreenMovPos = player->MovPos;
8966 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
8969 else if (!FrameReached(&screen_frame_counter, 1))
8974 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
8975 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
8976 redraw_mask |= REDRAW_FIELD;
8979 ScreenMovDir = MV_NO_MOVING;
8982 void TestIfPlayerTouchesCustomElement(int x, int y)
8984 static int xy[4][2] =
8991 static int trigger_sides[4][2] =
8993 /* center side border side */
8994 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, /* check top */
8995 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* check left */
8996 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* check right */
8997 { CH_SIDE_BOTTOM, CH_SIDE_TOP } /* check bottom */
8999 static int touch_dir[4] =
9006 int center_element = Feld[x][y]; /* should always be non-moving! */
9009 for (i = 0; i < NUM_DIRECTIONS; i++)
9011 int xx = x + xy[i][0];
9012 int yy = y + xy[i][1];
9013 int center_side = trigger_sides[i][0];
9014 int border_side = trigger_sides[i][1];
9017 if (!IN_LEV_FIELD(xx, yy))
9020 if (IS_PLAYER(x, y))
9022 struct PlayerInfo *player = PLAYERINFO(x, y);
9024 if (game.engine_version < VERSION_IDENT(3,0,7,0))
9025 border_element = Feld[xx][yy]; /* may be moving! */
9026 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
9027 border_element = Feld[xx][yy];
9028 else if (MovDir[xx][yy] & touch_dir[i]) /* elements are touching */
9029 border_element = MovingOrBlocked2Element(xx, yy);
9031 continue; /* center and border element do not touch */
9033 CheckTriggeredElementChangePlayer(xx, yy, border_element,
9034 CE_OTHER_GETS_TOUCHED,
9035 player->index_bit, border_side);
9036 CheckElementChangePlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
9037 player->index_bit, border_side);
9039 else if (IS_PLAYER(xx, yy))
9041 struct PlayerInfo *player = PLAYERINFO(xx, yy);
9043 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
9045 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
9046 continue; /* center and border element do not touch */
9049 CheckTriggeredElementChangePlayer(x, y, center_element,
9050 CE_OTHER_GETS_TOUCHED,
9051 player->index_bit, center_side);
9052 CheckElementChangePlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
9053 player->index_bit, center_side);
9060 void TestIfElementTouchesCustomElement(int x, int y)
9062 static int xy[4][2] =
9069 static int trigger_sides[4][2] =
9071 /* center side border side */
9072 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, /* check top */
9073 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* check left */
9074 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* check right */
9075 { CH_SIDE_BOTTOM, CH_SIDE_TOP } /* check bottom */
9077 static int touch_dir[4] =
9084 boolean change_center_element = FALSE;
9085 int center_element_change_page = 0;
9086 int center_element = Feld[x][y]; /* should always be non-moving! */
9089 for (i = 0; i < NUM_DIRECTIONS; i++)
9091 int xx = x + xy[i][0];
9092 int yy = y + xy[i][1];
9093 int center_side = trigger_sides[i][0];
9094 int border_side = trigger_sides[i][1];
9097 if (!IN_LEV_FIELD(xx, yy))
9100 if (game.engine_version < VERSION_IDENT(3,0,7,0))
9101 border_element = Feld[xx][yy]; /* may be moving! */
9102 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
9103 border_element = Feld[xx][yy];
9104 else if (MovDir[xx][yy] & touch_dir[i]) /* elements are touching */
9105 border_element = MovingOrBlocked2Element(xx, yy);
9107 continue; /* center and border element do not touch */
9109 /* check for change of center element (but change it only once) */
9110 if (IS_CUSTOM_ELEMENT(center_element) &&
9111 HAS_ANY_CHANGE_EVENT(center_element, CE_OTHER_IS_TOUCHING) &&
9112 !change_center_element)
9114 for (j = 0; j < element_info[center_element].num_change_pages; j++)
9116 struct ElementChangeInfo *change =
9117 &element_info[center_element].change_page[j];
9119 if (change->can_change &&
9120 change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
9121 change->trigger_side & border_side &&
9123 IS_EQUAL_OR_IN_GROUP(border_element, change->trigger_element)
9125 change->trigger_element == border_element
9129 change_center_element = TRUE;
9130 center_element_change_page = j;
9137 /* check for change of border element */
9138 if (IS_CUSTOM_ELEMENT(border_element) &&
9139 HAS_ANY_CHANGE_EVENT(border_element, CE_OTHER_IS_TOUCHING))
9141 for (j = 0; j < element_info[border_element].num_change_pages; j++)
9143 struct ElementChangeInfo *change =
9144 &element_info[border_element].change_page[j];
9146 if (change->can_change &&
9147 change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
9148 change->trigger_side & center_side &&
9150 IS_EQUAL_OR_IN_GROUP(center_element, change->trigger_element)
9152 change->trigger_element == center_element
9156 CheckElementChangePage(xx, yy, border_element, CE_OTHER_IS_TOUCHING,
9164 if (change_center_element)
9165 CheckElementChangePage(x, y, center_element, CE_OTHER_IS_TOUCHING,
9166 center_element_change_page);
9169 void TestIfElementHitsCustomElement(int x, int y, int direction)
9171 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
9172 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
9173 int hitx = x + dx, hity = y + dy;
9174 int hitting_element = Feld[x][y];
9176 boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
9177 !IS_FREE(hitx, hity) &&
9178 (!IS_MOVING(hitx, hity) ||
9179 MovDir[hitx][hity] != direction ||
9180 ABS(MovPos[hitx][hity]) <= TILEY / 2));
9183 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
9187 if (IN_LEV_FIELD(hitx, hity) && !object_hit)
9191 CheckElementChangeSide(x, y, hitting_element, CE_HITTING_SOMETHING,
9194 if (IN_LEV_FIELD(hitx, hity))
9196 int opposite_direction = MV_DIR_OPPOSITE(direction);
9197 int hitting_side = direction;
9198 int touched_side = opposite_direction;
9199 int touched_element = MovingOrBlocked2Element(hitx, hity);
9201 boolean object_hit = (!IS_MOVING(hitx, hity) ||
9202 MovDir[hitx][hity] != direction ||
9203 ABS(MovPos[hitx][hity]) <= TILEY / 2);
9212 CheckElementChangeSide(hitx, hity, touched_element, CE_HIT_BY_SOMETHING,
9213 opposite_direction);
9215 if (IS_CUSTOM_ELEMENT(hitting_element) &&
9216 HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING))
9218 for (i = 0; i < element_info[hitting_element].num_change_pages; i++)
9220 struct ElementChangeInfo *change =
9221 &element_info[hitting_element].change_page[i];
9223 if (change->can_change &&
9224 change->events & CH_EVENT_BIT(CE_OTHER_IS_HITTING) &&
9225 change->trigger_side & touched_side &&
9228 IS_EQUAL_OR_IN_GROUP(touched_element, change->trigger_element)
9230 change->trigger_element == touched_element
9234 CheckElementChangePage(x, y, hitting_element, CE_OTHER_IS_HITTING,
9241 if (IS_CUSTOM_ELEMENT(touched_element) &&
9242 HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_HIT))
9244 for (i = 0; i < element_info[touched_element].num_change_pages; i++)
9246 struct ElementChangeInfo *change =
9247 &element_info[touched_element].change_page[i];
9249 if (change->can_change &&
9250 change->events & CH_EVENT_BIT(CE_OTHER_GETS_HIT) &&
9251 change->trigger_side & hitting_side &&
9253 IS_EQUAL_OR_IN_GROUP(hitting_element, change->trigger_element)
9255 change->trigger_element == hitting_element
9259 CheckElementChangePage(hitx, hity, touched_element,
9260 CE_OTHER_GETS_HIT, i);
9270 void TestIfElementSmashesCustomElement(int x, int y, int direction)
9272 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
9273 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
9274 int hitx = x + dx, hity = y + dy;
9275 int hitting_element = Feld[x][y];
9277 boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
9278 !IS_FREE(hitx, hity) &&
9279 (!IS_MOVING(hitx, hity) ||
9280 MovDir[hitx][hity] != direction ||
9281 ABS(MovPos[hitx][hity]) <= TILEY / 2));
9284 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
9288 if (IN_LEV_FIELD(hitx, hity) && !object_hit)
9292 CheckElementChangeSide(x, y, hitting_element, EP_CAN_SMASH_EVERYTHING,
9295 if (IN_LEV_FIELD(hitx, hity))
9297 int opposite_direction = MV_DIR_OPPOSITE(direction);
9298 int hitting_side = direction;
9299 int touched_side = opposite_direction;
9300 int touched_element = MovingOrBlocked2Element(hitx, hity);
9302 boolean object_hit = (!IS_MOVING(hitx, hity) ||
9303 MovDir[hitx][hity] != direction ||
9304 ABS(MovPos[hitx][hity]) <= TILEY / 2);
9313 CheckElementChangeSide(hitx, hity, touched_element,
9314 CE_SMASHED_BY_SOMETHING, opposite_direction);
9316 if (IS_CUSTOM_ELEMENT(hitting_element) &&
9317 HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_SMASHING))
9319 for (i = 0; i < element_info[hitting_element].num_change_pages; i++)
9321 struct ElementChangeInfo *change =
9322 &element_info[hitting_element].change_page[i];
9324 if (change->can_change &&
9325 change->events & CH_EVENT_BIT(CE_OTHER_IS_SMASHING) &&
9326 change->trigger_side & touched_side &&
9329 IS_EQUAL_OR_IN_GROUP(touched_element, change->trigger_element)
9331 change->trigger_element == touched_element
9335 CheckElementChangePage(x, y, hitting_element, CE_OTHER_IS_SMASHING,
9342 if (IS_CUSTOM_ELEMENT(touched_element) &&
9343 HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_SMASHED))
9345 for (i = 0; i < element_info[touched_element].num_change_pages; i++)
9347 struct ElementChangeInfo *change =
9348 &element_info[touched_element].change_page[i];
9350 if (change->can_change &&
9351 change->events & CH_EVENT_BIT(CE_OTHER_GETS_SMASHED) &&
9352 change->trigger_side & hitting_side &&
9354 IS_EQUAL_OR_IN_GROUP(hitting_element, change->trigger_element)
9356 change->trigger_element == hitting_element
9360 CheckElementChangePage(hitx, hity, touched_element,
9361 CE_OTHER_GETS_SMASHED, i);
9371 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
9373 int i, kill_x = -1, kill_y = -1;
9374 static int test_xy[4][2] =
9381 static int test_dir[4] =
9389 for (i = 0; i < NUM_DIRECTIONS; i++)
9391 int test_x, test_y, test_move_dir, test_element;
9393 test_x = good_x + test_xy[i][0];
9394 test_y = good_y + test_xy[i][1];
9395 if (!IN_LEV_FIELD(test_x, test_y))
9399 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9402 test_element = Feld[test_x][test_y];
9404 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
9407 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9408 2nd case: DONT_TOUCH style bad thing does not move away from good thing
9410 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
9411 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
9419 if (kill_x != -1 || kill_y != -1)
9421 if (IS_PLAYER(good_x, good_y))
9423 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
9425 if (player->shield_deadly_time_left > 0)
9426 Bang(kill_x, kill_y);
9427 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
9431 Bang(good_x, good_y);
9435 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
9437 int i, kill_x = -1, kill_y = -1;
9438 int bad_element = Feld[bad_x][bad_y];
9439 static int test_xy[4][2] =
9446 static int touch_dir[4] =
9453 static int test_dir[4] =
9461 if (bad_element == EL_EXPLOSION) /* skip just exploding bad things */
9464 for (i = 0; i < NUM_DIRECTIONS; i++)
9466 int test_x, test_y, test_move_dir, test_element;
9468 test_x = bad_x + test_xy[i][0];
9469 test_y = bad_y + test_xy[i][1];
9470 if (!IN_LEV_FIELD(test_x, test_y))
9474 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9476 test_element = Feld[test_x][test_y];
9478 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9479 2nd case: DONT_TOUCH style bad thing does not move away from good thing
9481 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
9482 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
9484 /* good thing is player or penguin that does not move away */
9485 if (IS_PLAYER(test_x, test_y))
9487 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
9489 if (bad_element == EL_ROBOT && player->is_moving)
9490 continue; /* robot does not kill player if he is moving */
9492 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
9494 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
9495 continue; /* center and border element do not touch */
9502 else if (test_element == EL_PENGUIN)
9511 if (kill_x != -1 || kill_y != -1)
9513 if (IS_PLAYER(kill_x, kill_y))
9515 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
9517 if (player->shield_deadly_time_left > 0)
9519 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
9523 Bang(kill_x, kill_y);
9527 void TestIfHeroTouchesBadThing(int x, int y)
9529 TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9532 void TestIfHeroRunsIntoBadThing(int x, int y, int move_dir)
9534 TestIfGoodThingHitsBadThing(x, y, move_dir);
9537 void TestIfBadThingTouchesHero(int x, int y)
9539 TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9542 void TestIfBadThingRunsIntoHero(int x, int y, int move_dir)
9544 TestIfBadThingHitsGoodThing(x, y, move_dir);
9547 void TestIfFriendTouchesBadThing(int x, int y)
9549 TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9552 void TestIfBadThingTouchesFriend(int x, int y)
9554 TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9557 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
9559 int i, kill_x = bad_x, kill_y = bad_y;
9560 static int xy[4][2] =
9568 for (i = 0; i < NUM_DIRECTIONS; i++)
9572 x = bad_x + xy[i][0];
9573 y = bad_y + xy[i][1];
9574 if (!IN_LEV_FIELD(x, y))
9577 element = Feld[x][y];
9578 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
9579 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
9587 if (kill_x != bad_x || kill_y != bad_y)
9591 void KillHero(struct PlayerInfo *player)
9593 int jx = player->jx, jy = player->jy;
9595 if (!player->active)
9598 /* remove accessible field at the player's position */
9599 Feld[jx][jy] = EL_EMPTY;
9601 /* deactivate shield (else Bang()/Explode() would not work right) */
9602 player->shield_normal_time_left = 0;
9603 player->shield_deadly_time_left = 0;
9609 static void KillHeroUnlessEnemyProtected(int x, int y)
9611 if (!PLAYER_ENEMY_PROTECTED(x, y))
9612 KillHero(PLAYERINFO(x, y));
9615 static void KillHeroUnlessExplosionProtected(int x, int y)
9617 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
9618 KillHero(PLAYERINFO(x, y));
9621 void BuryHero(struct PlayerInfo *player)
9623 int jx = player->jx, jy = player->jy;
9625 if (!player->active)
9629 PlayLevelSoundElementAction(jx, jy, player->element_nr, ACTION_DYING);
9631 PlayLevelSound(jx, jy, SND_CLASS_PLAYER_DYING);
9633 PlayLevelSound(jx, jy, SND_GAME_LOSING);
9635 player->GameOver = TRUE;
9639 void RemoveHero(struct PlayerInfo *player)
9641 int jx = player->jx, jy = player->jy;
9642 int i, found = FALSE;
9644 player->present = FALSE;
9645 player->active = FALSE;
9647 if (!ExplodeField[jx][jy])
9648 StorePlayer[jx][jy] = 0;
9650 for (i = 0; i < MAX_PLAYERS; i++)
9651 if (stored_player[i].active)
9655 AllPlayersGone = TRUE;
9662 =============================================================================
9663 checkDiagonalPushing()
9664 -----------------------------------------------------------------------------
9665 check if diagonal input device direction results in pushing of object
9666 (by checking if the alternative direction is walkable, diggable, ...)
9667 =============================================================================
9670 static boolean checkDiagonalPushing(struct PlayerInfo *player,
9671 int x, int y, int real_dx, int real_dy)
9673 int jx, jy, dx, dy, xx, yy;
9675 if (real_dx == 0 || real_dy == 0) /* no diagonal direction => push */
9678 /* diagonal direction: check alternative direction */
9683 xx = jx + (dx == 0 ? real_dx : 0);
9684 yy = jy + (dy == 0 ? real_dy : 0);
9686 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
9690 =============================================================================
9692 -----------------------------------------------------------------------------
9693 x, y: field next to player (non-diagonal) to try to dig to
9694 real_dx, real_dy: direction as read from input device (can be diagonal)
9695 =============================================================================
9698 int DigField(struct PlayerInfo *player,
9699 int oldx, int oldy, int x, int y,
9700 int real_dx, int real_dy, int mode)
9702 static int trigger_sides[4] =
9704 CH_SIDE_RIGHT, /* moving left */
9705 CH_SIDE_LEFT, /* moving right */
9706 CH_SIDE_BOTTOM, /* moving up */
9707 CH_SIDE_TOP, /* moving down */
9710 boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0,0));
9712 int jx = oldx, jy = oldy;
9713 int dx = x - jx, dy = y - jy;
9714 int nextx = x + dx, nexty = y + dy;
9715 int move_direction = (dx == -1 ? MV_LEFT :
9716 dx == +1 ? MV_RIGHT :
9718 dy == +1 ? MV_DOWN : MV_NO_MOVING);
9719 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
9720 int dig_side = trigger_sides[MV_DIR_BIT(move_direction)];
9721 int old_element = Feld[jx][jy];
9724 if (player->MovPos == 0)
9726 player->is_digging = FALSE;
9727 player->is_collecting = FALSE;
9730 if (player->MovPos == 0) /* last pushing move finished */
9731 player->is_pushing = FALSE;
9733 if (mode == DF_NO_PUSH) /* player just stopped pushing */
9735 player->is_switching = FALSE;
9736 player->push_delay = 0;
9738 return MF_NO_ACTION;
9741 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
9742 return MF_NO_ACTION;
9747 if (IS_TUBE(Feld[jx][jy]) || IS_TUBE(Back[jx][jy]))
9749 if (IS_TUBE(Feld[jx][jy]) ||
9750 (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0)))
9754 int tube_element = (IS_TUBE(Feld[jx][jy]) ? Feld[jx][jy] : Back[jx][jy]);
9755 int tube_leave_directions[][2] =
9757 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
9758 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
9759 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
9760 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
9761 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
9762 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
9763 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
9764 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
9765 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
9766 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
9767 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
9768 { -1, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
9771 while (tube_leave_directions[i][0] != tube_element)
9774 if (tube_leave_directions[i][0] == -1) /* should not happen */
9778 if (!(tube_leave_directions[i][1] & move_direction))
9779 return MF_NO_ACTION; /* tube has no opening in this direction */
9784 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
9785 old_element = Back[jx][jy];
9789 if (IS_WALKABLE(old_element) &&
9790 !(element_info[old_element].access_direction & move_direction))
9791 return MF_NO_ACTION; /* field has no opening in this direction */
9793 element = Feld[x][y];
9795 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
9796 game.engine_version >= VERSION_IDENT(2,2,0,0))
9797 return MF_NO_ACTION;
9801 case EL_SP_PORT_LEFT:
9802 case EL_SP_PORT_RIGHT:
9804 case EL_SP_PORT_DOWN:
9805 case EL_SP_PORT_HORIZONTAL:
9806 case EL_SP_PORT_VERTICAL:
9807 case EL_SP_PORT_ANY:
9808 case EL_SP_GRAVITY_PORT_LEFT:
9809 case EL_SP_GRAVITY_PORT_RIGHT:
9810 case EL_SP_GRAVITY_PORT_UP:
9811 case EL_SP_GRAVITY_PORT_DOWN:
9813 if (!canEnterSupaplexPort(x, y, dx, dy))
9814 return MF_NO_ACTION;
9817 element != EL_SP_PORT_LEFT &&
9818 element != EL_SP_GRAVITY_PORT_LEFT &&
9819 element != EL_SP_PORT_HORIZONTAL &&
9820 element != EL_SP_PORT_ANY) ||
9822 element != EL_SP_PORT_RIGHT &&
9823 element != EL_SP_GRAVITY_PORT_RIGHT &&
9824 element != EL_SP_PORT_HORIZONTAL &&
9825 element != EL_SP_PORT_ANY) ||
9827 element != EL_SP_PORT_UP &&
9828 element != EL_SP_GRAVITY_PORT_UP &&
9829 element != EL_SP_PORT_VERTICAL &&
9830 element != EL_SP_PORT_ANY) ||
9832 element != EL_SP_PORT_DOWN &&
9833 element != EL_SP_GRAVITY_PORT_DOWN &&
9834 element != EL_SP_PORT_VERTICAL &&
9835 element != EL_SP_PORT_ANY) ||
9836 !IN_LEV_FIELD(nextx, nexty) ||
9837 !IS_FREE(nextx, nexty))
9838 return MF_NO_ACTION;
9841 if (element == EL_SP_GRAVITY_PORT_LEFT ||
9842 element == EL_SP_GRAVITY_PORT_RIGHT ||
9843 element == EL_SP_GRAVITY_PORT_UP ||
9844 element == EL_SP_GRAVITY_PORT_DOWN)
9845 game.gravity = !game.gravity;
9847 /* automatically move to the next field with double speed */
9848 player->programmed_action = move_direction;
9850 if (player->move_delay_reset_counter == 0)
9852 player->move_delay_reset_counter = 2; /* two double speed steps */
9854 DOUBLE_PLAYER_SPEED(player);
9857 player->move_delay_reset_counter = 2;
9859 DOUBLE_PLAYER_SPEED(player);
9863 printf("::: passing port %d,%d [%d]\n", x, y, FrameCounter);
9866 PlayLevelSound(x, y, SND_CLASS_SP_PORT_PASSING);
9871 case EL_TUBE_VERTICAL:
9872 case EL_TUBE_HORIZONTAL:
9873 case EL_TUBE_VERTICAL_LEFT:
9874 case EL_TUBE_VERTICAL_RIGHT:
9875 case EL_TUBE_HORIZONTAL_UP:
9876 case EL_TUBE_HORIZONTAL_DOWN:
9877 case EL_TUBE_LEFT_UP:
9878 case EL_TUBE_LEFT_DOWN:
9879 case EL_TUBE_RIGHT_UP:
9880 case EL_TUBE_RIGHT_DOWN:
9883 int tube_enter_directions[][2] =
9885 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
9886 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
9887 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
9888 { EL_TUBE_VERTICAL_LEFT, MV_RIGHT | MV_UP | MV_DOWN },
9889 { EL_TUBE_VERTICAL_RIGHT, MV_LEFT | MV_UP | MV_DOWN },
9890 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_DOWN },
9891 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_UP },
9892 { EL_TUBE_LEFT_UP, MV_RIGHT | MV_DOWN },
9893 { EL_TUBE_LEFT_DOWN, MV_RIGHT | MV_UP },
9894 { EL_TUBE_RIGHT_UP, MV_LEFT | MV_DOWN },
9895 { EL_TUBE_RIGHT_DOWN, MV_LEFT | MV_UP },
9896 { -1, MV_NO_MOVING }
9899 while (tube_enter_directions[i][0] != element)
9902 if (tube_enter_directions[i][0] == -1) /* should not happen */
9906 if (!(tube_enter_directions[i][1] & move_direction))
9907 return MF_NO_ACTION; /* tube has no opening in this direction */
9909 PlayLevelSound(x, y, SND_CLASS_TUBE_WALKING);
9916 if (IS_WALKABLE(element))
9918 int sound_action = ACTION_WALKING;
9920 if (!(element_info[element].access_direction & opposite_direction))
9921 return MF_NO_ACTION; /* field not accessible from this direction */
9923 if (element >= EL_GATE_1 && element <= EL_GATE_4)
9925 if (!player->key[element - EL_GATE_1])
9926 return MF_NO_ACTION;
9928 else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY)
9930 if (!player->key[element - EL_GATE_1_GRAY])
9931 return MF_NO_ACTION;
9933 else if (element == EL_EXIT_OPEN ||
9934 element == EL_SP_EXIT_OPEN ||
9935 element == EL_SP_EXIT_OPENING)
9937 sound_action = ACTION_PASSING; /* player is passing exit */
9939 else if (element == EL_EMPTY)
9941 sound_action = ACTION_MOVING; /* nothing to walk on */
9944 /* play sound from background or player, whatever is available */
9945 if (element_info[element].sound[sound_action] != SND_UNDEFINED)
9946 PlayLevelSoundElementAction(x, y, element, sound_action);
9948 PlayLevelSoundElementAction(x, y, player->element_nr, sound_action);
9952 else if (IS_PASSABLE(element))
9954 if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
9955 return MF_NO_ACTION;
9957 if (IS_CUSTOM_ELEMENT(element) &&
9958 !(element_info[element].access_direction & opposite_direction))
9959 return MF_NO_ACTION; /* field not accessible from this direction */
9962 if (CAN_MOVE(element)) /* only fixed elements can be passed! */
9963 return MF_NO_ACTION;
9966 if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4)
9968 if (!player->key[element - EL_EM_GATE_1])
9969 return MF_NO_ACTION;
9971 else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY)
9973 if (!player->key[element - EL_EM_GATE_1_GRAY])
9974 return MF_NO_ACTION;
9977 /* automatically move to the next field with double speed */
9978 player->programmed_action = move_direction;
9980 if (player->move_delay_reset_counter == 0)
9982 player->move_delay_reset_counter = 2; /* two double speed steps */
9984 DOUBLE_PLAYER_SPEED(player);
9987 player->move_delay_reset_counter = 2;
9989 DOUBLE_PLAYER_SPEED(player);
9992 PlayLevelSoundAction(x, y, ACTION_PASSING);
9996 else if (IS_DIGGABLE(element))
10000 if (mode != DF_SNAP)
10003 GfxElement[x][y] = GFX_ELEMENT(element);
10006 (GFX_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
10008 player->is_digging = TRUE;
10011 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
10013 CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_DIGGED,
10014 player->index_bit, CH_SIDE_ANY);
10017 if (mode == DF_SNAP)
10018 TestIfElementTouchesCustomElement(x, y); /* for empty space */
10023 else if (IS_COLLECTIBLE(element))
10027 if (mode != DF_SNAP)
10029 GfxElement[x][y] = element;
10030 player->is_collecting = TRUE;
10033 if (element == EL_SPEED_PILL)
10034 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
10035 else if (element == EL_EXTRA_TIME && level.time > 0)
10038 DrawGameValue_Time(TimeLeft);
10040 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
10042 player->shield_normal_time_left += 10;
10043 if (element == EL_SHIELD_DEADLY)
10044 player->shield_deadly_time_left += 10;
10046 else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
10048 if (player->inventory_size < MAX_INVENTORY_SIZE)
10049 player->inventory_element[player->inventory_size++] = element;
10051 DrawGameValue_Dynamite(local_player->inventory_size);
10053 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
10055 player->dynabomb_count++;
10056 player->dynabombs_left++;
10058 else if (element == EL_DYNABOMB_INCREASE_SIZE)
10060 player->dynabomb_size++;
10062 else if (element == EL_DYNABOMB_INCREASE_POWER)
10064 player->dynabomb_xl = TRUE;
10066 else if ((element >= EL_KEY_1 && element <= EL_KEY_4) ||
10067 (element >= EL_EM_KEY_1 && element <= EL_EM_KEY_4))
10069 int key_nr = (element >= EL_KEY_1 && element <= EL_KEY_4 ?
10070 element - EL_KEY_1 : element - EL_EM_KEY_1);
10072 player->key[key_nr] = TRUE;
10074 DrawGameValue_Keys(player);
10076 redraw_mask |= REDRAW_DOOR_1;
10078 else if (IS_ENVELOPE(element))
10081 player->show_envelope = element;
10083 ShowEnvelope(element - EL_ENVELOPE_1);
10086 else if (IS_DROPPABLE(element)) /* can be collected and dropped */
10090 if (element_info[element].collect_count == 0)
10091 player->inventory_infinite_element = element;
10093 for (i = 0; i < element_info[element].collect_count; i++)
10094 if (player->inventory_size < MAX_INVENTORY_SIZE)
10095 player->inventory_element[player->inventory_size++] = element;
10097 DrawGameValue_Dynamite(local_player->inventory_size);
10099 else if (element_info[element].collect_count > 0)
10101 local_player->gems_still_needed -=
10102 element_info[element].collect_count;
10103 if (local_player->gems_still_needed < 0)
10104 local_player->gems_still_needed = 0;
10106 DrawGameValue_Emeralds(local_player->gems_still_needed);
10109 RaiseScoreElement(element);
10110 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
10112 CheckTriggeredElementChangePlayer(x, y, element,
10113 CE_OTHER_GETS_COLLECTED,
10114 player->index_bit, CH_SIDE_ANY);
10117 if (mode == DF_SNAP)
10118 TestIfElementTouchesCustomElement(x, y); /* for empty space */
10123 else if (IS_PUSHABLE(element))
10125 if (mode == DF_SNAP && element != EL_BD_ROCK)
10126 return MF_NO_ACTION;
10128 if (CAN_FALL(element) && dy)
10129 return MF_NO_ACTION;
10131 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
10132 !(element == EL_SPRING && level.use_spring_bug))
10133 return MF_NO_ACTION;
10136 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
10137 ((move_direction & MV_VERTICAL &&
10138 ((element_info[element].move_pattern & MV_LEFT &&
10139 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
10140 (element_info[element].move_pattern & MV_RIGHT &&
10141 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
10142 (move_direction & MV_HORIZONTAL &&
10143 ((element_info[element].move_pattern & MV_UP &&
10144 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
10145 (element_info[element].move_pattern & MV_DOWN &&
10146 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
10147 return MF_NO_ACTION;
10151 /* do not push elements already moving away faster than player */
10152 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
10153 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
10154 return MF_NO_ACTION;
10156 if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
10157 return MF_NO_ACTION;
10161 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
10163 if (player->push_delay_value == -1)
10164 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10166 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
10168 if (!player->is_pushing)
10169 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10173 if (game.engine_version >= VERSION_IDENT(2,2,0,7) &&
10174 (game.engine_version < VERSION_IDENT(3,0,7,1) ||
10175 !player_is_pushing))
10176 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10179 if (!player->is_pushing &&
10180 game.engine_version >= VERSION_IDENT(2,2,0,7))
10181 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10185 printf("::: push delay: %ld [%d, %d] [%d]\n",
10186 player->push_delay_value, FrameCounter, game.engine_version,
10187 player->is_pushing);
10190 player->is_pushing = TRUE;
10192 if (!(IN_LEV_FIELD(nextx, nexty) &&
10193 (IS_FREE(nextx, nexty) ||
10194 (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
10195 IS_SB_ELEMENT(element)))))
10196 return MF_NO_ACTION;
10198 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
10199 return MF_NO_ACTION;
10201 if (player->push_delay == 0) /* new pushing; restart delay */
10202 player->push_delay = FrameCounter;
10204 if (!FrameReached(&player->push_delay, player->push_delay_value) &&
10205 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
10206 element != EL_SPRING && element != EL_BALLOON)
10208 /* make sure that there is no move delay before next try to push */
10209 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
10210 player->move_delay = INITIAL_MOVE_DELAY_OFF;
10212 return MF_NO_ACTION;
10216 printf("::: NOW PUSHING... [%d]\n", FrameCounter);
10219 if (IS_SB_ELEMENT(element))
10221 if (element == EL_SOKOBAN_FIELD_FULL)
10223 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
10224 local_player->sokobanfields_still_needed++;
10227 if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
10229 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
10230 local_player->sokobanfields_still_needed--;
10233 Feld[x][y] = EL_SOKOBAN_OBJECT;
10235 if (Back[x][y] == Back[nextx][nexty])
10236 PlayLevelSoundAction(x, y, ACTION_PUSHING);
10237 else if (Back[x][y] != 0)
10238 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
10241 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
10244 if (local_player->sokobanfields_still_needed == 0 &&
10245 game.emulation == EMU_SOKOBAN)
10247 player->LevelSolved = player->GameOver = TRUE;
10248 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
10252 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
10254 InitMovingField(x, y, move_direction);
10255 GfxAction[x][y] = ACTION_PUSHING;
10257 if (mode == DF_SNAP)
10258 ContinueMoving(x, y);
10260 MovPos[x][y] = (dx != 0 ? dx : dy);
10262 Pushed[x][y] = TRUE;
10263 Pushed[nextx][nexty] = TRUE;
10265 if (game.engine_version < VERSION_IDENT(2,2,0,7))
10266 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10268 player->push_delay_value = -1; /* get new value later */
10270 CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PUSHED,
10271 player->index_bit, dig_side);
10272 CheckElementChangePlayer(x, y, element, CE_PUSHED_BY_PLAYER,
10273 player->index_bit, dig_side);
10277 else if (IS_SWITCHABLE(element))
10279 if (PLAYER_SWITCHING(player, x, y))
10282 player->is_switching = TRUE;
10283 player->switch_x = x;
10284 player->switch_y = y;
10286 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
10288 if (element == EL_ROBOT_WHEEL)
10290 Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
10294 DrawLevelField(x, y);
10296 else if (element == EL_SP_TERMINAL)
10300 for (yy = 0; yy < lev_fieldy; yy++) for (xx=0; xx < lev_fieldx; xx++)
10302 if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
10304 else if (Feld[xx][yy] == EL_SP_TERMINAL)
10305 Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
10308 else if (IS_BELT_SWITCH(element))
10310 ToggleBeltSwitch(x, y);
10312 else if (element == EL_SWITCHGATE_SWITCH_UP ||
10313 element == EL_SWITCHGATE_SWITCH_DOWN)
10315 ToggleSwitchgateSwitch(x, y);
10317 else if (element == EL_LIGHT_SWITCH ||
10318 element == EL_LIGHT_SWITCH_ACTIVE)
10320 ToggleLightSwitch(x, y);
10323 PlayLevelSound(x, y, element == EL_LIGHT_SWITCH ?
10324 SND_LIGHT_SWITCH_ACTIVATING :
10325 SND_LIGHT_SWITCH_DEACTIVATING);
10328 else if (element == EL_TIMEGATE_SWITCH)
10330 ActivateTimegateSwitch(x, y);
10332 else if (element == EL_BALLOON_SWITCH_LEFT ||
10333 element == EL_BALLOON_SWITCH_RIGHT ||
10334 element == EL_BALLOON_SWITCH_UP ||
10335 element == EL_BALLOON_SWITCH_DOWN ||
10336 element == EL_BALLOON_SWITCH_ANY)
10338 if (element == EL_BALLOON_SWITCH_ANY)
10339 game.balloon_dir = move_direction;
10341 game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
10342 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
10343 element == EL_BALLOON_SWITCH_UP ? MV_UP :
10344 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
10347 else if (element == EL_LAMP)
10349 Feld[x][y] = EL_LAMP_ACTIVE;
10350 local_player->lights_still_needed--;
10352 DrawLevelField(x, y);
10354 else if (element == EL_TIME_ORB_FULL)
10356 Feld[x][y] = EL_TIME_ORB_EMPTY;
10358 DrawGameValue_Time(TimeLeft);
10360 DrawLevelField(x, y);
10363 PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
10371 if (!PLAYER_SWITCHING(player, x, y))
10373 player->is_switching = TRUE;
10374 player->switch_x = x;
10375 player->switch_y = y;
10377 CheckTriggeredElementChangePlayer(x, y, element,
10378 CE_OTHER_IS_SWITCHING,
10379 player->index_bit, dig_side);
10380 CheckElementChangePlayer(x, y, element, CE_SWITCHED,
10381 player->index_bit, dig_side);
10384 CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PRESSED,
10385 player->index_bit, dig_side);
10386 CheckElementChangePlayer(x, y, element, CE_PRESSED_BY_PLAYER,
10387 player->index_bit, dig_side);
10390 return MF_NO_ACTION;
10393 player->push_delay = 0;
10395 if (Feld[x][y] != element) /* really digged/collected something */
10396 player->is_collecting = !player->is_digging;
10401 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
10403 int jx = player->jx, jy = player->jy;
10404 int x = jx + dx, y = jy + dy;
10405 int snap_direction = (dx == -1 ? MV_LEFT :
10406 dx == +1 ? MV_RIGHT :
10408 dy == +1 ? MV_DOWN : MV_NO_MOVING);
10411 if (player->MovPos)
10414 if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0,0))
10418 if (!player->active || !IN_LEV_FIELD(x, y))
10426 if (player->MovPos == 0)
10427 player->is_pushing = FALSE;
10429 player->is_snapping = FALSE;
10431 if (player->MovPos == 0)
10433 player->is_moving = FALSE;
10434 player->is_digging = FALSE;
10435 player->is_collecting = FALSE;
10441 if (player->is_snapping)
10444 player->MovDir = snap_direction;
10447 if (player->MovPos == 0)
10450 player->is_moving = FALSE;
10451 player->is_digging = FALSE;
10452 player->is_collecting = FALSE;
10455 player->is_dropping = FALSE;
10457 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
10460 player->is_snapping = TRUE;
10463 if (player->MovPos == 0)
10466 player->is_moving = FALSE;
10467 player->is_digging = FALSE;
10468 player->is_collecting = FALSE;
10471 DrawLevelField(x, y);
10477 boolean DropElement(struct PlayerInfo *player)
10479 int jx = player->jx, jy = player->jy;
10480 int old_element = Feld[jx][jy];
10481 int new_element = (player->inventory_size > 0 ?
10482 player->inventory_element[player->inventory_size - 1] :
10483 player->inventory_infinite_element != EL_UNDEFINED ?
10484 player->inventory_infinite_element :
10485 player->dynabombs_left > 0 ?
10486 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
10489 /* check if player is active, not moving and ready to drop */
10490 if (!player->active || player->MovPos || player->drop_delay > 0)
10493 /* check if player has anything that can be dropped */
10495 if (new_element == EL_UNDEFINED)
10498 if (player->inventory_size == 0 &&
10499 player->inventory_infinite_element == EL_UNDEFINED &&
10500 player->dynabombs_left == 0)
10504 /* check if anything can be dropped at the current position */
10505 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
10508 /* collected custom elements can only be dropped on empty fields */
10510 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
10513 if (player->inventory_size > 0 &&
10514 IS_CUSTOM_ELEMENT(player->inventory_element[player->inventory_size - 1])
10515 && old_element != EL_EMPTY)
10519 if (old_element != EL_EMPTY)
10520 Back[jx][jy] = old_element; /* store old element on this field */
10522 ResetGfxAnimation(jx, jy);
10523 ResetRandomAnimationValue(jx, jy);
10525 if (player->inventory_size > 0 ||
10526 player->inventory_infinite_element != EL_UNDEFINED)
10528 if (player->inventory_size > 0)
10530 player->inventory_size--;
10533 new_element = player->inventory_element[player->inventory_size];
10536 DrawGameValue_Dynamite(local_player->inventory_size);
10538 if (new_element == EL_DYNAMITE)
10539 new_element = EL_DYNAMITE_ACTIVE;
10540 else if (new_element == EL_SP_DISK_RED)
10541 new_element = EL_SP_DISK_RED_ACTIVE;
10544 Feld[jx][jy] = new_element;
10546 if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
10547 DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
10549 PlayLevelSoundAction(jx, jy, ACTION_DROPPING);
10552 /* needed if previous element just changed to "empty" in the last frame */
10553 Changed[jx][jy] = 0; /* allow another change */
10556 CheckTriggeredElementChangePlayer(jx, jy, new_element,
10557 CE_OTHER_GETS_DROPPED,
10558 player->index_bit, CH_SIDE_ANY);
10559 CheckElementChangePlayer(jx, jy, new_element, CE_DROPPED_BY_PLAYER,
10560 player->index_bit, CH_SIDE_ANY);
10562 TestIfElementTouchesCustomElement(jx, jy);
10564 else /* player is dropping a dyna bomb */
10566 player->dynabombs_left--;
10569 new_element = EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr;
10572 Feld[jx][jy] = new_element;
10574 if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
10575 DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
10577 PlayLevelSoundAction(jx, jy, ACTION_DROPPING);
10584 if (Feld[jx][jy] == new_element) /* uninitialized unless CE change */
10587 InitField_WithBug1(jx, jy, FALSE);
10589 InitField(jx, jy, FALSE);
10590 if (CAN_MOVE(Feld[jx][jy]))
10591 InitMovDir(jx, jy);
10595 new_element = Feld[jx][jy];
10597 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
10598 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
10600 int move_stepsize = element_info[new_element].move_stepsize;
10601 int direction, dx, dy, nextx, nexty;
10603 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
10604 MovDir[jx][jy] = player->MovDir;
10606 direction = MovDir[jx][jy];
10607 dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
10608 dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
10612 if (IN_LEV_FIELD(nextx, nexty) && IS_FREE(nextx, nexty))
10615 WasJustMoving[jx][jy] = 3;
10617 InitMovingField(jx, jy, direction);
10618 ContinueMoving(jx, jy);
10623 Changed[jx][jy] = 0; /* allow another change */
10626 TestIfElementHitsCustomElement(jx, jy, direction);
10628 CheckElementChangeSide(jx, jy, new_element, CE_HITTING_SOMETHING,
10633 player->drop_delay = 2 * TILEX / move_stepsize + 1;
10637 player->drop_delay = 8 + 8 + 8;
10642 player->is_dropping = TRUE;
10648 /* ------------------------------------------------------------------------- */
10649 /* game sound playing functions */
10650 /* ------------------------------------------------------------------------- */
10652 static int *loop_sound_frame = NULL;
10653 static int *loop_sound_volume = NULL;
10655 void InitPlayLevelSound()
10657 int num_sounds = getSoundListSize();
10659 checked_free(loop_sound_frame);
10660 checked_free(loop_sound_volume);
10662 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
10663 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
10666 static void PlayLevelSound(int x, int y, int nr)
10668 int sx = SCREENX(x), sy = SCREENY(y);
10669 int volume, stereo_position;
10670 int max_distance = 8;
10671 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
10673 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
10674 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
10677 if (!IN_LEV_FIELD(x, y) ||
10678 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
10679 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
10682 volume = SOUND_MAX_VOLUME;
10684 if (!IN_SCR_FIELD(sx, sy))
10686 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
10687 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
10689 volume -= volume * (dx > dy ? dx : dy) / max_distance;
10692 stereo_position = (SOUND_MAX_LEFT +
10693 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
10694 (SCR_FIELDX + 2 * max_distance));
10696 if (IS_LOOP_SOUND(nr))
10698 /* This assures that quieter loop sounds do not overwrite louder ones,
10699 while restarting sound volume comparison with each new game frame. */
10701 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
10704 loop_sound_volume[nr] = volume;
10705 loop_sound_frame[nr] = FrameCounter;
10708 PlaySoundExt(nr, volume, stereo_position, type);
10711 static void PlayLevelSoundNearest(int x, int y, int sound_action)
10713 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
10714 x > LEVELX(BX2) ? LEVELX(BX2) : x,
10715 y < LEVELY(BY1) ? LEVELY(BY1) :
10716 y > LEVELY(BY2) ? LEVELY(BY2) : y,
10720 static void PlayLevelSoundAction(int x, int y, int action)
10722 PlayLevelSoundElementAction(x, y, Feld[x][y], action);
10725 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
10727 int sound_effect = element_info[element].sound[action];
10729 if (sound_effect != SND_UNDEFINED)
10730 PlayLevelSound(x, y, sound_effect);
10733 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
10736 int sound_effect = element_info[element].sound[action];
10738 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10739 PlayLevelSound(x, y, sound_effect);
10742 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
10744 int sound_effect = element_info[Feld[x][y]].sound[action];
10746 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10747 PlayLevelSound(x, y, sound_effect);
10750 static void StopLevelSoundActionIfLoop(int x, int y, int action)
10752 int sound_effect = element_info[Feld[x][y]].sound[action];
10754 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10755 StopSound(sound_effect);
10758 static void PlayLevelMusic()
10760 if (levelset.music[level_nr] != MUS_UNDEFINED)
10761 PlayMusic(levelset.music[level_nr]); /* from config file */
10763 PlayMusic(MAP_NOCONF_MUSIC(level_nr)); /* from music dir */
10766 void RaiseScore(int value)
10768 local_player->score += value;
10770 DrawGameValue_Score(local_player->score);
10773 void RaiseScoreElement(int element)
10778 case EL_BD_DIAMOND:
10779 case EL_EMERALD_YELLOW:
10780 case EL_EMERALD_RED:
10781 case EL_EMERALD_PURPLE:
10782 case EL_SP_INFOTRON:
10783 RaiseScore(level.score[SC_EMERALD]);
10786 RaiseScore(level.score[SC_DIAMOND]);
10789 RaiseScore(level.score[SC_CRYSTAL]);
10792 RaiseScore(level.score[SC_PEARL]);
10795 case EL_BD_BUTTERFLY:
10796 case EL_SP_ELECTRON:
10797 RaiseScore(level.score[SC_BUG]);
10800 case EL_BD_FIREFLY:
10801 case EL_SP_SNIKSNAK:
10802 RaiseScore(level.score[SC_SPACESHIP]);
10805 case EL_DARK_YAMYAM:
10806 RaiseScore(level.score[SC_YAMYAM]);
10809 RaiseScore(level.score[SC_ROBOT]);
10812 RaiseScore(level.score[SC_PACMAN]);
10815 RaiseScore(level.score[SC_NUT]);
10818 case EL_SP_DISK_RED:
10819 case EL_DYNABOMB_INCREASE_NUMBER:
10820 case EL_DYNABOMB_INCREASE_SIZE:
10821 case EL_DYNABOMB_INCREASE_POWER:
10822 RaiseScore(level.score[SC_DYNAMITE]);
10824 case EL_SHIELD_NORMAL:
10825 case EL_SHIELD_DEADLY:
10826 RaiseScore(level.score[SC_SHIELD]);
10828 case EL_EXTRA_TIME:
10829 RaiseScore(level.score[SC_TIME_BONUS]);
10835 RaiseScore(level.score[SC_KEY]);
10838 RaiseScore(element_info[element].collect_score);
10843 void RequestQuitGame(boolean ask_if_really_quit)
10845 if (AllPlayersGone ||
10846 !ask_if_really_quit ||
10847 level_editor_test_game ||
10848 Request("Do you really want to quit the game ?",
10849 REQ_ASK | REQ_STAY_CLOSED))
10851 #if defined(PLATFORM_UNIX)
10852 if (options.network)
10853 SendToServer_StopPlaying();
10857 game_status = GAME_MODE_MAIN;
10865 if (tape.playing && tape.index_search)
10867 SetDrawDeactivationMask(REDRAW_NONE);
10868 audio.sound_deactivated = FALSE;
10872 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
10875 if (tape.playing && tape.index_search)
10877 SetDrawDeactivationMask(REDRAW_FIELD);
10878 audio.sound_deactivated = TRUE;
10886 /* ---------- new game button stuff ---------------------------------------- */
10888 /* graphic position values for game buttons */
10889 #define GAME_BUTTON_XSIZE 30
10890 #define GAME_BUTTON_YSIZE 30
10891 #define GAME_BUTTON_XPOS 5
10892 #define GAME_BUTTON_YPOS 215
10893 #define SOUND_BUTTON_XPOS 5
10894 #define SOUND_BUTTON_YPOS (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
10896 #define GAME_BUTTON_STOP_XPOS (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
10897 #define GAME_BUTTON_PAUSE_XPOS (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
10898 #define GAME_BUTTON_PLAY_XPOS (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
10899 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
10900 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
10901 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
10908 } gamebutton_info[NUM_GAME_BUTTONS] =
10911 GAME_BUTTON_STOP_XPOS, GAME_BUTTON_YPOS,
10916 GAME_BUTTON_PAUSE_XPOS, GAME_BUTTON_YPOS,
10917 GAME_CTRL_ID_PAUSE,
10921 GAME_BUTTON_PLAY_XPOS, GAME_BUTTON_YPOS,
10926 SOUND_BUTTON_MUSIC_XPOS, SOUND_BUTTON_YPOS,
10927 SOUND_CTRL_ID_MUSIC,
10928 "background music on/off"
10931 SOUND_BUTTON_LOOPS_XPOS, SOUND_BUTTON_YPOS,
10932 SOUND_CTRL_ID_LOOPS,
10933 "sound loops on/off"
10936 SOUND_BUTTON_SIMPLE_XPOS, SOUND_BUTTON_YPOS,
10937 SOUND_CTRL_ID_SIMPLE,
10938 "normal sounds on/off"
10942 void CreateGameButtons()
10946 for (i = 0; i < NUM_GAME_BUTTONS; i++)
10948 Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
10949 struct GadgetInfo *gi;
10952 unsigned long event_mask;
10953 int gd_xoffset, gd_yoffset;
10954 int gd_x1, gd_x2, gd_y1, gd_y2;
10957 gd_xoffset = gamebutton_info[i].x;
10958 gd_yoffset = gamebutton_info[i].y;
10959 gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
10960 gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
10962 if (id == GAME_CTRL_ID_STOP ||
10963 id == GAME_CTRL_ID_PAUSE ||
10964 id == GAME_CTRL_ID_PLAY)
10966 button_type = GD_TYPE_NORMAL_BUTTON;
10968 event_mask = GD_EVENT_RELEASED;
10969 gd_y1 = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10970 gd_y2 = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10974 button_type = GD_TYPE_CHECK_BUTTON;
10976 ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
10977 (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
10978 (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
10979 event_mask = GD_EVENT_PRESSED;
10980 gd_y1 = DOOR_GFX_PAGEY1 + gd_yoffset;
10981 gd_y2 = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10984 gi = CreateGadget(GDI_CUSTOM_ID, id,
10985 GDI_INFO_TEXT, gamebutton_info[i].infotext,
10986 GDI_X, DX + gd_xoffset,
10987 GDI_Y, DY + gd_yoffset,
10988 GDI_WIDTH, GAME_BUTTON_XSIZE,
10989 GDI_HEIGHT, GAME_BUTTON_YSIZE,
10990 GDI_TYPE, button_type,
10991 GDI_STATE, GD_BUTTON_UNPRESSED,
10992 GDI_CHECKED, checked,
10993 GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
10994 GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
10995 GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
10996 GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
10997 GDI_EVENT_MASK, event_mask,
10998 GDI_CALLBACK_ACTION, HandleGameButtons,
11002 Error(ERR_EXIT, "cannot create gadget");
11004 game_gadget[id] = gi;
11008 void FreeGameButtons()
11012 for (i = 0; i < NUM_GAME_BUTTONS; i++)
11013 FreeGadget(game_gadget[i]);
11016 static void MapGameButtons()
11020 for (i = 0; i < NUM_GAME_BUTTONS; i++)
11021 MapGadget(game_gadget[i]);
11024 void UnmapGameButtons()
11028 for (i = 0; i < NUM_GAME_BUTTONS; i++)
11029 UnmapGadget(game_gadget[i]);
11032 static void HandleGameButtons(struct GadgetInfo *gi)
11034 int id = gi->custom_id;
11036 if (game_status != GAME_MODE_PLAYING)
11041 case GAME_CTRL_ID_STOP:
11042 RequestQuitGame(TRUE);
11045 case GAME_CTRL_ID_PAUSE:
11046 if (options.network)
11048 #if defined(PLATFORM_UNIX)
11050 SendToServer_ContinuePlaying();
11052 SendToServer_PausePlaying();
11056 TapeTogglePause(TAPE_TOGGLE_MANUAL);
11059 case GAME_CTRL_ID_PLAY:
11062 #if defined(PLATFORM_UNIX)
11063 if (options.network)
11064 SendToServer_ContinuePlaying();
11068 tape.pausing = FALSE;
11069 DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
11074 case SOUND_CTRL_ID_MUSIC:
11075 if (setup.sound_music)
11077 setup.sound_music = FALSE;
11080 else if (audio.music_available)
11082 setup.sound = setup.sound_music = TRUE;
11084 SetAudioMode(setup.sound);
11090 case SOUND_CTRL_ID_LOOPS:
11091 if (setup.sound_loops)
11092 setup.sound_loops = FALSE;
11093 else if (audio.loops_available)
11095 setup.sound = setup.sound_loops = TRUE;
11096 SetAudioMode(setup.sound);
11100 case SOUND_CTRL_ID_SIMPLE:
11101 if (setup.sound_simple)
11102 setup.sound_simple = FALSE;
11103 else if (audio.sound_available)
11105 setup.sound = setup.sound_simple = TRUE;
11106 SetAudioMode(setup.sound);