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 GET_TARGET_ELEMENT(e, ch) \
107 ((e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
108 (e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : (e))
110 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
111 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
114 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
115 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
116 (CAN_MOVE_INTO_ACID(e) && \
117 Feld[x][y] == EL_ACID) || \
120 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
121 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
122 (CAN_MOVE_INTO_ACID(e) && \
123 Feld[x][y] == EL_ACID) || \
126 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
127 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
129 (CAN_MOVE_INTO_ACID(e) && \
130 Feld[x][y] == EL_ACID) || \
131 (DONT_COLLIDE_WITH(e) && \
133 !PLAYER_ENEMY_PROTECTED(x, y))))
136 #define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition) \
137 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
139 (DONT_COLLIDE_WITH(e) && \
141 !PLAYER_ENEMY_PROTECTED(x, y))))
144 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
145 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
148 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
149 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
151 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
152 ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, Feld[x][y] == EL_ACID)
156 #define ENEMY_CAN_ENTER_FIELD(e, x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
159 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
160 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
164 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
165 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Feld[x][y] == EL_DIAMOND)
167 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
168 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Feld[x][y]))
170 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
171 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Feld[x][y]))
173 #define PIG_CAN_ENTER_FIELD(e, x, y) \
174 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Feld[x][y]))
176 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
177 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Feld[x][y] == EL_EXIT_OPEN ||\
178 IS_FOOD_PENGUIN(Feld[x][y])))
179 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
180 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
182 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
183 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
185 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
186 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
190 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
191 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
192 (CAN_MOVE_INTO_ACID(e) && \
193 Feld[x][y] == EL_ACID) || \
194 Feld[x][y] == EL_DIAMOND))
196 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
197 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
198 (CAN_MOVE_INTO_ACID(e) && \
199 Feld[x][y] == EL_ACID) || \
200 IS_FOOD_DARK_YAMYAM(Feld[x][y])))
202 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
203 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
204 (CAN_MOVE_INTO_ACID(e) && \
205 Feld[x][y] == EL_ACID) || \
206 IS_AMOEBOID(Feld[x][y])))
208 #define PIG_CAN_ENTER_FIELD(e, x, y) \
209 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
210 (CAN_MOVE_INTO_ACID(e) && \
211 Feld[x][y] == EL_ACID) || \
212 IS_FOOD_PIG(Feld[x][y])))
214 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
215 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
216 (CAN_MOVE_INTO_ACID(e) && \
217 Feld[x][y] == EL_ACID) || \
218 IS_FOOD_PENGUIN(Feld[x][y]) || \
219 Feld[x][y] == EL_EXIT_OPEN))
221 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
222 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
223 (CAN_MOVE_INTO_ACID(e) && \
224 Feld[x][y] == EL_ACID)))
226 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
227 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
228 (CAN_MOVE_INTO_ACID(e) && \
229 Feld[x][y] == EL_ACID) || \
232 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
233 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
234 (CAN_MOVE_INTO_ACID(e) && \
235 Feld[x][y] == EL_ACID)))
239 #define GROUP_NR(e) ((e) - EL_GROUP_START)
240 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
241 #define IS_IN_GROUP(e, nr) (element_info[e].in_group[nr] == TRUE)
242 #define IS_IN_GROUP_EL(e, ge) (IS_IN_GROUP(e, (ge) - EL_GROUP_START))
244 #define IS_EQUAL_OR_IN_GROUP(e, ge) \
245 (IS_GROUP_ELEMENT(ge) ? IS_IN_GROUP(e, GROUP_NR(ge)) : (e) == (ge))
248 #define CE_ENTER_FIELD_COND(e, x, y) \
249 (!IS_PLAYER(x, y) && \
250 (Feld[x][y] == EL_ACID || \
251 IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e))))
253 #define CE_ENTER_FIELD_COND(e, x, y) \
254 (!IS_PLAYER(x, y) && \
255 IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e)))
258 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
259 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
261 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
262 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
264 /* game button identifiers */
265 #define GAME_CTRL_ID_STOP 0
266 #define GAME_CTRL_ID_PAUSE 1
267 #define GAME_CTRL_ID_PLAY 2
268 #define SOUND_CTRL_ID_MUSIC 3
269 #define SOUND_CTRL_ID_LOOPS 4
270 #define SOUND_CTRL_ID_SIMPLE 5
272 #define NUM_GAME_BUTTONS 6
275 /* forward declaration for internal use */
277 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
278 static boolean MovePlayer(struct PlayerInfo *, int, int);
279 static void ScrollPlayer(struct PlayerInfo *, int);
280 static void ScrollScreen(struct PlayerInfo *, int);
282 int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
284 static void InitBeltMovement(void);
285 static void CloseAllOpenTimegates(void);
286 static void CheckGravityMovement(struct PlayerInfo *);
287 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
288 static void KillHeroUnlessEnemyProtected(int, int);
289 static void KillHeroUnlessExplosionProtected(int, int);
291 static void TestIfPlayerTouchesCustomElement(int, int);
292 static void TestIfElementTouchesCustomElement(int, int);
293 static void TestIfElementHitsCustomElement(int, int, int);
295 static void TestIfElementSmashesCustomElement(int, int, int);
298 static void ChangeElement(int, int, int);
300 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
301 #define CheckTriggeredElementChange(x, y, e, ev) \
302 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, \
304 #define CheckTriggeredElementChangePlayer(x, y, e, ev, p, s) \
305 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
306 #define CheckTriggeredElementChangeSide(x, y, e, ev, s) \
307 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
308 #define CheckTriggeredElementChangePage(x, y, e, ev, p) \
309 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, \
312 static boolean CheckElementChangeExt(int, int, int, int, int, int, int, int);
313 #define CheckElementChange(x, y, e, te, ev) \
314 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY, -1)
315 #define CheckElementChangePlayer(x, y, e, ev, p, s) \
316 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s, CH_PAGE_ANY)
317 #define CheckElementChangeSide(x, y, e, te, ev, s) \
318 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s, CH_PAGE_ANY)
319 #define CheckElementChangePage(x, y, e, te, ev, p) \
320 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
322 static void PlayLevelSound(int, int, int);
323 static void PlayLevelSoundNearest(int, int, int);
324 static void PlayLevelSoundAction(int, int, int);
325 static void PlayLevelSoundElementAction(int, int, int, int);
326 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
327 static void PlayLevelSoundActionIfLoop(int, int, int);
328 static void StopLevelSoundActionIfLoop(int, int, int);
329 static void PlayLevelMusic();
331 static void MapGameButtons();
332 static void HandleGameButtons(struct GadgetInfo *);
334 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
337 /* ------------------------------------------------------------------------- */
338 /* definition of elements that automatically change to other elements after */
339 /* a specified time, eventually calling a function when changing */
340 /* ------------------------------------------------------------------------- */
342 /* forward declaration for changer functions */
343 static void InitBuggyBase(int x, int y);
344 static void WarnBuggyBase(int x, int y);
346 static void InitTrap(int x, int y);
347 static void ActivateTrap(int x, int y);
348 static void ChangeActiveTrap(int x, int y);
350 static void InitRobotWheel(int x, int y);
351 static void RunRobotWheel(int x, int y);
352 static void StopRobotWheel(int x, int y);
354 static void InitTimegateWheel(int x, int y);
355 static void RunTimegateWheel(int x, int y);
357 struct ChangingElementInfo
362 void (*pre_change_function)(int x, int y);
363 void (*change_function)(int x, int y);
364 void (*post_change_function)(int x, int y);
367 static struct ChangingElementInfo change_delay_list[] =
418 EL_SWITCHGATE_OPENING,
426 EL_SWITCHGATE_CLOSING,
427 EL_SWITCHGATE_CLOSED,
459 EL_ACID_SPLASH_RIGHT,
468 EL_SP_BUGGY_BASE_ACTIVATING,
475 EL_SP_BUGGY_BASE_ACTIVATING,
476 EL_SP_BUGGY_BASE_ACTIVE,
483 EL_SP_BUGGY_BASE_ACTIVE,
507 EL_ROBOT_WHEEL_ACTIVE,
515 EL_TIMEGATE_SWITCH_ACTIVE,
536 int push_delay_fixed, push_delay_random;
541 { EL_BALLOON, 0, 0 },
543 { EL_SOKOBAN_OBJECT, 2, 0 },
544 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
545 { EL_SATELLITE, 2, 0 },
546 { EL_SP_DISK_YELLOW, 2, 0 },
548 { EL_UNDEFINED, 0, 0 },
556 move_stepsize_list[] =
558 { EL_AMOEBA_DROP, 2 },
559 { EL_AMOEBA_DROPPING, 2 },
560 { EL_QUICKSAND_FILLING, 1 },
561 { EL_QUICKSAND_EMPTYING, 1 },
562 { EL_MAGIC_WALL_FILLING, 2 },
563 { EL_BD_MAGIC_WALL_FILLING, 2 },
564 { EL_MAGIC_WALL_EMPTYING, 2 },
565 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
575 collect_count_list[] =
578 { EL_BD_DIAMOND, 1 },
579 { EL_EMERALD_YELLOW, 1 },
580 { EL_EMERALD_RED, 1 },
581 { EL_EMERALD_PURPLE, 1 },
583 { EL_SP_INFOTRON, 1 },
597 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
598 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
599 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
600 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
601 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
602 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
603 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
604 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
605 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
606 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
607 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
612 static unsigned long trigger_events[MAX_NUM_ELEMENTS];
614 #define IS_AUTO_CHANGING(e) (element_info[e].change_events & \
615 CH_EVENT_BIT(CE_DELAY))
616 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
617 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Feld[x][y]) || \
618 IS_JUST_CHANGING(x, y))
620 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
623 void GetPlayerConfig()
625 if (!audio.sound_available)
626 setup.sound_simple = FALSE;
628 if (!audio.loops_available)
629 setup.sound_loops = FALSE;
631 if (!audio.music_available)
632 setup.sound_music = FALSE;
634 if (!video.fullscreen_available)
635 setup.fullscreen = FALSE;
637 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
639 SetAudioMode(setup.sound);
643 static int getBeltNrFromBeltElement(int element)
645 return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
646 element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
647 element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
650 static int getBeltNrFromBeltActiveElement(int element)
652 return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
653 element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
654 element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
657 static int getBeltNrFromBeltSwitchElement(int element)
659 return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
660 element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
661 element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
664 static int getBeltDirNrFromBeltSwitchElement(int element)
666 static int belt_base_element[4] =
668 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
669 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
670 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
671 EL_CONVEYOR_BELT_4_SWITCH_LEFT
674 int belt_nr = getBeltNrFromBeltSwitchElement(element);
675 int belt_dir_nr = element - belt_base_element[belt_nr];
677 return (belt_dir_nr % 3);
680 static int getBeltDirFromBeltSwitchElement(int element)
682 static int belt_move_dir[3] =
689 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
691 return belt_move_dir[belt_dir_nr];
694 static void InitPlayerField(int x, int y, int element, boolean init_game)
696 if (element == EL_SP_MURPHY)
700 if (stored_player[0].present)
702 Feld[x][y] = EL_SP_MURPHY_CLONE;
708 stored_player[0].use_murphy_graphic = TRUE;
711 Feld[x][y] = EL_PLAYER_1;
717 struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_PLAYER_1];
718 int jx = player->jx, jy = player->jy;
720 player->present = TRUE;
722 player->block_last_field = (element == EL_SP_MURPHY ?
723 level.sp_block_last_field :
724 level.block_last_field);
726 if (!options.network || player->connected)
728 player->active = TRUE;
730 /* remove potentially duplicate players */
731 if (StorePlayer[jx][jy] == Feld[x][y])
732 StorePlayer[jx][jy] = 0;
734 StorePlayer[x][y] = Feld[x][y];
738 printf("Player %d activated.\n", player->element_nr);
739 printf("[Local player is %d and currently %s.]\n",
740 local_player->element_nr,
741 local_player->active ? "active" : "not active");
745 Feld[x][y] = EL_EMPTY;
746 player->jx = player->last_jx = x;
747 player->jy = player->last_jy = y;
751 static void InitField(int x, int y, boolean init_game)
753 int element = Feld[x][y];
762 InitPlayerField(x, y, element, init_game);
765 case EL_SOKOBAN_FIELD_PLAYER:
766 element = Feld[x][y] = EL_PLAYER_1;
767 InitField(x, y, init_game);
769 element = Feld[x][y] = EL_SOKOBAN_FIELD_EMPTY;
770 InitField(x, y, init_game);
773 case EL_SOKOBAN_FIELD_EMPTY:
774 local_player->sokobanfields_still_needed++;
778 if (x < lev_fieldx-1 && Feld[x+1][y] == EL_ACID)
779 Feld[x][y] = EL_ACID_POOL_TOPLEFT;
780 else if (x > 0 && Feld[x-1][y] == EL_ACID)
781 Feld[x][y] = EL_ACID_POOL_TOPRIGHT;
782 else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPLEFT)
783 Feld[x][y] = EL_ACID_POOL_BOTTOMLEFT;
784 else if (y > 0 && Feld[x][y-1] == EL_ACID)
785 Feld[x][y] = EL_ACID_POOL_BOTTOM;
786 else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPRIGHT)
787 Feld[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
795 case EL_SPACESHIP_RIGHT:
796 case EL_SPACESHIP_UP:
797 case EL_SPACESHIP_LEFT:
798 case EL_SPACESHIP_DOWN:
800 case EL_BD_BUTTERFLY_RIGHT:
801 case EL_BD_BUTTERFLY_UP:
802 case EL_BD_BUTTERFLY_LEFT:
803 case EL_BD_BUTTERFLY_DOWN:
804 case EL_BD_BUTTERFLY:
805 case EL_BD_FIREFLY_RIGHT:
806 case EL_BD_FIREFLY_UP:
807 case EL_BD_FIREFLY_LEFT:
808 case EL_BD_FIREFLY_DOWN:
810 case EL_PACMAN_RIGHT:
834 if (y == lev_fieldy - 1)
836 Feld[x][y] = EL_AMOEBA_GROWING;
837 Store[x][y] = EL_AMOEBA_WET;
841 case EL_DYNAMITE_ACTIVE:
842 case EL_SP_DISK_RED_ACTIVE:
843 case EL_DYNABOMB_PLAYER_1_ACTIVE:
844 case EL_DYNABOMB_PLAYER_2_ACTIVE:
845 case EL_DYNABOMB_PLAYER_3_ACTIVE:
846 case EL_DYNABOMB_PLAYER_4_ACTIVE:
851 local_player->lights_still_needed++;
855 local_player->friends_still_needed++;
860 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
865 Feld[x][y] = EL_EMPTY;
870 case EL_EM_KEY_1_FILE:
871 Feld[x][y] = EL_EM_KEY_1;
873 case EL_EM_KEY_2_FILE:
874 Feld[x][y] = EL_EM_KEY_2;
876 case EL_EM_KEY_3_FILE:
877 Feld[x][y] = EL_EM_KEY_3;
879 case EL_EM_KEY_4_FILE:
880 Feld[x][y] = EL_EM_KEY_4;
884 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
885 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
886 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
887 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
888 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
889 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
890 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
891 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
892 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
893 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
894 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
895 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
898 int belt_nr = getBeltNrFromBeltSwitchElement(Feld[x][y]);
899 int belt_dir = getBeltDirFromBeltSwitchElement(Feld[x][y]);
900 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Feld[x][y]);
902 if (game.belt_dir_nr[belt_nr] == 3) /* initial value */
904 game.belt_dir[belt_nr] = belt_dir;
905 game.belt_dir_nr[belt_nr] = belt_dir_nr;
907 else /* more than one switch -- set it like the first switch */
909 Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
914 case EL_SWITCHGATE_SWITCH_DOWN: /* always start with same switch pos */
916 Feld[x][y] = EL_SWITCHGATE_SWITCH_UP;
919 case EL_LIGHT_SWITCH_ACTIVE:
921 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
925 if (IS_CUSTOM_ELEMENT(element) && CAN_MOVE(element))
927 else if (IS_GROUP_ELEMENT(element))
929 struct ElementGroupInfo *group = element_info[element].group;
930 int last_anim_random_frame = gfx.anim_random_frame;
933 if (group->choice_mode == ANIM_RANDOM)
934 gfx.anim_random_frame = RND(group->num_elements_resolved);
936 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
937 group->choice_mode, 0,
940 if (group->choice_mode == ANIM_RANDOM)
941 gfx.anim_random_frame = last_anim_random_frame;
945 Feld[x][y] = group->element_resolved[element_pos];
947 InitField(x, y, init_game);
953 static inline void InitField_WithBug1(int x, int y, boolean init_game)
955 InitField(x, y, init_game);
957 /* not needed to call InitMovDir() -- already done by InitField()! */
958 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
959 CAN_MOVE(Feld[x][y]))
963 static inline void InitField_WithBug2(int x, int y, boolean init_game)
965 int old_element = Feld[x][y];
967 InitField(x, y, init_game);
969 /* not needed to call InitMovDir() -- already done by InitField()! */
970 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
971 CAN_MOVE(old_element) &&
972 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
975 /* this case is in fact a combination of not less than three bugs:
976 first, it calls InitMovDir() for elements that can move, although this is
977 already done by InitField(); then, it checks the element that was at this
978 field _before_ the call to InitField() (which can change it)
983 inline void DrawGameValue_Emeralds(int value)
985 DrawText(DX_EMERALDS, DY_EMERALDS, int2str(value, 3), FONT_TEXT_2);
988 inline void DrawGameValue_Dynamite(int value)
990 DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(value, 3), FONT_TEXT_2);
993 inline void DrawGameValue_Keys(struct PlayerInfo *player)
997 for (i = 0; i < MAX_KEYS; i++)
999 DrawMiniGraphicExt(drawto, DX_KEYS + i * MINI_TILEX, DY_KEYS,
1000 el2edimg(EL_KEY_1 + i));
1003 inline void DrawGameValue_Score(int value)
1005 DrawText(DX_SCORE, DY_SCORE, int2str(value, 5), FONT_TEXT_2);
1008 inline void DrawGameValue_Time(int value)
1011 DrawText(DX_TIME1, DY_TIME, int2str(value, 3), FONT_TEXT_2);
1013 DrawText(DX_TIME2, DY_TIME, int2str(value, 4), FONT_LEVEL_NUMBER);
1016 inline void DrawGameValue_Level(int value)
1019 DrawText(DX_LEVEL, DY_LEVEL, int2str(value, 2), FONT_TEXT_2);
1022 /* misuse area for displaying emeralds to draw bigger level number */
1023 DrawTextExt(drawto, DX_EMERALDS, DY_EMERALDS,
1024 int2str(value, 3), FONT_LEVEL_NUMBER, BLIT_OPAQUE);
1026 /* now copy it to the area for displaying level number */
1027 BlitBitmap(drawto, drawto,
1028 DX_EMERALDS, DY_EMERALDS + 1,
1029 getFontWidth(FONT_LEVEL_NUMBER) * 3,
1030 getFontHeight(FONT_LEVEL_NUMBER) - 1,
1031 DX_LEVEL - 1, DY_LEVEL + 1);
1033 /* restore the area for displaying emeralds */
1034 DrawGameValue_Emeralds(local_player->gems_still_needed);
1036 /* yes, this is all really ugly :-) */
1040 void DrawGameDoorValues()
1044 DrawGameValue_Level(level_nr);
1046 for (i = 0; i < MAX_PLAYERS; i++)
1047 DrawGameValue_Keys(&stored_player[i]);
1049 DrawGameValue_Emeralds(local_player->gems_still_needed);
1050 DrawGameValue_Dynamite(local_player->inventory_size);
1051 DrawGameValue_Score(local_player->score);
1052 DrawGameValue_Time(TimeLeft);
1055 static void resolve_group_element(int group_element, int recursion_depth)
1057 static int group_nr;
1058 static struct ElementGroupInfo *group;
1059 struct ElementGroupInfo *actual_group = element_info[group_element].group;
1062 if (recursion_depth > NUM_GROUP_ELEMENTS) /* recursion too deep */
1064 Error(ERR_WARN, "recursion too deep when resolving group element %d",
1065 group_element - EL_GROUP_START + 1);
1067 /* replace element which caused too deep recursion by question mark */
1068 group->element_resolved[group->num_elements_resolved++] = EL_UNKNOWN;
1073 if (recursion_depth == 0) /* initialization */
1075 group = element_info[group_element].group;
1076 group_nr = group_element - EL_GROUP_START;
1078 group->num_elements_resolved = 0;
1079 group->choice_pos = 0;
1082 for (i = 0; i < actual_group->num_elements; i++)
1084 int element = actual_group->element[i];
1086 if (group->num_elements_resolved == NUM_FILE_ELEMENTS)
1089 if (IS_GROUP_ELEMENT(element))
1090 resolve_group_element(element, recursion_depth + 1);
1093 group->element_resolved[group->num_elements_resolved++] = element;
1094 element_info[element].in_group[group_nr] = TRUE;
1099 if (recursion_depth == 0 && group_element <= EL_GROUP_4)
1101 printf("::: group %d: %d resolved elements\n",
1102 group_element - EL_GROUP_START, group->num_elements_resolved);
1103 for (i = 0; i < group->num_elements_resolved; i++)
1104 printf("::: - %d ['%s']\n", group->element_resolved[i],
1105 element_info[group->element_resolved[i]].token_name);
1112 =============================================================================
1114 -----------------------------------------------------------------------------
1115 initialize game engine due to level / tape version number
1116 =============================================================================
1119 static void InitGameEngine()
1123 /* set game engine from tape file when re-playing, else from level file */
1124 game.engine_version = (tape.playing ? tape.engine_version :
1125 level.game_version);
1127 /* dynamically adjust element properties according to game engine version */
1128 InitElementPropertiesEngine(game.engine_version);
1131 printf("level %d: level version == %06d\n", level_nr, level.game_version);
1132 printf(" tape version == %06d [%s] [file: %06d]\n",
1133 tape.engine_version, (tape.playing ? "PLAYING" : "RECORDING"),
1135 printf(" => game.engine_version == %06d\n", game.engine_version);
1138 /* ---------- recursively resolve group elements ------------------------- */
1140 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1141 for (j = 0; j < NUM_GROUP_ELEMENTS; j++)
1142 element_info[i].in_group[j] = FALSE;
1144 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
1145 resolve_group_element(EL_GROUP_START + i, 0);
1147 /* ---------- initialize player's initial move delay --------------------- */
1149 /* dynamically adjust player properties according to game engine version */
1150 game.initial_move_delay =
1151 (game.engine_version <= VERSION_IDENT(2,0,1,0) ? INITIAL_MOVE_DELAY_ON :
1152 INITIAL_MOVE_DELAY_OFF);
1154 /* dynamically adjust player properties according to level information */
1155 game.initial_move_delay_value =
1156 (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
1158 /* ---------- initialize player's initial push delay --------------------- */
1160 /* dynamically adjust player properties according to game engine version */
1161 game.initial_push_delay_value =
1162 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
1164 /* ---------- initialize changing elements ------------------------------- */
1166 /* initialize changing elements information */
1167 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1169 struct ElementInfo *ei = &element_info[i];
1171 /* this pointer might have been changed in the level editor */
1172 ei->change = &ei->change_page[0];
1174 if (!IS_CUSTOM_ELEMENT(i))
1176 ei->change->target_element = EL_EMPTY_SPACE;
1177 ei->change->delay_fixed = 0;
1178 ei->change->delay_random = 0;
1179 ei->change->delay_frames = 1;
1182 ei->change_events = CE_BITMASK_DEFAULT;
1183 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
1185 ei->event_page_nr[j] = 0;
1186 ei->event_page[j] = &ei->change_page[0];
1190 /* add changing elements from pre-defined list */
1191 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
1193 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
1194 struct ElementInfo *ei = &element_info[ch_delay->element];
1196 ei->change->target_element = ch_delay->target_element;
1197 ei->change->delay_fixed = ch_delay->change_delay;
1199 ei->change->pre_change_function = ch_delay->pre_change_function;
1200 ei->change->change_function = ch_delay->change_function;
1201 ei->change->post_change_function = ch_delay->post_change_function;
1203 ei->change_events |= CH_EVENT_BIT(CE_DELAY);
1207 /* add change events from custom element configuration */
1208 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1210 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
1212 for (j = 0; j < ei->num_change_pages; j++)
1214 if (!ei->change_page[j].can_change)
1217 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
1219 /* only add event page for the first page found with this event */
1220 if (ei->change_page[j].events & CH_EVENT_BIT(k) &&
1221 !(ei->change_events & CH_EVENT_BIT(k)))
1223 ei->change_events |= CH_EVENT_BIT(k);
1224 ei->event_page_nr[k] = j;
1225 ei->event_page[k] = &ei->change_page[j];
1233 /* add change events from custom element configuration */
1234 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1236 int element = EL_CUSTOM_START + i;
1238 /* only add custom elements that change after fixed/random frame delay */
1239 if (CAN_CHANGE(element) && HAS_CHANGE_EVENT(element, CE_DELAY))
1240 element_info[element].change_events |= CH_EVENT_BIT(CE_DELAY);
1244 /* ---------- initialize run-time trigger player and element ------------- */
1246 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1248 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
1250 for (j = 0; j < ei->num_change_pages; j++)
1252 ei->change_page[j].actual_trigger_element = EL_EMPTY;
1253 ei->change_page[j].actual_trigger_player = EL_PLAYER_1;
1257 /* ---------- initialize trigger events ---------------------------------- */
1259 /* initialize trigger events information */
1260 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1261 trigger_events[i] = EP_BITMASK_DEFAULT;
1264 /* add trigger events from element change event properties */
1265 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1267 struct ElementInfo *ei = &element_info[i];
1269 for (j = 0; j < ei->num_change_pages; j++)
1271 if (!ei->change_page[j].can_change)
1274 if (ei->change_page[j].events & CH_EVENT_BIT(CE_BY_OTHER_ACTION))
1276 int trigger_element = ei->change_page[j].trigger_element;
1278 if (IS_GROUP_ELEMENT(trigger_element))
1280 struct ElementGroupInfo *group = element_info[trigger_element].group;
1282 for (k = 0; k < group->num_elements_resolved; k++)
1283 trigger_events[group->element_resolved[k]]
1284 |= ei->change_page[j].events;
1287 trigger_events[trigger_element] |= ei->change_page[j].events;
1292 /* add trigger events from element change event properties */
1293 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1294 if (HAS_CHANGE_EVENT(i, CE_BY_OTHER_ACTION))
1295 trigger_events[element_info[i].change->trigger_element] |=
1296 element_info[i].change->events;
1299 /* ---------- initialize push delay -------------------------------------- */
1301 /* initialize push delay values to default */
1302 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1304 if (!IS_CUSTOM_ELEMENT(i))
1306 element_info[i].push_delay_fixed = game.default_push_delay_fixed;
1307 element_info[i].push_delay_random = game.default_push_delay_random;
1311 /* set push delay value for certain elements from pre-defined list */
1312 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
1314 int e = push_delay_list[i].element;
1316 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
1317 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
1320 /* set push delay value for Supaplex elements for newer engine versions */
1321 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
1323 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1325 if (IS_SP_ELEMENT(i))
1327 element_info[i].push_delay_fixed = 6; /* just enough to escape ... */
1328 element_info[i].push_delay_random = 0; /* ... from falling zonk */
1333 /* ---------- initialize move stepsize ----------------------------------- */
1335 /* initialize move stepsize values to default */
1336 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1337 if (!IS_CUSTOM_ELEMENT(i))
1338 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
1340 /* set move stepsize value for certain elements from pre-defined list */
1341 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
1343 int e = move_stepsize_list[i].element;
1345 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
1348 /* ---------- initialize move dig/leave ---------------------------------- */
1350 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1352 element_info[i].can_leave_element = FALSE;
1353 element_info[i].can_leave_element_last = FALSE;
1356 /* ---------- initialize gem count --------------------------------------- */
1358 /* initialize gem count values for each element */
1359 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1360 if (!IS_CUSTOM_ELEMENT(i))
1361 element_info[i].collect_count = 0;
1363 /* add gem count values for all elements from pre-defined list */
1364 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
1365 element_info[collect_count_list[i].element].collect_count =
1366 collect_count_list[i].count;
1368 /* ---------- initialize access direction -------------------------------- */
1370 /* initialize access direction values to default */
1371 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1372 if (!IS_CUSTOM_ELEMENT(i))
1373 element_info[i].access_direction = MV_ALL_DIRECTIONS;
1375 /* set access direction value for certain elements from pre-defined list */
1376 for (i = 0; tube_access[i].element != EL_UNDEFINED; i++)
1377 element_info[tube_access[i].element].access_direction =
1378 tube_access[i].direction;
1383 =============================================================================
1385 -----------------------------------------------------------------------------
1386 initialize and start new game
1387 =============================================================================
1392 boolean emulate_bd = TRUE; /* unless non-BOULDERDASH elements found */
1393 boolean emulate_sb = TRUE; /* unless non-SOKOBAN elements found */
1394 boolean emulate_sp = TRUE; /* unless non-SUPAPLEX elements found */
1401 #if USE_NEW_AMOEBA_CODE
1402 printf("Using new amoeba code.\n");
1404 printf("Using old amoeba code.\n");
1409 /* don't play tapes over network */
1410 network_playing = (options.network && !tape.playing);
1412 for (i = 0; i < MAX_PLAYERS; i++)
1414 struct PlayerInfo *player = &stored_player[i];
1416 player->index_nr = i;
1417 player->index_bit = (1 << i);
1418 player->element_nr = EL_PLAYER_1 + i;
1420 player->present = FALSE;
1421 player->active = FALSE;
1424 player->effective_action = 0;
1425 player->programmed_action = 0;
1428 player->gems_still_needed = level.gems_needed;
1429 player->sokobanfields_still_needed = 0;
1430 player->lights_still_needed = 0;
1431 player->friends_still_needed = 0;
1433 for (j = 0; j < MAX_KEYS; j++)
1434 player->key[j] = FALSE;
1436 player->dynabomb_count = 0;
1437 player->dynabomb_size = 1;
1438 player->dynabombs_left = 0;
1439 player->dynabomb_xl = FALSE;
1441 player->MovDir = MV_NO_MOVING;
1444 player->GfxDir = MV_NO_MOVING;
1445 player->GfxAction = ACTION_DEFAULT;
1447 player->StepFrame = 0;
1449 player->use_murphy_graphic = FALSE;
1451 player->block_last_field = FALSE;
1452 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
1454 player->actual_frame_counter = 0;
1456 player->step_counter = 0;
1458 player->last_move_dir = MV_NO_MOVING;
1460 player->is_waiting = FALSE;
1461 player->is_moving = FALSE;
1462 player->is_digging = FALSE;
1463 player->is_snapping = FALSE;
1464 player->is_collecting = FALSE;
1465 player->is_pushing = FALSE;
1466 player->is_switching = FALSE;
1467 player->is_dropping = FALSE;
1469 player->is_bored = FALSE;
1470 player->is_sleeping = FALSE;
1472 player->frame_counter_bored = -1;
1473 player->frame_counter_sleeping = -1;
1475 player->anim_delay_counter = 0;
1476 player->post_delay_counter = 0;
1478 player->action_waiting = ACTION_DEFAULT;
1479 player->last_action_waiting = ACTION_DEFAULT;
1480 player->special_action_bored = ACTION_DEFAULT;
1481 player->special_action_sleeping = ACTION_DEFAULT;
1483 player->num_special_action_bored = 0;
1484 player->num_special_action_sleeping = 0;
1486 /* determine number of special actions for bored and sleeping animation */
1487 for (j = ACTION_BORING_1; j <= ACTION_BORING_LAST; j++)
1489 boolean found = FALSE;
1491 for (k = 0; k < NUM_DIRECTIONS; k++)
1492 if (el_act_dir2img(player->element_nr, j, k) !=
1493 el_act_dir2img(player->element_nr, ACTION_DEFAULT, k))
1497 player->num_special_action_bored++;
1501 for (j = ACTION_SLEEPING_1; j <= ACTION_SLEEPING_LAST; j++)
1503 boolean found = FALSE;
1505 for (k = 0; k < NUM_DIRECTIONS; k++)
1506 if (el_act_dir2img(player->element_nr, j, k) !=
1507 el_act_dir2img(player->element_nr, ACTION_DEFAULT, k))
1511 player->num_special_action_sleeping++;
1516 player->switch_x = -1;
1517 player->switch_y = -1;
1519 player->show_envelope = 0;
1521 player->move_delay = game.initial_move_delay;
1522 player->move_delay_value = game.initial_move_delay_value;
1524 player->move_delay_reset_counter = 0;
1526 player->push_delay = 0;
1527 player->push_delay_value = game.initial_push_delay_value;
1529 player->drop_delay = 0;
1531 player->last_jx = player->last_jy = 0;
1532 player->jx = player->jy = 0;
1534 player->shield_normal_time_left = 0;
1535 player->shield_deadly_time_left = 0;
1537 player->inventory_infinite_element = EL_UNDEFINED;
1538 player->inventory_size = 0;
1540 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
1541 SnapField(player, 0, 0);
1543 player->LevelSolved = FALSE;
1544 player->GameOver = FALSE;
1547 network_player_action_received = FALSE;
1549 #if defined(PLATFORM_UNIX)
1550 /* initial null action */
1551 if (network_playing)
1552 SendToServer_MovePlayer(MV_NO_MOVING);
1560 TimeLeft = level.time;
1563 ScreenMovDir = MV_NO_MOVING;
1567 ScrollStepSize = 0; /* will be correctly initialized by ScrollScreen() */
1569 AllPlayersGone = FALSE;
1571 game.yamyam_content_nr = 0;
1572 game.magic_wall_active = FALSE;
1573 game.magic_wall_time_left = 0;
1574 game.light_time_left = 0;
1575 game.timegate_time_left = 0;
1576 game.switchgate_pos = 0;
1577 game.balloon_dir = MV_NO_MOVING;
1578 game.gravity = level.initial_gravity;
1579 game.explosions_delayed = TRUE;
1581 game.envelope_active = FALSE;
1583 for (i = 0; i < NUM_BELTS; i++)
1585 game.belt_dir[i] = MV_NO_MOVING;
1586 game.belt_dir_nr[i] = 3; /* not moving, next moving left */
1589 for (i = 0; i < MAX_NUM_AMOEBA; i++)
1590 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
1592 for (x = 0; x < lev_fieldx; x++)
1594 for (y = 0; y < lev_fieldy; y++)
1596 Feld[x][y] = level.field[x][y];
1597 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
1598 ChangeDelay[x][y] = 0;
1599 ChangePage[x][y] = -1;
1600 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
1602 WasJustMoving[x][y] = 0;
1603 WasJustFalling[x][y] = 0;
1605 Pushed[x][y] = FALSE;
1607 Changed[x][y] = CE_BITMASK_DEFAULT;
1608 ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
1610 ExplodePhase[x][y] = 0;
1611 ExplodeDelay[x][y] = 0;
1612 ExplodeField[x][y] = EX_NO_EXPLOSION;
1614 RunnerVisit[x][y] = 0;
1615 PlayerVisit[x][y] = 0;
1618 GfxRandom[x][y] = INIT_GFX_RANDOM();
1619 GfxElement[x][y] = EL_UNDEFINED;
1620 GfxAction[x][y] = ACTION_DEFAULT;
1621 GfxDir[x][y] = MV_NO_MOVING;
1625 for (y = 0; y < lev_fieldy; y++)
1627 for (x = 0; x < lev_fieldx; x++)
1629 if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y]))
1631 if (emulate_sb && !IS_SB_ELEMENT(Feld[x][y]))
1633 if (emulate_sp && !IS_SP_ELEMENT(Feld[x][y]))
1636 InitField(x, y, TRUE);
1642 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
1643 emulate_sb ? EMU_SOKOBAN :
1644 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
1646 /* initialize explosion and ignition delay */
1647 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1649 if (!IS_CUSTOM_ELEMENT(i))
1652 int delay = ((IS_SP_ELEMENT(i) &&
1653 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
1654 game.emulation == EMU_SUPAPLEX ? 3 : 2);
1655 int last_phase = (num_phase + 1) * delay;
1656 int half_phase = (num_phase / 2) * delay;
1658 element_info[i].explosion_delay = last_phase - 1;
1659 element_info[i].ignition_delay = half_phase;
1662 if (i == EL_BLACK_ORB)
1663 element_info[i].ignition_delay = 0;
1665 if (i == EL_BLACK_ORB)
1666 element_info[i].ignition_delay = 1;
1671 if (element_info[i].explosion_delay < 1) /* !!! check again !!! */
1672 element_info[i].explosion_delay = 1;
1674 if (element_info[i].ignition_delay < 1) /* !!! check again !!! */
1675 element_info[i].ignition_delay = 1;
1679 /* correct non-moving belts to start moving left */
1680 for (i = 0; i < NUM_BELTS; i++)
1681 if (game.belt_dir[i] == MV_NO_MOVING)
1682 game.belt_dir_nr[i] = 3; /* not moving, next moving left */
1684 /* check if any connected player was not found in playfield */
1685 for (i = 0; i < MAX_PLAYERS; i++)
1687 struct PlayerInfo *player = &stored_player[i];
1689 if (player->connected && !player->present)
1691 for (j = 0; j < MAX_PLAYERS; j++)
1693 struct PlayerInfo *some_player = &stored_player[j];
1694 int jx = some_player->jx, jy = some_player->jy;
1696 /* assign first free player found that is present in the playfield */
1697 if (some_player->present && !some_player->connected)
1699 player->present = TRUE;
1700 player->active = TRUE;
1702 some_player->present = FALSE;
1703 some_player->active = FALSE;
1706 player->element_nr = some_player->element_nr;
1709 StorePlayer[jx][jy] = player->element_nr;
1710 player->jx = player->last_jx = jx;
1711 player->jy = player->last_jy = jy;
1721 /* when playing a tape, eliminate all players which do not participate */
1723 for (i = 0; i < MAX_PLAYERS; i++)
1725 if (stored_player[i].active && !tape.player_participates[i])
1727 struct PlayerInfo *player = &stored_player[i];
1728 int jx = player->jx, jy = player->jy;
1730 player->active = FALSE;
1731 StorePlayer[jx][jy] = 0;
1732 Feld[jx][jy] = EL_EMPTY;
1736 else if (!options.network && !setup.team_mode) /* && !tape.playing */
1738 /* when in single player mode, eliminate all but the first active player */
1740 for (i = 0; i < MAX_PLAYERS; i++)
1742 if (stored_player[i].active)
1744 for (j = i + 1; j < MAX_PLAYERS; j++)
1746 if (stored_player[j].active)
1748 struct PlayerInfo *player = &stored_player[j];
1749 int jx = player->jx, jy = player->jy;
1751 player->active = FALSE;
1752 player->present = FALSE;
1754 StorePlayer[jx][jy] = 0;
1755 Feld[jx][jy] = EL_EMPTY;
1762 /* when recording the game, store which players take part in the game */
1765 for (i = 0; i < MAX_PLAYERS; i++)
1766 if (stored_player[i].active)
1767 tape.player_participates[i] = TRUE;
1772 for (i = 0; i < MAX_PLAYERS; i++)
1774 struct PlayerInfo *player = &stored_player[i];
1776 printf("Player %d: present == %d, connected == %d, active == %d.\n",
1781 if (local_player == player)
1782 printf("Player %d is local player.\n", i+1);
1786 if (BorderElement == EL_EMPTY)
1789 SBX_Right = lev_fieldx - SCR_FIELDX;
1791 SBY_Lower = lev_fieldy - SCR_FIELDY;
1796 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
1798 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
1801 if (lev_fieldx + (SBX_Left == -1 ? 2 : 0) <= SCR_FIELDX)
1802 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
1804 if (lev_fieldy + (SBY_Upper == -1 ? 2 : 0) <= SCR_FIELDY)
1805 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
1807 /* if local player not found, look for custom element that might create
1808 the player (make some assumptions about the right custom element) */
1809 if (!local_player->present)
1811 int start_x = 0, start_y = 0;
1812 int found_rating = 0;
1813 int found_element = EL_UNDEFINED;
1815 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
1817 int element = Feld[x][y];
1822 if (!IS_CUSTOM_ELEMENT(element))
1825 if (CAN_CHANGE(element))
1827 for (i = 0; i < element_info[element].num_change_pages; i++)
1829 content = element_info[element].change_page[i].target_element;
1830 is_player = ELEM_IS_PLAYER(content);
1832 if (is_player && (found_rating < 3 || element < found_element))
1838 found_element = element;
1843 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
1845 content = element_info[element].content[xx][yy];
1846 is_player = ELEM_IS_PLAYER(content);
1848 if (is_player && (found_rating < 2 || element < found_element))
1850 start_x = x + xx - 1;
1851 start_y = y + yy - 1;
1854 found_element = element;
1857 if (!CAN_CHANGE(element))
1860 for (i = 0; i < element_info[element].num_change_pages; i++)
1862 content= element_info[element].change_page[i].target_content[xx][yy];
1863 is_player = ELEM_IS_PLAYER(content);
1865 if (is_player && (found_rating < 1 || element < found_element))
1867 start_x = x + xx - 1;
1868 start_y = y + yy - 1;
1871 found_element = element;
1877 scroll_x = (start_x < SBX_Left + MIDPOSX ? SBX_Left :
1878 start_x > SBX_Right + MIDPOSX ? SBX_Right :
1881 scroll_y = (start_y < SBY_Upper + MIDPOSY ? SBY_Upper :
1882 start_y > SBY_Lower + MIDPOSY ? SBY_Lower :
1888 scroll_x = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
1889 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
1890 local_player->jx - MIDPOSX);
1892 scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
1893 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
1894 local_player->jy - MIDPOSY);
1896 scroll_x = SBX_Left;
1897 scroll_y = SBY_Upper;
1898 if (local_player->jx >= SBX_Left + MIDPOSX)
1899 scroll_x = (local_player->jx <= SBX_Right + MIDPOSX ?
1900 local_player->jx - MIDPOSX :
1902 if (local_player->jy >= SBY_Upper + MIDPOSY)
1903 scroll_y = (local_player->jy <= SBY_Lower + MIDPOSY ?
1904 local_player->jy - MIDPOSY :
1909 CloseDoor(DOOR_CLOSE_1);
1914 /* after drawing the level, correct some elements */
1915 if (game.timegate_time_left == 0)
1916 CloseAllOpenTimegates();
1918 if (setup.soft_scrolling)
1919 BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
1921 redraw_mask |= REDRAW_FROM_BACKBUFFER;
1924 /* copy default game door content to main double buffer */
1925 BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
1926 DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
1928 DrawGameDoorValues();
1932 game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
1933 game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
1934 game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
1938 /* copy actual game door content to door double buffer for OpenDoor() */
1939 BlitBitmap(drawto, bitmap_db_door,
1940 DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
1942 OpenDoor(DOOR_OPEN_ALL);
1944 PlaySoundStereo(SND_GAME_STARTING, SOUND_MIDDLE);
1946 if (setup.sound_music)
1949 KeyboardAutoRepeatOffUnlessAutoplay();
1953 for (i = 0; i < MAX_PLAYERS; i++)
1954 printf("Player %d %sactive.\n",
1955 i + 1, (stored_player[i].active ? "" : "not "));
1959 printf("::: starting game [%d]\n", FrameCounter);
1963 void InitMovDir(int x, int y)
1965 int i, element = Feld[x][y];
1966 static int xy[4][2] =
1973 static int direction[3][4] =
1975 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
1976 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
1977 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
1986 Feld[x][y] = EL_BUG;
1987 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
1990 case EL_SPACESHIP_RIGHT:
1991 case EL_SPACESHIP_UP:
1992 case EL_SPACESHIP_LEFT:
1993 case EL_SPACESHIP_DOWN:
1994 Feld[x][y] = EL_SPACESHIP;
1995 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
1998 case EL_BD_BUTTERFLY_RIGHT:
1999 case EL_BD_BUTTERFLY_UP:
2000 case EL_BD_BUTTERFLY_LEFT:
2001 case EL_BD_BUTTERFLY_DOWN:
2002 Feld[x][y] = EL_BD_BUTTERFLY;
2003 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
2006 case EL_BD_FIREFLY_RIGHT:
2007 case EL_BD_FIREFLY_UP:
2008 case EL_BD_FIREFLY_LEFT:
2009 case EL_BD_FIREFLY_DOWN:
2010 Feld[x][y] = EL_BD_FIREFLY;
2011 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
2014 case EL_PACMAN_RIGHT:
2016 case EL_PACMAN_LEFT:
2017 case EL_PACMAN_DOWN:
2018 Feld[x][y] = EL_PACMAN;
2019 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
2022 case EL_SP_SNIKSNAK:
2023 MovDir[x][y] = MV_UP;
2026 case EL_SP_ELECTRON:
2027 MovDir[x][y] = MV_LEFT;
2034 Feld[x][y] = EL_MOLE;
2035 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
2039 if (IS_CUSTOM_ELEMENT(element))
2041 struct ElementInfo *ei = &element_info[element];
2042 int move_direction_initial = ei->move_direction_initial;
2043 int move_pattern = ei->move_pattern;
2045 if (move_direction_initial == MV_START_PREVIOUS)
2047 if (MovDir[x][y] != MV_NO_MOVING)
2050 move_direction_initial = MV_START_AUTOMATIC;
2053 if (move_direction_initial == MV_START_RANDOM)
2054 MovDir[x][y] = 1 << RND(4);
2055 else if (move_direction_initial & MV_ANY_DIRECTION)
2056 MovDir[x][y] = move_direction_initial;
2057 else if (move_pattern == MV_ALL_DIRECTIONS ||
2058 move_pattern == MV_TURNING_LEFT ||
2059 move_pattern == MV_TURNING_RIGHT ||
2060 move_pattern == MV_TURNING_LEFT_RIGHT ||
2061 move_pattern == MV_TURNING_RIGHT_LEFT ||
2062 move_pattern == MV_TURNING_RANDOM)
2063 MovDir[x][y] = 1 << RND(4);
2064 else if (move_pattern == MV_HORIZONTAL)
2065 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
2066 else if (move_pattern == MV_VERTICAL)
2067 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
2068 else if (move_pattern & MV_ANY_DIRECTION)
2069 MovDir[x][y] = element_info[element].move_pattern;
2070 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
2071 move_pattern == MV_ALONG_RIGHT_SIDE)
2073 for (i = 0; i < NUM_DIRECTIONS; i++)
2075 int x1 = x + xy[i][0];
2076 int y1 = y + xy[i][1];
2078 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
2080 if (move_pattern == MV_ALONG_RIGHT_SIDE)
2081 MovDir[x][y] = direction[0][i];
2083 MovDir[x][y] = direction[1][i];
2092 MovDir[x][y] = 1 << RND(4);
2094 if (element != EL_BUG &&
2095 element != EL_SPACESHIP &&
2096 element != EL_BD_BUTTERFLY &&
2097 element != EL_BD_FIREFLY)
2100 for (i = 0; i < NUM_DIRECTIONS; i++)
2102 int x1 = x + xy[i][0];
2103 int y1 = y + xy[i][1];
2105 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
2107 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
2109 MovDir[x][y] = direction[0][i];
2112 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
2113 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
2115 MovDir[x][y] = direction[1][i];
2124 GfxDir[x][y] = MovDir[x][y];
2127 void InitAmoebaNr(int x, int y)
2130 int group_nr = AmoebeNachbarNr(x, y);
2134 for (i = 1; i < MAX_NUM_AMOEBA; i++)
2136 if (AmoebaCnt[i] == 0)
2144 AmoebaNr[x][y] = group_nr;
2145 AmoebaCnt[group_nr]++;
2146 AmoebaCnt2[group_nr]++;
2152 boolean raise_level = FALSE;
2154 if (local_player->MovPos)
2158 if (tape.auto_play) /* tape might already be stopped here */
2159 tape.auto_play_level_solved = TRUE;
2161 if (tape.playing && tape.auto_play)
2162 tape.auto_play_level_solved = TRUE;
2165 local_player->LevelSolved = FALSE;
2167 PlaySoundStereo(SND_GAME_WINNING, SOUND_MIDDLE);
2171 if (!tape.playing && setup.sound_loops)
2172 PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
2173 SND_CTRL_PLAY_LOOP);
2175 while (TimeLeft > 0)
2177 if (!tape.playing && !setup.sound_loops)
2178 PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
2179 if (TimeLeft > 0 && !(TimeLeft % 10))
2180 RaiseScore(level.score[SC_TIME_BONUS]);
2181 if (TimeLeft > 100 && !(TimeLeft % 10))
2186 DrawGameValue_Time(TimeLeft);
2194 if (!tape.playing && setup.sound_loops)
2195 StopSound(SND_GAME_LEVELTIME_BONUS);
2197 else if (level.time == 0) /* level without time limit */
2199 if (!tape.playing && setup.sound_loops)
2200 PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
2201 SND_CTRL_PLAY_LOOP);
2203 while (TimePlayed < 999)
2205 if (!tape.playing && !setup.sound_loops)
2206 PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
2207 if (TimePlayed < 999 && !(TimePlayed % 10))
2208 RaiseScore(level.score[SC_TIME_BONUS]);
2209 if (TimePlayed < 900 && !(TimePlayed % 10))
2214 DrawGameValue_Time(TimePlayed);
2222 if (!tape.playing && setup.sound_loops)
2223 StopSound(SND_GAME_LEVELTIME_BONUS);
2226 /* close exit door after last player */
2227 if ((Feld[ExitX][ExitY] == EL_EXIT_OPEN ||
2228 Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN) && AllPlayersGone)
2230 int element = Feld[ExitX][ExitY];
2232 Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
2233 EL_SP_EXIT_CLOSING);
2235 PlayLevelSoundElementAction(ExitX, ExitY, element, ACTION_CLOSING);
2238 /* Hero disappears */
2239 DrawLevelField(ExitX, ExitY);
2245 CloseDoor(DOOR_CLOSE_1);
2250 SaveTape(tape.level_nr); /* Ask to save tape */
2253 if (level_nr == leveldir_current->handicap_level)
2255 leveldir_current->handicap_level++;
2256 SaveLevelSetup_SeriesInfo();
2259 if (level_editor_test_game)
2260 local_player->score = -1; /* no highscore when playing from editor */
2261 else if (level_nr < leveldir_current->last_level)
2262 raise_level = TRUE; /* advance to next level */
2264 if ((hi_pos = NewHiScore()) >= 0)
2266 game_status = GAME_MODE_SCORES;
2267 DrawHallOfFame(hi_pos);
2276 game_status = GAME_MODE_MAIN;
2293 LoadScore(level_nr);
2295 if (strcmp(setup.player_name, EMPTY_PLAYER_NAME) == 0 ||
2296 local_player->score < highscore[MAX_SCORE_ENTRIES - 1].Score)
2299 for (k = 0; k < MAX_SCORE_ENTRIES; k++)
2301 if (local_player->score > highscore[k].Score)
2303 /* player has made it to the hall of fame */
2305 if (k < MAX_SCORE_ENTRIES - 1)
2307 int m = MAX_SCORE_ENTRIES - 1;
2310 for (l = k; l < MAX_SCORE_ENTRIES; l++)
2311 if (!strcmp(setup.player_name, highscore[l].Name))
2313 if (m == k) /* player's new highscore overwrites his old one */
2317 for (l = m; l > k; l--)
2319 strcpy(highscore[l].Name, highscore[l - 1].Name);
2320 highscore[l].Score = highscore[l - 1].Score;
2327 strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
2328 highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
2329 highscore[k].Score = local_player->score;
2335 else if (!strncmp(setup.player_name, highscore[k].Name,
2336 MAX_PLAYER_NAME_LEN))
2337 break; /* player already there with a higher score */
2343 SaveScore(level_nr);
2348 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
2350 if (player->GfxAction != action || player->GfxDir != dir)
2353 printf("Player frame reset! (%d => %d, %d => %d)\n",
2354 player->GfxAction, action, player->GfxDir, dir);
2357 player->GfxAction = action;
2358 player->GfxDir = dir;
2360 player->StepFrame = 0;
2364 static void ResetRandomAnimationValue(int x, int y)
2366 GfxRandom[x][y] = INIT_GFX_RANDOM();
2369 static void ResetGfxAnimation(int x, int y)
2372 GfxAction[x][y] = ACTION_DEFAULT;
2373 GfxDir[x][y] = MovDir[x][y];
2376 void InitMovingField(int x, int y, int direction)
2378 int element = Feld[x][y];
2379 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2380 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
2384 if (!WasJustMoving[x][y] || direction != MovDir[x][y])
2385 ResetGfxAnimation(x, y);
2387 MovDir[newx][newy] = MovDir[x][y] = direction;
2388 GfxDir[x][y] = direction;
2390 if (Feld[newx][newy] == EL_EMPTY)
2391 Feld[newx][newy] = EL_BLOCKED;
2393 if (direction == MV_DOWN && CAN_FALL(element))
2394 GfxAction[x][y] = ACTION_FALLING;
2396 GfxAction[x][y] = ACTION_MOVING;
2398 GfxFrame[newx][newy] = GfxFrame[x][y];
2399 GfxRandom[newx][newy] = GfxRandom[x][y];
2400 GfxAction[newx][newy] = GfxAction[x][y];
2401 GfxDir[newx][newy] = GfxDir[x][y];
2404 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
2406 int direction = MovDir[x][y];
2407 int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2408 int newy = y + (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
2414 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
2416 int oldx = x, oldy = y;
2417 int direction = MovDir[x][y];
2419 if (direction == MV_LEFT)
2421 else if (direction == MV_RIGHT)
2423 else if (direction == MV_UP)
2425 else if (direction == MV_DOWN)
2428 *comes_from_x = oldx;
2429 *comes_from_y = oldy;
2432 int MovingOrBlocked2Element(int x, int y)
2434 int element = Feld[x][y];
2436 if (element == EL_BLOCKED)
2440 Blocked2Moving(x, y, &oldx, &oldy);
2441 return Feld[oldx][oldy];
2447 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
2449 /* like MovingOrBlocked2Element(), but if element is moving
2450 and (x,y) is the field the moving element is just leaving,
2451 return EL_BLOCKED instead of the element value */
2452 int element = Feld[x][y];
2454 if (IS_MOVING(x, y))
2456 if (element == EL_BLOCKED)
2460 Blocked2Moving(x, y, &oldx, &oldy);
2461 return Feld[oldx][oldy];
2470 static void RemoveField(int x, int y)
2472 Feld[x][y] = EL_EMPTY;
2479 ChangeDelay[x][y] = 0;
2480 ChangePage[x][y] = -1;
2481 Pushed[x][y] = FALSE;
2483 GfxElement[x][y] = EL_UNDEFINED;
2484 GfxAction[x][y] = ACTION_DEFAULT;
2485 GfxDir[x][y] = MV_NO_MOVING;
2488 void RemoveMovingField(int x, int y)
2490 int oldx = x, oldy = y, newx = x, newy = y;
2491 int element = Feld[x][y];
2492 int next_element = EL_UNDEFINED;
2494 if (element != EL_BLOCKED && !IS_MOVING(x, y))
2497 if (IS_MOVING(x, y))
2499 Moving2Blocked(x, y, &newx, &newy);
2501 if (Feld[newx][newy] != EL_BLOCKED)
2504 if (Feld[newx][newy] != EL_BLOCKED)
2506 /* element is moving, but target field is not free (blocked), but
2507 already occupied by something different (example: acid pool);
2508 in this case, only remove the moving field, but not the target */
2510 RemoveField(oldx, oldy);
2512 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
2514 DrawLevelField(oldx, oldy);
2520 else if (element == EL_BLOCKED)
2522 Blocked2Moving(x, y, &oldx, &oldy);
2523 if (!IS_MOVING(oldx, oldy))
2527 if (element == EL_BLOCKED &&
2528 (Feld[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
2529 Feld[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
2530 Feld[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
2531 Feld[oldx][oldy] == EL_AMOEBA_DROPPING))
2532 next_element = get_next_element(Feld[oldx][oldy]);
2534 RemoveField(oldx, oldy);
2535 RemoveField(newx, newy);
2537 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
2539 if (next_element != EL_UNDEFINED)
2540 Feld[oldx][oldy] = next_element;
2542 DrawLevelField(oldx, oldy);
2543 DrawLevelField(newx, newy);
2546 void DrawDynamite(int x, int y)
2548 int sx = SCREENX(x), sy = SCREENY(y);
2549 int graphic = el2img(Feld[x][y]);
2552 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
2555 if (IS_WALKABLE_INSIDE(Back[x][y]))
2559 DrawGraphic(sx, sy, el2img(Back[x][y]), 0);
2560 else if (Store[x][y])
2561 DrawGraphic(sx, sy, el2img(Store[x][y]), 0);
2563 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
2566 if (Back[x][y] || Store[x][y])
2567 DrawGraphicThruMask(sx, sy, graphic, frame);
2569 DrawGraphic(sx, sy, graphic, frame);
2571 if (game.emulation == EMU_SUPAPLEX)
2572 DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
2573 else if (Store[x][y])
2574 DrawGraphicThruMask(sx, sy, graphic, frame);
2576 DrawGraphic(sx, sy, graphic, frame);
2580 void CheckDynamite(int x, int y)
2582 if (MovDelay[x][y] != 0) /* dynamite is still waiting to explode */
2586 if (MovDelay[x][y] != 0)
2589 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
2596 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
2598 if (Feld[x][y] == EL_DYNAMITE_ACTIVE ||
2599 Feld[x][y] == EL_SP_DISK_RED_ACTIVE)
2600 StopSound(SND_DYNAMITE_ACTIVE);
2602 StopSound(SND_DYNABOMB_ACTIVE);
2608 void RelocatePlayer(int x, int y, int element_raw)
2610 int element = (element_raw == EL_SP_MURPHY ? EL_PLAYER_1 : element_raw);
2611 struct PlayerInfo *player = &stored_player[element - EL_PLAYER_1];
2612 boolean ffwd_delay = (tape.playing && tape.fast_forward);
2613 boolean no_delay = (tape.index_search);
2614 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2615 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
2620 if (player->GameOver) /* do not reanimate dead player */
2624 RemoveField(x, y); /* temporarily remove newly placed player */
2625 DrawLevelField(x, y);
2628 if (player->present)
2630 while (player->MovPos)
2632 ScrollPlayer(player, SCROLL_GO_ON);
2633 ScrollScreen(NULL, SCROLL_GO_ON);
2639 Delay(wait_delay_value);
2642 DrawPlayer(player); /* needed here only to cleanup last field */
2643 DrawLevelField(player->jx, player->jy); /* remove player graphic */
2645 player->is_moving = FALSE;
2649 old_jx = player->jx;
2650 old_jy = player->jy;
2653 Feld[x][y] = element;
2654 InitPlayerField(x, y, element, TRUE);
2657 if (player == local_player)
2661 scroll_x += (local_player->jx - old_jx);
2662 scroll_y += (local_player->jy - old_jy);
2664 /* don't scroll over playfield boundaries */
2665 if (scroll_x < SBX_Left || scroll_x > SBX_Right)
2666 scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
2668 /* don't scroll over playfield boundaries */
2669 if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
2670 scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
2673 scroll_x = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
2674 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
2675 local_player->jx - MIDPOSX);
2677 scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
2678 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
2679 local_player->jy - MIDPOSY);
2682 RedrawPlayfield(TRUE, 0,0,0,0);
2691 if (player == local_player)
2693 int scroll_xx = -999, scroll_yy = -999;
2695 while (scroll_xx != scroll_x || scroll_yy != scroll_y)
2698 int fx = FX, fy = FY;
2700 scroll_xx = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
2701 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
2702 local_player->jx - MIDPOSX);
2704 scroll_yy = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
2705 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
2706 local_player->jy - MIDPOSY);
2708 dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
2709 dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
2714 fx += dx * TILEX / 2;
2715 fy += dy * TILEY / 2;
2717 ScrollLevel(dx, dy);
2720 /* scroll in two steps of half tile size to make things smoother */
2721 BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
2723 Delay(wait_delay_value);
2725 /* scroll second step to align at full tile size */
2727 Delay(wait_delay_value);
2733 void Explode(int ex, int ey, int phase, int mode)
2740 /* !!! eliminate this variable !!! */
2741 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
2746 int last_phase = num_phase * delay;
2747 int half_phase = (num_phase / 2) * delay;
2748 int first_phase_after_start = EX_PHASE_START + 1;
2752 if (game.explosions_delayed)
2754 ExplodeField[ex][ey] = mode;
2758 if (phase == EX_PHASE_START) /* initialize 'Store[][]' field */
2760 int center_element = Feld[ex][ey];
2763 printf("::: start explosion %d,%d [%d]\n", ex, ey, FrameCounter);
2767 /* --- This is only really needed (and now handled) in "Impact()". --- */
2768 /* do not explode moving elements that left the explode field in time */
2769 if (game.engine_version >= VERSION_IDENT(2,2,0,7) &&
2770 center_element == EL_EMPTY && (mode == EX_NORMAL || mode == EX_CENTER))
2774 if (mode == EX_NORMAL || mode == EX_CENTER)
2775 PlayLevelSoundAction(ex, ey, ACTION_EXPLODING);
2777 /* remove things displayed in background while burning dynamite */
2778 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
2781 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
2783 /* put moving element to center field (and let it explode there) */
2784 center_element = MovingOrBlocked2Element(ex, ey);
2785 RemoveMovingField(ex, ey);
2786 Feld[ex][ey] = center_element;
2792 last_phase = element_info[center_element].explosion_delay + 1;
2794 last_phase = element_info[center_element].explosion_delay;
2798 printf("::: %d -> %d\n", center_element, last_phase);
2802 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
2804 int xx = x - ex + 1;
2805 int yy = y - ey + 1;
2809 if (!IN_LEV_FIELD(x, y) || (mode != EX_NORMAL && (x != ex || y != ey)))
2812 if (!IN_LEV_FIELD(x, y) ||
2813 ((mode != EX_NORMAL || center_element == EL_AMOEBA_TO_DIAMOND) &&
2814 (x != ex || y != ey)))
2818 element = Feld[x][y];
2820 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
2822 element = MovingOrBlocked2Element(x, y);
2824 if (!IS_EXPLOSION_PROOF(element))
2825 RemoveMovingField(x, y);
2831 if (IS_EXPLOSION_PROOF(element))
2834 /* indestructible elements can only explode in center (but not flames) */
2835 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey)) ||
2836 element == EL_FLAMES)
2841 if ((IS_INDESTRUCTIBLE(element) &&
2842 (game.engine_version < VERSION_IDENT(2,2,0,0) ||
2843 (!IS_WALKABLE_OVER(element) && !IS_WALKABLE_UNDER(element)))) ||
2844 element == EL_FLAMES)
2848 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
2850 if (IS_ACTIVE_BOMB(element))
2852 /* re-activate things under the bomb like gate or penguin */
2853 Feld[x][y] = (Store[x][y] ? Store[x][y] : EL_EMPTY);
2860 /* save walkable background elements while explosion on same tile */
2862 if (IS_INDESTRUCTIBLE(element))
2863 Back[x][y] = element;
2865 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element))
2866 Back[x][y] = element;
2869 /* ignite explodable elements reached by other explosion */
2870 if (element == EL_EXPLOSION)
2871 element = Store2[x][y];
2874 if (AmoebaNr[x][y] &&
2875 (element == EL_AMOEBA_FULL ||
2876 element == EL_BD_AMOEBA ||
2877 element == EL_AMOEBA_GROWING))
2879 AmoebaCnt[AmoebaNr[x][y]]--;
2880 AmoebaCnt2[AmoebaNr[x][y]]--;
2886 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
2888 switch(StorePlayer[ex][ey])
2891 Store[x][y] = EL_PLAYER_IS_EXPLODING_2;
2894 Store[x][y] = EL_PLAYER_IS_EXPLODING_3;
2897 Store[x][y] = EL_PLAYER_IS_EXPLODING_4;
2901 Store[x][y] = EL_PLAYER_IS_EXPLODING_1;
2906 if (PLAYERINFO(ex, ey)->use_murphy_graphic)
2907 Store[x][y] = EL_EMPTY;
2909 if (game.emulation == EMU_SUPAPLEX)
2910 Store[x][y] = EL_EMPTY;
2913 else if (center_element == EL_MOLE)
2914 Store[x][y] = EL_EMERALD_RED;
2915 else if (center_element == EL_PENGUIN)
2916 Store[x][y] = EL_EMERALD_PURPLE;
2917 else if (center_element == EL_BUG)
2918 Store[x][y] = ((x == ex && y == ey) ? EL_DIAMOND : EL_EMERALD);
2919 else if (center_element == EL_BD_BUTTERFLY)
2920 Store[x][y] = EL_BD_DIAMOND;
2921 else if (center_element == EL_SP_ELECTRON)
2922 Store[x][y] = EL_SP_INFOTRON;
2923 else if (center_element == EL_AMOEBA_TO_DIAMOND)
2924 Store[x][y] = level.amoeba_content;
2925 else if (center_element == EL_YAMYAM)
2926 Store[x][y] = level.yamyam_content[game.yamyam_content_nr][xx][yy];
2927 else if (IS_CUSTOM_ELEMENT(center_element) &&
2928 element_info[center_element].content[xx][yy] != EL_EMPTY)
2929 Store[x][y] = element_info[center_element].content[xx][yy];
2930 else if (element == EL_WALL_EMERALD)
2931 Store[x][y] = EL_EMERALD;
2932 else if (element == EL_WALL_DIAMOND)
2933 Store[x][y] = EL_DIAMOND;
2934 else if (element == EL_WALL_BD_DIAMOND)
2935 Store[x][y] = EL_BD_DIAMOND;
2936 else if (element == EL_WALL_EMERALD_YELLOW)
2937 Store[x][y] = EL_EMERALD_YELLOW;
2938 else if (element == EL_WALL_EMERALD_RED)
2939 Store[x][y] = EL_EMERALD_RED;
2940 else if (element == EL_WALL_EMERALD_PURPLE)
2941 Store[x][y] = EL_EMERALD_PURPLE;
2942 else if (element == EL_WALL_PEARL)
2943 Store[x][y] = EL_PEARL;
2944 else if (element == EL_WALL_CRYSTAL)
2945 Store[x][y] = EL_CRYSTAL;
2946 else if (IS_CUSTOM_ELEMENT(element) && !CAN_EXPLODE(element))
2947 Store[x][y] = element_info[element].content[1][1];
2949 Store[x][y] = EL_EMPTY;
2951 if (x != ex || y != ey ||
2952 center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_BORDER)
2953 Store2[x][y] = element;
2956 if (AmoebaNr[x][y] &&
2957 (element == EL_AMOEBA_FULL ||
2958 element == EL_BD_AMOEBA ||
2959 element == EL_AMOEBA_GROWING))
2961 AmoebaCnt[AmoebaNr[x][y]]--;
2962 AmoebaCnt2[AmoebaNr[x][y]]--;
2968 MovDir[x][y] = MovPos[x][y] = 0;
2969 GfxDir[x][y] = MovDir[x][y];
2974 Feld[x][y] = EL_EXPLOSION;
2976 GfxElement[x][y] = center_element;
2978 GfxElement[x][y] = EL_UNDEFINED;
2981 ExplodePhase[x][y] = 1;
2983 ExplodeDelay[x][y] = last_phase;
2988 GfxFrame[x][y] = 0; /* animation does not start until next frame */
2990 GfxFrame[x][y] = -1; /* animation does not start until next frame */
2997 if (center_element == EL_YAMYAM)
2998 game.yamyam_content_nr =
2999 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
3012 GfxFrame[x][y] = 0; /* restart explosion animation */
3016 printf(":X: phase == %d [%d]\n", phase, GfxFrame[x][y]);
3020 last_phase = ExplodeDelay[x][y];
3023 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
3027 /* activate this even in non-DEBUG version until cause for crash in
3028 getGraphicAnimationFrame() (see below) is found and eliminated */
3032 if (GfxElement[x][y] == EL_UNDEFINED)
3035 printf("Explode(): x = %d, y = %d: GfxElement == EL_UNDEFINED\n", x, y);
3036 printf("Explode(): This should never happen!\n");
3039 GfxElement[x][y] = EL_EMPTY;
3045 border_element = Store2[x][y];
3046 if (IS_PLAYER(x, y))
3047 border_element = StorePlayer[x][y];
3050 printf("::: phase == %d\n", phase);
3053 if (phase == element_info[border_element].ignition_delay ||
3054 phase == last_phase)
3056 boolean border_explosion = FALSE;
3059 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present)
3061 if (IS_PLAYER(x, y))
3064 KillHeroUnlessExplosionProtected(x, y);
3065 border_explosion = TRUE;
3068 if (phase == last_phase)
3069 printf("::: IS_PLAYER\n");
3072 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
3074 Feld[x][y] = Store2[x][y];
3077 border_explosion = TRUE;
3080 if (phase == last_phase)
3081 printf("::: CAN_EXPLODE_BY_EXPLOSION\n");
3084 else if (border_element == EL_AMOEBA_TO_DIAMOND)
3086 AmoebeUmwandeln(x, y);
3088 border_explosion = TRUE;
3091 if (phase == last_phase)
3092 printf("::: EL_AMOEBA_TO_DIAMOND [%d, %d] [%d]\n",
3093 element_info[border_element].explosion_delay,
3094 element_info[border_element].ignition_delay,
3100 /* if an element just explodes due to another explosion (chain-reaction),
3101 do not immediately end the new explosion when it was the last frame of
3102 the explosion (as it would be done in the following "if"-statement!) */
3103 if (border_explosion && phase == last_phase)
3110 if (phase == first_phase_after_start)
3112 int element = Store2[x][y];
3114 if (element == EL_BLACK_ORB)
3116 Feld[x][y] = Store2[x][y];
3121 else if (phase == half_phase)
3123 int element = Store2[x][y];
3125 if (IS_PLAYER(x, y))
3126 KillHeroUnlessExplosionProtected(x, y);
3127 else if (CAN_EXPLODE_BY_EXPLOSION(element))
3129 Feld[x][y] = Store2[x][y];
3133 else if (element == EL_AMOEBA_TO_DIAMOND)
3134 AmoebeUmwandeln(x, y);
3138 if (phase == last_phase)
3143 printf("::: explosion %d,%d done [%d]\n", x, y, FrameCounter);
3146 element = Feld[x][y] = Store[x][y];
3147 Store[x][y] = Store2[x][y] = 0;
3148 GfxElement[x][y] = EL_UNDEFINED;
3150 /* player can escape from explosions and might therefore be still alive */
3151 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
3152 element <= EL_PLAYER_IS_EXPLODING_4)
3153 Feld[x][y] = (stored_player[element - EL_PLAYER_IS_EXPLODING_1].active ?
3155 element == EL_PLAYER_IS_EXPLODING_1 ? EL_EMERALD_YELLOW :
3156 element == EL_PLAYER_IS_EXPLODING_2 ? EL_EMERALD_RED :
3157 element == EL_PLAYER_IS_EXPLODING_3 ? EL_EMERALD :
3160 /* restore probably existing indestructible background element */
3161 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
3162 element = Feld[x][y] = Back[x][y];
3165 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
3166 GfxDir[x][y] = MV_NO_MOVING;
3167 ChangeDelay[x][y] = 0;
3168 ChangePage[x][y] = -1;
3171 InitField_WithBug2(x, y, FALSE);
3173 InitField(x, y, FALSE);
3175 /* !!! not needed !!! */
3177 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3178 CAN_MOVE(Feld[x][y]) && Feld[x][y] != EL_MOLE)
3181 if (CAN_MOVE(element))
3186 DrawLevelField(x, y);
3188 TestIfElementTouchesCustomElement(x, y);
3190 if (GFX_CRUMBLED(element))
3191 DrawLevelFieldCrumbledSandNeighbours(x, y);
3193 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
3194 StorePlayer[x][y] = 0;
3196 if (ELEM_IS_PLAYER(element))
3197 RelocatePlayer(x, y, element);
3200 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3202 else if (phase >= delay && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3206 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
3208 int stored = Store[x][y];
3209 int graphic = (game.emulation != EMU_SUPAPLEX ? IMG_EXPLOSION :
3210 stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
3214 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
3216 int frame = getGraphicAnimationFrame(graphic, phase - delay);
3220 printf("::: phase == %d [%d]\n", phase, GfxFrame[x][y]);
3224 printf("::: %d / %d [%d - %d]\n",
3225 GfxFrame[x][y], phase - delay, phase, delay);
3229 printf("::: %d ['%s'] -> %d\n", GfxElement[x][y],
3230 element_info[GfxElement[x][y]].token_name,
3235 DrawLevelFieldCrumbledSand(x, y);
3237 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
3239 DrawLevelElement(x, y, Back[x][y]);
3240 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
3242 else if (IS_WALKABLE_UNDER(Back[x][y]))
3244 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
3245 DrawLevelElementThruMask(x, y, Back[x][y]);
3247 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
3248 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
3252 void DynaExplode(int ex, int ey)
3255 int dynabomb_element = Feld[ex][ey];
3256 int dynabomb_size = 1;
3257 boolean dynabomb_xl = FALSE;
3258 struct PlayerInfo *player;
3259 static int xy[4][2] =
3267 if (IS_ACTIVE_BOMB(dynabomb_element))
3269 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
3270 dynabomb_size = player->dynabomb_size;
3271 dynabomb_xl = player->dynabomb_xl;
3272 player->dynabombs_left++;
3275 Explode(ex, ey, EX_PHASE_START, EX_CENTER);
3277 for (i = 0; i < NUM_DIRECTIONS; i++)
3279 for (j = 1; j <= dynabomb_size; j++)
3281 int x = ex + j * xy[i][0];
3282 int y = ey + j * xy[i][1];
3285 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Feld[x][y]))
3288 element = Feld[x][y];
3290 /* do not restart explosions of fields with active bombs */
3291 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
3294 Explode(x, y, EX_PHASE_START, EX_BORDER);
3296 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
3297 if (element != EL_EMPTY &&
3298 element != EL_SAND &&
3299 element != EL_EXPLOSION &&
3306 void Bang(int x, int y)
3309 int element = MovingOrBlocked2Element(x, y);
3311 int element = Feld[x][y];
3315 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
3317 if (IS_PLAYER(x, y))
3320 struct PlayerInfo *player = PLAYERINFO(x, y);
3322 element = Feld[x][y] = (player->use_murphy_graphic ? EL_SP_MURPHY :
3323 player->element_nr);
3328 PlayLevelSoundAction(x, y, ACTION_EXPLODING);
3330 if (game.emulation == EMU_SUPAPLEX)
3331 PlayLevelSound(x, y, SND_SP_ELEMENT_EXPLODING);
3333 PlayLevelSound(x, y, SND_ELEMENT_EXPLODING);
3338 if (IS_PLAYER(x, y)) /* remove objects that might cause smaller explosion */
3346 case EL_BD_BUTTERFLY:
3349 case EL_DARK_YAMYAM:
3353 RaiseScoreElement(element);
3354 Explode(x, y, EX_PHASE_START, EX_NORMAL);
3356 case EL_DYNABOMB_PLAYER_1_ACTIVE:
3357 case EL_DYNABOMB_PLAYER_2_ACTIVE:
3358 case EL_DYNABOMB_PLAYER_3_ACTIVE:
3359 case EL_DYNABOMB_PLAYER_4_ACTIVE:
3360 case EL_DYNABOMB_INCREASE_NUMBER:
3361 case EL_DYNABOMB_INCREASE_SIZE:
3362 case EL_DYNABOMB_INCREASE_POWER:
3367 case EL_LAMP_ACTIVE:
3369 case EL_AMOEBA_TO_DIAMOND:
3371 if (IS_PLAYER(x, y))
3372 Explode(x, y, EX_PHASE_START, EX_NORMAL);
3374 Explode(x, y, EX_PHASE_START, EX_CENTER);
3377 if (CAN_EXPLODE_DYNA(element))
3379 else if (CAN_EXPLODE_1X1(element))
3380 Explode(x, y, EX_PHASE_START, EX_CENTER);
3382 Explode(x, y, EX_PHASE_START, EX_NORMAL);
3386 CheckTriggeredElementChange(x, y, element, CE_OTHER_IS_EXPLODING);
3389 void SplashAcid(int x, int y)
3392 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
3393 (!IN_LEV_FIELD(x - 1, y - 2) ||
3394 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
3395 Feld[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
3397 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
3398 (!IN_LEV_FIELD(x + 1, y - 2) ||
3399 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
3400 Feld[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
3402 PlayLevelSound(x, y, SND_ACID_SPLASHING);
3404 /* input: position of element entering acid (obsolete) */
3406 int element = Feld[x][y];
3408 if (!IN_LEV_FIELD(x, y + 1) || Feld[x][y + 1] != EL_ACID)
3411 if (element != EL_ACID_SPLASH_LEFT &&
3412 element != EL_ACID_SPLASH_RIGHT)
3414 PlayLevelSound(x, y, SND_ACID_SPLASHING);
3416 if (IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y) &&
3417 (!IN_LEV_FIELD(x - 1, y - 1) ||
3418 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 1))))
3419 Feld[x - 1][y] = EL_ACID_SPLASH_LEFT;
3421 if (IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y) &&
3422 (!IN_LEV_FIELD(x + 1, y - 1) ||
3423 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 1))))
3424 Feld[x + 1][y] = EL_ACID_SPLASH_RIGHT;
3429 static void InitBeltMovement()
3431 static int belt_base_element[4] =
3433 EL_CONVEYOR_BELT_1_LEFT,
3434 EL_CONVEYOR_BELT_2_LEFT,
3435 EL_CONVEYOR_BELT_3_LEFT,
3436 EL_CONVEYOR_BELT_4_LEFT
3438 static int belt_base_active_element[4] =
3440 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
3441 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
3442 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
3443 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
3448 /* set frame order for belt animation graphic according to belt direction */
3449 for (i = 0; i < NUM_BELTS; i++)
3453 for (j = 0; j < NUM_BELT_PARTS; j++)
3455 int element = belt_base_active_element[belt_nr] + j;
3456 int graphic = el2img(element);
3458 if (game.belt_dir[i] == MV_LEFT)
3459 graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
3461 graphic_info[graphic].anim_mode |= ANIM_REVERSE;
3465 for (y = 0; y < lev_fieldy; y++)
3467 for (x = 0; x < lev_fieldx; x++)
3469 int element = Feld[x][y];
3471 for (i = 0; i < NUM_BELTS; i++)
3473 if (IS_BELT(element) && game.belt_dir[i] != MV_NO_MOVING)
3475 int e_belt_nr = getBeltNrFromBeltElement(element);
3478 if (e_belt_nr == belt_nr)
3480 int belt_part = Feld[x][y] - belt_base_element[belt_nr];
3482 Feld[x][y] = belt_base_active_element[belt_nr] + belt_part;
3490 static void ToggleBeltSwitch(int x, int y)
3492 static int belt_base_element[4] =
3494 EL_CONVEYOR_BELT_1_LEFT,
3495 EL_CONVEYOR_BELT_2_LEFT,
3496 EL_CONVEYOR_BELT_3_LEFT,
3497 EL_CONVEYOR_BELT_4_LEFT
3499 static int belt_base_active_element[4] =
3501 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
3502 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
3503 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
3504 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
3506 static int belt_base_switch_element[4] =
3508 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
3509 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
3510 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
3511 EL_CONVEYOR_BELT_4_SWITCH_LEFT
3513 static int belt_move_dir[4] =
3521 int element = Feld[x][y];
3522 int belt_nr = getBeltNrFromBeltSwitchElement(element);
3523 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
3524 int belt_dir = belt_move_dir[belt_dir_nr];
3527 if (!IS_BELT_SWITCH(element))
3530 game.belt_dir_nr[belt_nr] = belt_dir_nr;
3531 game.belt_dir[belt_nr] = belt_dir;
3533 if (belt_dir_nr == 3)
3536 /* set frame order for belt animation graphic according to belt direction */
3537 for (i = 0; i < NUM_BELT_PARTS; i++)
3539 int element = belt_base_active_element[belt_nr] + i;
3540 int graphic = el2img(element);
3542 if (belt_dir == MV_LEFT)
3543 graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
3545 graphic_info[graphic].anim_mode |= ANIM_REVERSE;
3548 for (yy = 0; yy < lev_fieldy; yy++)
3550 for (xx = 0; xx < lev_fieldx; xx++)
3552 int element = Feld[xx][yy];
3554 if (IS_BELT_SWITCH(element))
3556 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
3558 if (e_belt_nr == belt_nr)
3560 Feld[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
3561 DrawLevelField(xx, yy);
3564 else if (IS_BELT(element) && belt_dir != MV_NO_MOVING)
3566 int e_belt_nr = getBeltNrFromBeltElement(element);
3568 if (e_belt_nr == belt_nr)
3570 int belt_part = Feld[xx][yy] - belt_base_element[belt_nr];
3572 Feld[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
3573 DrawLevelField(xx, yy);
3576 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NO_MOVING)
3578 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
3580 if (e_belt_nr == belt_nr)
3582 int belt_part = Feld[xx][yy] - belt_base_active_element[belt_nr];
3584 Feld[xx][yy] = belt_base_element[belt_nr] + belt_part;
3585 DrawLevelField(xx, yy);
3592 static void ToggleSwitchgateSwitch(int x, int y)
3596 game.switchgate_pos = !game.switchgate_pos;
3598 for (yy = 0; yy < lev_fieldy; yy++)
3600 for (xx = 0; xx < lev_fieldx; xx++)
3602 int element = Feld[xx][yy];
3604 if (element == EL_SWITCHGATE_SWITCH_UP ||
3605 element == EL_SWITCHGATE_SWITCH_DOWN)
3607 Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
3608 DrawLevelField(xx, yy);
3610 else if (element == EL_SWITCHGATE_OPEN ||
3611 element == EL_SWITCHGATE_OPENING)
3613 Feld[xx][yy] = EL_SWITCHGATE_CLOSING;
3615 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
3617 PlayLevelSound(xx, yy, SND_SWITCHGATE_CLOSING);
3620 else if (element == EL_SWITCHGATE_CLOSED ||
3621 element == EL_SWITCHGATE_CLOSING)
3623 Feld[xx][yy] = EL_SWITCHGATE_OPENING;
3625 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
3627 PlayLevelSound(xx, yy, SND_SWITCHGATE_OPENING);
3634 static int getInvisibleActiveFromInvisibleElement(int element)
3636 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
3637 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
3638 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
3642 static int getInvisibleFromInvisibleActiveElement(int element)
3644 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
3645 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
3646 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
3650 static void RedrawAllLightSwitchesAndInvisibleElements()
3654 for (y = 0; y < lev_fieldy; y++)
3656 for (x = 0; x < lev_fieldx; x++)
3658 int element = Feld[x][y];
3660 if (element == EL_LIGHT_SWITCH &&
3661 game.light_time_left > 0)
3663 Feld[x][y] = EL_LIGHT_SWITCH_ACTIVE;
3664 DrawLevelField(x, y);
3666 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
3667 game.light_time_left == 0)
3669 Feld[x][y] = EL_LIGHT_SWITCH;
3670 DrawLevelField(x, y);
3672 else if (element == EL_INVISIBLE_STEELWALL ||
3673 element == EL_INVISIBLE_WALL ||
3674 element == EL_INVISIBLE_SAND)
3676 if (game.light_time_left > 0)
3677 Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
3679 DrawLevelField(x, y);
3681 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
3682 element == EL_INVISIBLE_WALL_ACTIVE ||
3683 element == EL_INVISIBLE_SAND_ACTIVE)
3685 if (game.light_time_left == 0)
3686 Feld[x][y] = getInvisibleFromInvisibleActiveElement(element);
3688 DrawLevelField(x, y);
3694 static void ToggleLightSwitch(int x, int y)
3696 int element = Feld[x][y];
3698 game.light_time_left =
3699 (element == EL_LIGHT_SWITCH ?
3700 level.time_light * FRAMES_PER_SECOND : 0);
3702 RedrawAllLightSwitchesAndInvisibleElements();
3705 static void ActivateTimegateSwitch(int x, int y)
3709 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
3711 for (yy = 0; yy < lev_fieldy; yy++)
3713 for (xx = 0; xx < lev_fieldx; xx++)
3715 int element = Feld[xx][yy];
3717 if (element == EL_TIMEGATE_CLOSED ||
3718 element == EL_TIMEGATE_CLOSING)
3720 Feld[xx][yy] = EL_TIMEGATE_OPENING;
3721 PlayLevelSound(xx, yy, SND_TIMEGATE_OPENING);
3725 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
3727 Feld[xx][yy] = EL_TIMEGATE_SWITCH;
3728 DrawLevelField(xx, yy);
3735 Feld[x][y] = EL_TIMEGATE_SWITCH_ACTIVE;
3738 inline static int getElementMoveStepsize(int x, int y)
3740 int element = Feld[x][y];
3741 int direction = MovDir[x][y];
3742 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
3743 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
3744 int horiz_move = (dx != 0);
3745 int sign = (horiz_move ? dx : dy);
3746 int step = sign * element_info[element].move_stepsize;
3748 /* special values for move stepsize for spring and things on conveyor belt */
3752 if (element == EL_SPRING)
3753 step = sign * MOVE_STEPSIZE_NORMAL * 2;
3754 else if (CAN_FALL(element) && !CAN_MOVE(element) &&
3755 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
3756 step = sign * MOVE_STEPSIZE_NORMAL / 2;
3758 if (CAN_FALL(element) &&
3759 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
3760 step = sign * MOVE_STEPSIZE_NORMAL / 2;
3761 else if (element == EL_SPRING)
3762 step = sign * MOVE_STEPSIZE_NORMAL * 2;
3769 void Impact(int x, int y)
3771 boolean lastline = (y == lev_fieldy-1);
3772 boolean object_hit = FALSE;
3773 boolean impact = (lastline || object_hit);
3774 int element = Feld[x][y];
3775 int smashed = EL_STEELWALL;
3777 if (!lastline) /* check if element below was hit */
3779 if (Feld[x][y + 1] == EL_PLAYER_IS_LEAVING)
3782 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
3783 MovDir[x][y + 1] != MV_DOWN ||
3784 MovPos[x][y + 1] <= TILEY / 2));
3787 object_hit = !IS_FREE(x, y + 1);
3790 /* do not smash moving elements that left the smashed field in time */
3791 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
3792 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
3796 smashed = MovingOrBlocked2Element(x, y + 1);
3798 impact = (lastline || object_hit);
3801 if (!lastline && smashed == EL_ACID) /* element falls into acid */
3803 SplashAcid(x, y + 1);
3807 /* only reset graphic animation if graphic really changes after impact */
3809 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
3811 ResetGfxAnimation(x, y);
3812 DrawLevelField(x, y);
3815 if (impact && CAN_EXPLODE_IMPACT(element))
3820 else if (impact && element == EL_PEARL)
3822 Feld[x][y] = EL_PEARL_BREAKING;
3823 PlayLevelSound(x, y, SND_PEARL_BREAKING);
3826 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
3828 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
3833 if (impact && element == EL_AMOEBA_DROP)
3835 if (object_hit && IS_PLAYER(x, y + 1))
3836 KillHeroUnlessEnemyProtected(x, y + 1);
3837 else if (object_hit && smashed == EL_PENGUIN)
3841 Feld[x][y] = EL_AMOEBA_GROWING;
3842 Store[x][y] = EL_AMOEBA_WET;
3844 ResetRandomAnimationValue(x, y);
3849 if (object_hit) /* check which object was hit */
3851 if (CAN_PASS_MAGIC_WALL(element) &&
3852 (smashed == EL_MAGIC_WALL ||
3853 smashed == EL_BD_MAGIC_WALL))
3856 int activated_magic_wall =
3857 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
3858 EL_BD_MAGIC_WALL_ACTIVE);
3860 /* activate magic wall / mill */
3861 for (yy = 0; yy < lev_fieldy; yy++)
3862 for (xx = 0; xx < lev_fieldx; xx++)
3863 if (Feld[xx][yy] == smashed)
3864 Feld[xx][yy] = activated_magic_wall;
3866 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
3867 game.magic_wall_active = TRUE;
3869 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
3870 SND_MAGIC_WALL_ACTIVATING :
3871 SND_BD_MAGIC_WALL_ACTIVATING));
3874 if (IS_PLAYER(x, y + 1))
3876 if (CAN_SMASH_PLAYER(element))
3878 KillHeroUnlessEnemyProtected(x, y + 1);
3882 else if (smashed == EL_PENGUIN)
3884 if (CAN_SMASH_PLAYER(element))
3890 else if (element == EL_BD_DIAMOND)
3892 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
3898 else if (((element == EL_SP_INFOTRON ||
3899 element == EL_SP_ZONK) &&
3900 (smashed == EL_SP_SNIKSNAK ||
3901 smashed == EL_SP_ELECTRON ||
3902 smashed == EL_SP_DISK_ORANGE)) ||
3903 (element == EL_SP_INFOTRON &&
3904 smashed == EL_SP_DISK_YELLOW))
3910 else if (CAN_SMASH_ENEMIES(element) && IS_CLASSIC_ENEMY(smashed))
3916 else if (CAN_SMASH_EVERYTHING(element))
3918 if (IS_CLASSIC_ENEMY(smashed) ||
3919 CAN_EXPLODE_SMASHED(smashed))
3924 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
3926 if (smashed == EL_LAMP ||
3927 smashed == EL_LAMP_ACTIVE)
3932 else if (smashed == EL_NUT)
3934 Feld[x][y + 1] = EL_NUT_BREAKING;
3935 PlayLevelSound(x, y, SND_NUT_BREAKING);
3936 RaiseScoreElement(EL_NUT);
3939 else if (smashed == EL_PEARL)
3941 Feld[x][y + 1] = EL_PEARL_BREAKING;
3942 PlayLevelSound(x, y, SND_PEARL_BREAKING);
3945 else if (smashed == EL_DIAMOND)
3947 Feld[x][y + 1] = EL_DIAMOND_BREAKING;
3948 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
3951 else if (IS_BELT_SWITCH(smashed))
3953 ToggleBeltSwitch(x, y + 1);
3955 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
3956 smashed == EL_SWITCHGATE_SWITCH_DOWN)
3958 ToggleSwitchgateSwitch(x, y + 1);
3960 else if (smashed == EL_LIGHT_SWITCH ||
3961 smashed == EL_LIGHT_SWITCH_ACTIVE)
3963 ToggleLightSwitch(x, y + 1);
3968 TestIfElementSmashesCustomElement(x, y, MV_DOWN);
3971 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
3973 CheckTriggeredElementChangeSide(x, y + 1, smashed,
3974 CE_OTHER_IS_SWITCHING, CH_SIDE_TOP);
3975 CheckElementChangeSide(x, y + 1, smashed, element,
3976 CE_SWITCHED, CH_SIDE_TOP);
3981 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
3986 /* play sound of magic wall / mill */
3988 (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
3989 Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
3991 if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
3992 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
3993 else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
3994 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
3999 /* play sound of object that hits the ground */
4000 if (lastline || object_hit)
4001 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
4004 inline static void TurnRoundExt(int x, int y)
4016 { 0, 0 }, { 0, 0 }, { 0, 0 },
4021 int left, right, back;
4025 { MV_DOWN, MV_UP, MV_RIGHT },
4026 { MV_UP, MV_DOWN, MV_LEFT },
4028 { MV_LEFT, MV_RIGHT, MV_DOWN },
4032 { MV_RIGHT, MV_LEFT, MV_UP }
4035 int element = Feld[x][y];
4036 int move_pattern = element_info[element].move_pattern;
4038 int old_move_dir = MovDir[x][y];
4039 int left_dir = turn[old_move_dir].left;
4040 int right_dir = turn[old_move_dir].right;
4041 int back_dir = turn[old_move_dir].back;
4043 int left_dx = move_xy[left_dir].x, left_dy = move_xy[left_dir].y;
4044 int right_dx = move_xy[right_dir].x, right_dy = move_xy[right_dir].y;
4045 int move_dx = move_xy[old_move_dir].x, move_dy = move_xy[old_move_dir].y;
4046 int back_dx = move_xy[back_dir].x, back_dy = move_xy[back_dir].y;
4048 int left_x = x + left_dx, left_y = y + left_dy;
4049 int right_x = x + right_dx, right_y = y + right_dy;
4050 int move_x = x + move_dx, move_y = y + move_dy;
4054 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4056 TestIfBadThingTouchesOtherBadThing(x, y);
4058 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
4059 MovDir[x][y] = right_dir;
4060 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
4061 MovDir[x][y] = left_dir;
4063 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
4065 else if (element == EL_BD_BUTTERFLY) /* && MovDir[x][y] == left_dir) */
4069 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4070 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4072 TestIfBadThingTouchesOtherBadThing(x, y);
4074 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
4075 MovDir[x][y] = left_dir;
4076 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
4077 MovDir[x][y] = right_dir;
4079 if ((element == EL_SPACESHIP ||
4080 element == EL_SP_SNIKSNAK ||
4081 element == EL_SP_ELECTRON)
4082 && MovDir[x][y] != old_move_dir)
4084 else if (element == EL_BD_FIREFLY) /* && MovDir[x][y] == right_dir) */
4088 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
4090 TestIfBadThingTouchesOtherBadThing(x, y);
4092 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
4093 MovDir[x][y] = left_dir;
4094 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
4095 MovDir[x][y] = right_dir;
4097 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
4099 else if (element == EL_BD_FIREFLY) /* && MovDir[x][y] == right_dir) */
4102 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4104 TestIfBadThingTouchesOtherBadThing(x, y);
4106 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
4107 MovDir[x][y] = left_dir;
4108 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
4109 MovDir[x][y] = right_dir;
4111 if (MovDir[x][y] != old_move_dir)
4115 else if (element == EL_YAMYAM)
4117 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
4118 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
4120 if (can_turn_left && can_turn_right)
4121 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4122 else if (can_turn_left)
4123 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4124 else if (can_turn_right)
4125 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4127 MovDir[x][y] = back_dir;
4129 MovDelay[x][y] = 16 + 16 * RND(3);
4131 else if (element == EL_DARK_YAMYAM)
4133 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
4135 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
4138 if (can_turn_left && can_turn_right)
4139 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4140 else if (can_turn_left)
4141 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4142 else if (can_turn_right)
4143 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4145 MovDir[x][y] = back_dir;
4147 MovDelay[x][y] = 16 + 16 * RND(3);
4149 else if (element == EL_PACMAN)
4151 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
4152 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
4154 if (can_turn_left && can_turn_right)
4155 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4156 else if (can_turn_left)
4157 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4158 else if (can_turn_right)
4159 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4161 MovDir[x][y] = back_dir;
4163 MovDelay[x][y] = 6 + RND(40);
4165 else if (element == EL_PIG)
4167 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
4168 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
4169 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
4170 boolean should_turn_left, should_turn_right, should_move_on;
4172 int rnd = RND(rnd_value);
4174 should_turn_left = (can_turn_left &&
4176 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
4177 y + back_dy + left_dy)));
4178 should_turn_right = (can_turn_right &&
4180 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
4181 y + back_dy + right_dy)));
4182 should_move_on = (can_move_on &&
4185 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
4186 y + move_dy + left_dy) ||
4187 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
4188 y + move_dy + right_dy)));
4190 if (should_turn_left || should_turn_right || should_move_on)
4192 if (should_turn_left && should_turn_right && should_move_on)
4193 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
4194 rnd < 2 * rnd_value / 3 ? right_dir :
4196 else if (should_turn_left && should_turn_right)
4197 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4198 else if (should_turn_left && should_move_on)
4199 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
4200 else if (should_turn_right && should_move_on)
4201 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
4202 else if (should_turn_left)
4203 MovDir[x][y] = left_dir;
4204 else if (should_turn_right)
4205 MovDir[x][y] = right_dir;
4206 else if (should_move_on)
4207 MovDir[x][y] = old_move_dir;
4209 else if (can_move_on && rnd > rnd_value / 8)
4210 MovDir[x][y] = old_move_dir;
4211 else if (can_turn_left && can_turn_right)
4212 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4213 else if (can_turn_left && rnd > rnd_value / 8)
4214 MovDir[x][y] = left_dir;
4215 else if (can_turn_right && rnd > rnd_value/8)
4216 MovDir[x][y] = right_dir;
4218 MovDir[x][y] = back_dir;
4220 xx = x + move_xy[MovDir[x][y]].x;
4221 yy = y + move_xy[MovDir[x][y]].y;
4223 if (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Feld[xx][yy]))
4224 MovDir[x][y] = old_move_dir;
4228 else if (element == EL_DRAGON)
4230 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
4231 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
4232 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
4234 int rnd = RND(rnd_value);
4237 if (FrameCounter < 1 && x == 0 && y == 29)
4238 printf(":2: %d/%d: %d [%d]\n", x, y, MovDir[x][y], FrameCounter);
4241 if (can_move_on && rnd > rnd_value / 8)
4242 MovDir[x][y] = old_move_dir;
4243 else if (can_turn_left && can_turn_right)
4244 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4245 else if (can_turn_left && rnd > rnd_value / 8)
4246 MovDir[x][y] = left_dir;
4247 else if (can_turn_right && rnd > rnd_value / 8)
4248 MovDir[x][y] = right_dir;
4250 MovDir[x][y] = back_dir;
4252 xx = x + move_xy[MovDir[x][y]].x;
4253 yy = y + move_xy[MovDir[x][y]].y;
4256 if (FrameCounter < 1 && x == 0 && y == 29)
4257 printf(":3: %d/%d: %d (%d/%d: %d) [%d]\n", x, y, MovDir[x][y],
4258 xx, yy, Feld[xx][yy],
4263 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
4264 MovDir[x][y] = old_move_dir;
4266 if (!IS_FREE(xx, yy))
4267 MovDir[x][y] = old_move_dir;
4271 if (FrameCounter < 1 && x == 0 && y == 29)
4272 printf(":4: %d/%d: %d [%d]\n", x, y, MovDir[x][y], FrameCounter);
4277 else if (element == EL_MOLE)
4279 boolean can_move_on =
4280 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
4281 IS_AMOEBOID(Feld[move_x][move_y]) ||
4282 Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
4285 boolean can_turn_left =
4286 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
4287 IS_AMOEBOID(Feld[left_x][left_y])));
4289 boolean can_turn_right =
4290 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
4291 IS_AMOEBOID(Feld[right_x][right_y])));
4293 if (can_turn_left && can_turn_right)
4294 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
4295 else if (can_turn_left)
4296 MovDir[x][y] = left_dir;
4298 MovDir[x][y] = right_dir;
4301 if (MovDir[x][y] != old_move_dir)
4304 else if (element == EL_BALLOON)
4306 MovDir[x][y] = game.balloon_dir;
4309 else if (element == EL_SPRING)
4312 if (MovDir[x][y] & MV_HORIZONTAL &&
4313 !SPRING_CAN_ENTER_FIELD(element, move_x, move_y))
4314 MovDir[x][y] = MV_NO_MOVING;
4316 if (MovDir[x][y] & MV_HORIZONTAL &&
4317 (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
4318 SPRING_CAN_ENTER_FIELD(element, x, y + 1)))
4319 MovDir[x][y] = MV_NO_MOVING;
4324 else if (element == EL_ROBOT ||
4325 element == EL_SATELLITE ||
4326 element == EL_PENGUIN)
4328 int attr_x = -1, attr_y = -1;
4339 for (i = 0; i < MAX_PLAYERS; i++)
4341 struct PlayerInfo *player = &stored_player[i];
4342 int jx = player->jx, jy = player->jy;
4344 if (!player->active)
4348 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
4356 if (element == EL_ROBOT && ZX >= 0 && ZY >= 0)
4362 if (element == EL_PENGUIN)
4365 static int xy[4][2] =
4373 for (i = 0; i < NUM_DIRECTIONS; i++)
4375 int ex = x + xy[i][0];
4376 int ey = y + xy[i][1];
4378 if (IN_LEV_FIELD(ex, ey) && Feld[ex][ey] == EL_EXIT_OPEN)
4387 MovDir[x][y] = MV_NO_MOVING;
4389 MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
4390 else if (attr_x > x)
4391 MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
4393 MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
4394 else if (attr_y > y)
4395 MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
4397 if (element == EL_ROBOT)
4401 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4402 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
4403 Moving2Blocked(x, y, &newx, &newy);
4405 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
4406 MovDelay[x][y] = 8 + 8 * !RND(3);
4408 MovDelay[x][y] = 16;
4410 else if (element == EL_PENGUIN)
4416 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4418 boolean first_horiz = RND(2);
4419 int new_move_dir = MovDir[x][y];
4422 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4423 Moving2Blocked(x, y, &newx, &newy);
4425 if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
4429 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4430 Moving2Blocked(x, y, &newx, &newy);
4432 if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
4435 MovDir[x][y] = old_move_dir;
4439 else /* (element == EL_SATELLITE) */
4445 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4447 boolean first_horiz = RND(2);
4448 int new_move_dir = MovDir[x][y];
4451 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4452 Moving2Blocked(x, y, &newx, &newy);
4454 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
4458 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4459 Moving2Blocked(x, y, &newx, &newy);
4461 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
4464 MovDir[x][y] = old_move_dir;
4469 else if (move_pattern == MV_TURNING_LEFT ||
4470 move_pattern == MV_TURNING_RIGHT ||
4471 move_pattern == MV_TURNING_LEFT_RIGHT ||
4472 move_pattern == MV_TURNING_RIGHT_LEFT ||
4473 move_pattern == MV_TURNING_RANDOM ||
4474 move_pattern == MV_ALL_DIRECTIONS)
4476 boolean can_turn_left =
4477 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
4478 boolean can_turn_right =
4479 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
4481 if (move_pattern == MV_TURNING_LEFT)
4482 MovDir[x][y] = left_dir;
4483 else if (move_pattern == MV_TURNING_RIGHT)
4484 MovDir[x][y] = right_dir;
4485 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
4486 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
4487 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
4488 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
4489 else if (move_pattern == MV_TURNING_RANDOM)
4490 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
4491 can_turn_right && !can_turn_left ? right_dir :
4492 RND(2) ? left_dir : right_dir);
4493 else if (can_turn_left && can_turn_right)
4494 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4495 else if (can_turn_left)
4496 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4497 else if (can_turn_right)
4498 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4500 MovDir[x][y] = back_dir;
4502 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4504 else if (move_pattern == MV_HORIZONTAL ||
4505 move_pattern == MV_VERTICAL)
4507 if (move_pattern & old_move_dir)
4508 MovDir[x][y] = back_dir;
4509 else if (move_pattern == MV_HORIZONTAL)
4510 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4511 else if (move_pattern == MV_VERTICAL)
4512 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4514 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4516 else if (move_pattern & MV_ANY_DIRECTION)
4518 MovDir[x][y] = move_pattern;
4519 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4521 else if (move_pattern == MV_ALONG_LEFT_SIDE)
4523 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
4524 MovDir[x][y] = left_dir;
4525 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4526 MovDir[x][y] = right_dir;
4528 if (MovDir[x][y] != old_move_dir)
4529 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4531 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
4533 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
4534 MovDir[x][y] = right_dir;
4535 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4536 MovDir[x][y] = left_dir;
4538 if (MovDir[x][y] != old_move_dir)
4539 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4541 else if (move_pattern == MV_TOWARDS_PLAYER ||
4542 move_pattern == MV_AWAY_FROM_PLAYER)
4544 int attr_x = -1, attr_y = -1;
4546 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
4557 for (i = 0; i < MAX_PLAYERS; i++)
4559 struct PlayerInfo *player = &stored_player[i];
4560 int jx = player->jx, jy = player->jy;
4562 if (!player->active)
4566 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
4574 MovDir[x][y] = MV_NO_MOVING;
4576 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
4577 else if (attr_x > x)
4578 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
4580 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
4581 else if (attr_y > y)
4582 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
4584 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4586 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4588 boolean first_horiz = RND(2);
4589 int new_move_dir = MovDir[x][y];
4592 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4593 Moving2Blocked(x, y, &newx, &newy);
4595 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
4599 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4600 Moving2Blocked(x, y, &newx, &newy);
4602 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
4605 MovDir[x][y] = old_move_dir;
4608 else if (move_pattern == MV_WHEN_PUSHED ||
4609 move_pattern == MV_WHEN_DROPPED)
4611 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4612 MovDir[x][y] = MV_NO_MOVING;
4616 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
4618 static int test_xy[7][2] =
4628 static int test_dir[7] =
4638 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
4639 int move_preference = -1000000; /* start with very low preference */
4640 int new_move_dir = MV_NO_MOVING;
4641 int start_test = RND(4);
4644 for (i = 0; i < NUM_DIRECTIONS; i++)
4646 int move_dir = test_dir[start_test + i];
4647 int move_dir_preference;
4649 xx = x + test_xy[start_test + i][0];
4650 yy = y + test_xy[start_test + i][1];
4652 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
4653 (IS_PLAYER(xx, yy) || Feld[xx][yy] == EL_PLAYER_IS_LEAVING))
4655 new_move_dir = move_dir;
4660 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
4663 move_dir_preference = -1 * RunnerVisit[xx][yy];
4664 if (hunter_mode && PlayerVisit[xx][yy] > 0)
4665 move_dir_preference = PlayerVisit[xx][yy];
4667 if (move_dir_preference > move_preference)
4669 /* prefer field that has not been visited for the longest time */
4670 move_preference = move_dir_preference;
4671 new_move_dir = move_dir;
4673 else if (move_dir_preference == move_preference &&
4674 move_dir == old_move_dir)
4676 /* prefer last direction when all directions are preferred equally */
4677 move_preference = move_dir_preference;
4678 new_move_dir = move_dir;
4682 MovDir[x][y] = new_move_dir;
4683 if (old_move_dir != new_move_dir)
4688 static void TurnRound(int x, int y)
4690 int direction = MovDir[x][y];
4693 GfxDir[x][y] = MovDir[x][y];
4699 GfxDir[x][y] = MovDir[x][y];
4702 if (direction != MovDir[x][y])
4707 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_BIT(direction);
4710 GfxAction[x][y] = ACTION_WAITING;
4714 static boolean JustBeingPushed(int x, int y)
4718 for (i = 0; i < MAX_PLAYERS; i++)
4720 struct PlayerInfo *player = &stored_player[i];
4722 if (player->active && player->is_pushing && player->MovPos)
4724 int next_jx = player->jx + (player->jx - player->last_jx);
4725 int next_jy = player->jy + (player->jy - player->last_jy);
4727 if (x == next_jx && y == next_jy)
4735 void StartMoving(int x, int y)
4738 boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0,0));
4740 boolean started_moving = FALSE; /* some elements can fall _and_ move */
4741 int element = Feld[x][y];
4747 if (MovDelay[x][y] == 0)
4748 GfxAction[x][y] = ACTION_DEFAULT;
4750 /* !!! this should be handled more generic (not only for mole) !!! */
4751 if (element != EL_MOLE && GfxAction[x][y] != ACTION_DIGGING)
4752 GfxAction[x][y] = ACTION_DEFAULT;
4755 if (CAN_FALL(element) && y < lev_fieldy - 1)
4757 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
4758 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
4759 if (JustBeingPushed(x, y))
4762 if (element == EL_QUICKSAND_FULL)
4764 if (IS_FREE(x, y + 1))
4766 InitMovingField(x, y, MV_DOWN);
4767 started_moving = TRUE;
4769 Feld[x][y] = EL_QUICKSAND_EMPTYING;
4770 Store[x][y] = EL_ROCK;
4772 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
4774 PlayLevelSound(x, y, SND_QUICKSAND_EMPTYING);
4777 else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
4779 if (!MovDelay[x][y])
4780 MovDelay[x][y] = TILEY + 1;
4789 Feld[x][y] = EL_QUICKSAND_EMPTY;
4790 Feld[x][y + 1] = EL_QUICKSAND_FULL;
4791 Store[x][y + 1] = Store[x][y];
4794 PlayLevelSoundAction(x, y, ACTION_FILLING);
4796 PlayLevelSound(x, y, SND_QUICKSAND_FILLING);
4800 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
4801 Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
4803 InitMovingField(x, y, MV_DOWN);
4804 started_moving = TRUE;
4806 Feld[x][y] = EL_QUICKSAND_FILLING;
4807 Store[x][y] = element;
4809 PlayLevelSoundAction(x, y, ACTION_FILLING);
4811 PlayLevelSound(x, y, SND_QUICKSAND_FILLING);
4814 else if (element == EL_MAGIC_WALL_FULL)
4816 if (IS_FREE(x, y + 1))
4818 InitMovingField(x, y, MV_DOWN);
4819 started_moving = TRUE;
4821 Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
4822 Store[x][y] = EL_CHANGED(Store[x][y]);
4824 else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
4826 if (!MovDelay[x][y])
4827 MovDelay[x][y] = TILEY/4 + 1;
4836 Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
4837 Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
4838 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
4842 else if (element == EL_BD_MAGIC_WALL_FULL)
4844 if (IS_FREE(x, y + 1))
4846 InitMovingField(x, y, MV_DOWN);
4847 started_moving = TRUE;
4849 Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
4850 Store[x][y] = EL_CHANGED2(Store[x][y]);
4852 else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
4854 if (!MovDelay[x][y])
4855 MovDelay[x][y] = TILEY/4 + 1;
4864 Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
4865 Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
4866 Store[x][y + 1] = EL_CHANGED2(Store[x][y]);
4870 else if (CAN_PASS_MAGIC_WALL(element) &&
4871 (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
4872 Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
4874 InitMovingField(x, y, MV_DOWN);
4875 started_moving = TRUE;
4878 (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
4879 EL_BD_MAGIC_WALL_FILLING);
4880 Store[x][y] = element;
4883 else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_ACID)
4885 else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
4888 SplashAcid(x, y + 1);
4890 InitMovingField(x, y, MV_DOWN);
4891 started_moving = TRUE;
4893 Store[x][y] = EL_ACID;
4895 /* !!! TEST !!! better use "_FALLING" etc. !!! */
4896 GfxAction[x][y + 1] = ACTION_ACTIVE;
4900 else if ((game.engine_version < VERSION_IDENT(2,2,0,7) &&
4901 CAN_SMASH(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
4902 (Feld[x][y + 1] == EL_BLOCKED)) ||
4903 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
4904 CAN_SMASH(element) && WasJustFalling[x][y] &&
4905 (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))))
4909 else if (game.engine_version < VERSION_IDENT(2,2,0,7) &&
4910 CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
4911 WasJustMoving[x][y] && !Pushed[x][y + 1])
4913 else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
4914 WasJustMoving[x][y])
4919 /* this is needed for a special case not covered by calling "Impact()"
4920 from "ContinueMoving()": if an element moves to a tile directly below
4921 another element which was just falling on that tile (which was empty
4922 in the previous frame), the falling element above would just stop
4923 instead of smashing the element below (in previous version, the above
4924 element was just checked for "moving" instead of "falling", resulting
4925 in incorrect smashes caused by horizontal movement of the above
4926 element; also, the case of the player being the element to smash was
4927 simply not covered here... :-/ ) */
4930 WasJustMoving[x][y] = 0;
4931 WasJustFalling[x][y] = 0;
4936 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
4938 if (MovDir[x][y] == MV_NO_MOVING)
4940 InitMovingField(x, y, MV_DOWN);
4941 started_moving = TRUE;
4944 else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
4946 if (WasJustFalling[x][y]) /* prevent animation from being restarted */
4947 MovDir[x][y] = MV_DOWN;
4949 InitMovingField(x, y, MV_DOWN);
4950 started_moving = TRUE;
4952 else if (element == EL_AMOEBA_DROP)
4954 Feld[x][y] = EL_AMOEBA_GROWING;
4955 Store[x][y] = EL_AMOEBA_WET;
4957 /* Store[x][y + 1] must be zero, because:
4958 (EL_QUICKSAND_FULL -> EL_ROCK): Store[x][y + 1] == EL_QUICKSAND_EMPTY
4961 #if OLD_GAME_BEHAVIOUR
4962 else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1])
4964 else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1] &&
4965 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
4966 element != EL_DX_SUPABOMB)
4969 else if (((IS_SLIPPERY(Feld[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
4970 (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
4971 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
4972 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
4975 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
4976 (IS_FREE(x - 1, y + 1) ||
4977 Feld[x - 1][y + 1] == EL_ACID));
4978 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
4979 (IS_FREE(x + 1, y + 1) ||
4980 Feld[x + 1][y + 1] == EL_ACID));
4981 boolean can_fall_any = (can_fall_left || can_fall_right);
4982 boolean can_fall_both = (can_fall_left && can_fall_right);
4984 if (can_fall_any && IS_CUSTOM_ELEMENT(Feld[x][y + 1]))
4986 int slippery_type = element_info[Feld[x][y + 1]].slippery_type;
4988 if (slippery_type == SLIPPERY_ONLY_LEFT)
4989 can_fall_right = FALSE;
4990 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
4991 can_fall_left = FALSE;
4992 else if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
4993 can_fall_right = FALSE;
4994 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
4995 can_fall_left = FALSE;
4997 can_fall_any = (can_fall_left || can_fall_right);
4998 can_fall_both = (can_fall_left && can_fall_right);
5003 if (can_fall_both &&
5004 (game.emulation != EMU_BOULDERDASH &&
5005 element != EL_BD_ROCK && element != EL_BD_DIAMOND))
5006 can_fall_left = !(can_fall_right = RND(2));
5008 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
5009 started_moving = TRUE;
5013 else if (IS_BELT_ACTIVE(Feld[x][y + 1]) && !CAN_MOVE(element))
5015 else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
5018 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
5019 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
5020 int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
5021 int belt_dir = game.belt_dir[belt_nr];
5023 if ((belt_dir == MV_LEFT && left_is_free) ||
5024 (belt_dir == MV_RIGHT && right_is_free))
5027 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
5030 InitMovingField(x, y, belt_dir);
5031 started_moving = TRUE;
5034 Pushed[x][y] = TRUE;
5035 Pushed[nextx][y] = TRUE;
5038 GfxAction[x][y] = ACTION_DEFAULT;
5042 MovDir[x][y] = 0; /* if element was moving, stop it */
5047 /* not "else if" because of elements that can fall and move (EL_SPRING) */
5048 if (CAN_MOVE(element) && !started_moving)
5050 int move_pattern = element_info[element].move_pattern;
5053 Moving2Blocked(x, y, &newx, &newy);
5056 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
5059 if ((element == EL_SATELLITE ||
5060 element == EL_BALLOON ||
5061 element == EL_SPRING)
5062 && JustBeingPushed(x, y))
5067 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
5068 WasJustMoving[x][y] && IN_LEV_FIELD(newx, newy) &&
5069 (Feld[newx][newy] == EL_BLOCKED || IS_PLAYER(newx, newy)))
5072 printf("::: element %d '%s' WasJustMoving %d [%d, %d, %d, %d]\n",
5073 element, element_info[element].token_name,
5074 WasJustMoving[x][y],
5075 HAS_ANY_CHANGE_EVENT(element, CE_HITTING_SOMETHING),
5076 HAS_ANY_CHANGE_EVENT(element, CE_HIT_BY_SOMETHING),
5077 HAS_ANY_CHANGE_EVENT(element, CE_OTHER_IS_HITTING),
5078 HAS_ANY_CHANGE_EVENT(element, CE_OTHER_GETS_HIT));
5082 WasJustMoving[x][y] = 0;
5085 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
5088 if (Feld[x][y] != element) /* element has changed */
5090 element = Feld[x][y];
5091 move_pattern = element_info[element].move_pattern;
5093 if (!CAN_MOVE(element))
5097 if (Feld[x][y] != element) /* element has changed */
5105 if (element == EL_SPRING && MovDir[x][y] == MV_DOWN)
5106 Feld[x][y + 1] = EL_EMPTY; /* was set to EL_BLOCKED above */
5108 if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
5110 Moving2Blocked(x, y, &newx, &newy);
5111 if (Feld[newx][newy] == EL_BLOCKED)
5112 Feld[newx][newy] = EL_EMPTY; /* was set to EL_BLOCKED above */
5118 if (FrameCounter < 1 && x == 0 && y == 29)
5119 printf(":1: %d/%d: %d [%d]\n", x, y, MovDir[x][y], FrameCounter);
5122 if (!MovDelay[x][y]) /* start new movement phase */
5124 /* all objects that can change their move direction after each step
5125 (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall */
5127 if (element != EL_YAMYAM &&
5128 element != EL_DARK_YAMYAM &&
5129 element != EL_PACMAN &&
5130 !(move_pattern & MV_ANY_DIRECTION) &&
5131 move_pattern != MV_TURNING_LEFT &&
5132 move_pattern != MV_TURNING_RIGHT &&
5133 move_pattern != MV_TURNING_LEFT_RIGHT &&
5134 move_pattern != MV_TURNING_RIGHT_LEFT &&
5135 move_pattern != MV_TURNING_RANDOM)
5140 if (FrameCounter < 1 && x == 0 && y == 29)
5141 printf(":9: %d: %d [%d]\n", y, MovDir[x][y], FrameCounter);
5144 if (MovDelay[x][y] && (element == EL_BUG ||
5145 element == EL_SPACESHIP ||
5146 element == EL_SP_SNIKSNAK ||
5147 element == EL_SP_ELECTRON ||
5148 element == EL_MOLE))
5149 DrawLevelField(x, y);
5153 if (MovDelay[x][y]) /* wait some time before next movement */
5158 if (element == EL_YAMYAM)
5161 el_act_dir2img(EL_YAMYAM, ACTION_WAITING, MV_LEFT));
5162 DrawLevelElementAnimation(x, y, element);
5166 if (MovDelay[x][y]) /* element still has to wait some time */
5169 /* !!! PLACE THIS SOMEWHERE AFTER "TurnRound()" !!! */
5170 ResetGfxAnimation(x, y);
5174 if (GfxAction[x][y] != ACTION_WAITING)
5175 printf("::: %d: %d != ACTION_WAITING\n", element, GfxAction[x][y]);
5177 GfxAction[x][y] = ACTION_WAITING;
5181 if (element == EL_ROBOT ||
5183 element == EL_PACMAN ||
5185 element == EL_YAMYAM ||
5186 element == EL_DARK_YAMYAM)
5189 DrawLevelElementAnimation(x, y, element);
5191 DrawLevelElementAnimationIfNeeded(x, y, element);
5193 PlayLevelSoundAction(x, y, ACTION_WAITING);
5195 else if (element == EL_SP_ELECTRON)
5196 DrawLevelElementAnimationIfNeeded(x, y, element);
5197 else if (element == EL_DRAGON)
5200 int dir = MovDir[x][y];
5201 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
5202 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
5203 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
5204 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
5205 dir == MV_UP ? IMG_FLAMES_1_UP :
5206 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
5207 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5210 printf("::: %d, %d\n", GfxAction[x][y], GfxFrame[x][y]);
5213 GfxAction[x][y] = ACTION_ATTACKING;
5215 if (IS_PLAYER(x, y))
5216 DrawPlayerField(x, y);
5218 DrawLevelField(x, y);
5220 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
5222 for (i = 1; i <= 3; i++)
5224 int xx = x + i * dx;
5225 int yy = y + i * dy;
5226 int sx = SCREENX(xx);
5227 int sy = SCREENY(yy);
5228 int flame_graphic = graphic + (i - 1);
5230 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
5235 int flamed = MovingOrBlocked2Element(xx, yy);
5237 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
5240 RemoveMovingField(xx, yy);
5242 Feld[xx][yy] = EL_FLAMES;
5243 if (IN_SCR_FIELD(sx, sy))
5245 DrawLevelFieldCrumbledSand(xx, yy);
5246 DrawGraphic(sx, sy, flame_graphic, frame);
5251 if (Feld[xx][yy] == EL_FLAMES)
5252 Feld[xx][yy] = EL_EMPTY;
5253 DrawLevelField(xx, yy);
5258 if (MovDelay[x][y]) /* element still has to wait some time */
5260 PlayLevelSoundAction(x, y, ACTION_WAITING);
5266 /* special case of "moving" animation of waiting elements (FIX THIS !!!);
5267 for all other elements GfxAction will be set by InitMovingField() */
5268 if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY)
5269 GfxAction[x][y] = ACTION_MOVING;
5273 /* now make next step */
5275 Moving2Blocked(x, y, &newx, &newy); /* get next screen position */
5277 if (DONT_COLLIDE_WITH(element) &&
5278 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
5279 !PLAYER_ENEMY_PROTECTED(newx, newy))
5282 TestIfBadThingRunsIntoHero(x, y, MovDir[x][y]);
5286 /* player killed by element which is deadly when colliding with */
5288 KillHero(PLAYERINFO(newx, newy));
5295 else if (CAN_MOVE_INTO_ACID(element) &&
5296 IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID &&
5297 (MovDir[x][y] == MV_DOWN ||
5298 game.engine_version >= VERSION_IDENT(3,1,0,0)))
5300 else if (CAN_MOVE_INTO_ACID(element) && MovDir[x][y] == MV_DOWN &&
5301 IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID)
5305 else if ((element == EL_PENGUIN ||
5306 element == EL_ROBOT ||
5307 element == EL_SATELLITE ||
5308 element == EL_BALLOON ||
5309 IS_CUSTOM_ELEMENT(element)) &&
5310 IN_LEV_FIELD(newx, newy) &&
5311 MovDir[x][y] == MV_DOWN && Feld[newx][newy] == EL_ACID)
5314 SplashAcid(newx, newy);
5315 Store[x][y] = EL_ACID;
5317 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
5319 if (Feld[newx][newy] == EL_EXIT_OPEN)
5323 DrawLevelField(x, y);
5325 Feld[x][y] = EL_EMPTY;
5326 DrawLevelField(x, y);
5329 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
5330 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
5331 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
5333 local_player->friends_still_needed--;
5334 if (!local_player->friends_still_needed &&
5335 !local_player->GameOver && AllPlayersGone)
5336 local_player->LevelSolved = local_player->GameOver = TRUE;
5340 else if (IS_FOOD_PENGUIN(Feld[newx][newy]))
5342 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MF_MOVING)
5343 DrawLevelField(newx, newy);
5345 GfxDir[x][y] = MovDir[x][y] = MV_NO_MOVING;
5347 else if (!IS_FREE(newx, newy))
5349 GfxAction[x][y] = ACTION_WAITING;
5351 if (IS_PLAYER(x, y))
5352 DrawPlayerField(x, y);
5354 DrawLevelField(x, y);
5359 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
5361 if (IS_FOOD_PIG(Feld[newx][newy]))
5363 if (IS_MOVING(newx, newy))
5364 RemoveMovingField(newx, newy);
5367 Feld[newx][newy] = EL_EMPTY;
5368 DrawLevelField(newx, newy);
5371 PlayLevelSound(x, y, SND_PIG_DIGGING);
5373 else if (!IS_FREE(newx, newy))
5375 if (IS_PLAYER(x, y))
5376 DrawPlayerField(x, y);
5378 DrawLevelField(x, y);
5387 else if (move_pattern & MV_MAZE_RUNNER_STYLE && IN_LEV_FIELD(newx, newy))
5390 else if (IS_CUSTOM_ELEMENT(element) &&
5391 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy)
5395 !IS_FREE(newx, newy)
5400 int new_element = Feld[newx][newy];
5403 printf("::: '%s' digs '%s' [%d]\n",
5404 element_info[element].token_name,
5405 element_info[Feld[newx][newy]].token_name,
5406 StorePlayer[newx][newy]);
5409 if (!IS_FREE(newx, newy))
5411 int action = (IS_DIGGABLE(new_element) ? ACTION_DIGGING :
5412 IS_COLLECTIBLE(new_element) ? ACTION_COLLECTING :
5415 /* no element can dig solid indestructible elements */
5416 if (IS_INDESTRUCTIBLE(new_element) &&
5417 !IS_DIGGABLE(new_element) &&
5418 !IS_COLLECTIBLE(new_element))
5421 if (AmoebaNr[newx][newy] &&
5422 (new_element == EL_AMOEBA_FULL ||
5423 new_element == EL_BD_AMOEBA ||
5424 new_element == EL_AMOEBA_GROWING))
5426 AmoebaCnt[AmoebaNr[newx][newy]]--;
5427 AmoebaCnt2[AmoebaNr[newx][newy]]--;
5430 if (IS_MOVING(newx, newy))
5431 RemoveMovingField(newx, newy);
5434 RemoveField(newx, newy);
5435 DrawLevelField(newx, newy);
5438 PlayLevelSoundAction(x, y, action);
5441 if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element)))
5442 element_info[element].can_leave_element = TRUE;
5444 if (move_pattern & MV_MAZE_RUNNER_STYLE)
5446 RunnerVisit[x][y] = FrameCounter;
5447 PlayerVisit[x][y] /= 8; /* expire player visit path */
5453 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
5455 if (!IS_FREE(newx, newy))
5457 if (IS_PLAYER(x, y))
5458 DrawPlayerField(x, y);
5460 DrawLevelField(x, y);
5466 boolean wanna_flame = !RND(10);
5467 int dx = newx - x, dy = newy - y;
5468 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
5469 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
5470 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
5471 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
5472 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
5473 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
5476 IS_CLASSIC_ENEMY(element1) ||
5477 IS_CLASSIC_ENEMY(element2)) &&
5478 element1 != EL_DRAGON && element2 != EL_DRAGON &&
5479 element1 != EL_FLAMES && element2 != EL_FLAMES)
5482 ResetGfxAnimation(x, y);
5483 GfxAction[x][y] = ACTION_ATTACKING;
5486 if (IS_PLAYER(x, y))
5487 DrawPlayerField(x, y);
5489 DrawLevelField(x, y);
5491 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
5493 MovDelay[x][y] = 50;
5495 Feld[newx][newy] = EL_FLAMES;
5496 if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
5497 Feld[newx1][newy1] = EL_FLAMES;
5498 if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
5499 Feld[newx2][newy2] = EL_FLAMES;
5505 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
5506 Feld[newx][newy] == EL_DIAMOND)
5508 if (IS_MOVING(newx, newy))
5509 RemoveMovingField(newx, newy);
5512 Feld[newx][newy] = EL_EMPTY;
5513 DrawLevelField(newx, newy);
5516 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
5518 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
5519 IS_FOOD_DARK_YAMYAM(Feld[newx][newy]))
5521 if (AmoebaNr[newx][newy])
5523 AmoebaCnt2[AmoebaNr[newx][newy]]--;
5524 if (Feld[newx][newy] == EL_AMOEBA_FULL ||
5525 Feld[newx][newy] == EL_BD_AMOEBA)
5526 AmoebaCnt[AmoebaNr[newx][newy]]--;
5531 if (IS_MOVING(newx, newy) || IS_BLOCKED(newx, newy))
5533 if (IS_MOVING(newx, newy))
5536 RemoveMovingField(newx, newy);
5540 Feld[newx][newy] = EL_EMPTY;
5541 DrawLevelField(newx, newy);
5544 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
5546 else if ((element == EL_PACMAN || element == EL_MOLE)
5547 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
5549 if (AmoebaNr[newx][newy])
5551 AmoebaCnt2[AmoebaNr[newx][newy]]--;
5552 if (Feld[newx][newy] == EL_AMOEBA_FULL ||
5553 Feld[newx][newy] == EL_BD_AMOEBA)
5554 AmoebaCnt[AmoebaNr[newx][newy]]--;
5557 if (element == EL_MOLE)
5559 Feld[newx][newy] = EL_AMOEBA_SHRINKING;
5560 PlayLevelSound(x, y, SND_MOLE_DIGGING);
5562 ResetGfxAnimation(x, y);
5563 GfxAction[x][y] = ACTION_DIGGING;
5564 DrawLevelField(x, y);
5566 MovDelay[newx][newy] = 0; /* start amoeba shrinking delay */
5568 return; /* wait for shrinking amoeba */
5570 else /* element == EL_PACMAN */
5572 Feld[newx][newy] = EL_EMPTY;
5573 DrawLevelField(newx, newy);
5574 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
5577 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
5578 (Feld[newx][newy] == EL_AMOEBA_SHRINKING ||
5579 (Feld[newx][newy] == EL_EMPTY && Stop[newx][newy])))
5581 /* wait for shrinking amoeba to completely disappear */
5584 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
5586 /* object was running against a wall */
5591 if (GFX_ELEMENT(element) != EL_SAND) /* !!! FIX THIS (crumble) !!! */
5592 DrawLevelElementAnimation(x, y, element);
5594 if (element == EL_BUG ||
5595 element == EL_SPACESHIP ||
5596 element == EL_SP_SNIKSNAK)
5597 DrawLevelField(x, y);
5598 else if (element == EL_MOLE)
5599 DrawLevelField(x, y);
5600 else if (element == EL_BD_BUTTERFLY ||
5601 element == EL_BD_FIREFLY)
5602 DrawLevelElementAnimationIfNeeded(x, y, element);
5603 else if (element == EL_SATELLITE)
5604 DrawLevelElementAnimationIfNeeded(x, y, element);
5605 else if (element == EL_SP_ELECTRON)
5606 DrawLevelElementAnimationIfNeeded(x, y, element);
5609 if (DONT_TOUCH(element))
5610 TestIfBadThingTouchesHero(x, y);
5613 PlayLevelSoundAction(x, y, ACTION_WAITING);
5619 InitMovingField(x, y, MovDir[x][y]);
5621 PlayLevelSoundAction(x, y, ACTION_MOVING);
5625 ContinueMoving(x, y);
5628 void ContinueMoving(int x, int y)
5630 int element = Feld[x][y];
5631 struct ElementInfo *ei = &element_info[element];
5632 int direction = MovDir[x][y];
5633 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5634 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5635 int newx = x + dx, newy = y + dy;
5637 int nextx = newx + dx, nexty = newy + dy;
5640 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
5641 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
5643 boolean pushed_by_player = Pushed[x][y];
5646 MovPos[x][y] += getElementMoveStepsize(x, y);
5649 if (pushed_by_player && IS_PLAYER(x, y))
5651 /* special case: moving object pushed by player */
5652 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
5655 if (pushed_by_player) /* special case: moving object pushed by player */
5656 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
5659 if (ABS(MovPos[x][y]) < TILEX)
5661 DrawLevelField(x, y);
5663 return; /* element is still moving */
5666 /* element reached destination field */
5668 Feld[x][y] = EL_EMPTY;
5669 Feld[newx][newy] = element;
5670 MovPos[x][y] = 0; /* force "not moving" for "crumbled sand" */
5672 if (element == EL_MOLE)
5674 Feld[x][y] = EL_SAND;
5676 DrawLevelFieldCrumbledSandNeighbours(x, y);
5678 else if (element == EL_QUICKSAND_FILLING)
5680 element = Feld[newx][newy] = get_next_element(element);
5681 Store[newx][newy] = Store[x][y];
5683 else if (element == EL_QUICKSAND_EMPTYING)
5685 Feld[x][y] = get_next_element(element);
5686 element = Feld[newx][newy] = Store[x][y];
5688 else if (element == EL_MAGIC_WALL_FILLING)
5690 element = Feld[newx][newy] = get_next_element(element);
5691 if (!game.magic_wall_active)
5692 element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
5693 Store[newx][newy] = Store[x][y];
5695 else if (element == EL_MAGIC_WALL_EMPTYING)
5697 Feld[x][y] = get_next_element(element);
5698 if (!game.magic_wall_active)
5699 Feld[x][y] = EL_MAGIC_WALL_DEAD;
5700 element = Feld[newx][newy] = Store[x][y];
5702 else if (element == EL_BD_MAGIC_WALL_FILLING)
5704 element = Feld[newx][newy] = get_next_element(element);
5705 if (!game.magic_wall_active)
5706 element = Feld[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
5707 Store[newx][newy] = Store[x][y];
5709 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
5711 Feld[x][y] = get_next_element(element);
5712 if (!game.magic_wall_active)
5713 Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
5714 element = Feld[newx][newy] = Store[x][y];
5716 else if (element == EL_AMOEBA_DROPPING)
5718 Feld[x][y] = get_next_element(element);
5719 element = Feld[newx][newy] = Store[x][y];
5721 else if (element == EL_SOKOBAN_OBJECT)
5724 Feld[x][y] = Back[x][y];
5726 if (Back[newx][newy])
5727 Feld[newx][newy] = EL_SOKOBAN_FIELD_FULL;
5729 Back[x][y] = Back[newx][newy] = 0;
5731 else if (Store[x][y] == EL_ACID)
5733 element = Feld[newx][newy] = EL_ACID;
5737 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
5738 MovDelay[newx][newy] = 0;
5740 /* copy element change control values to new field */
5741 ChangeDelay[newx][newy] = ChangeDelay[x][y];
5742 ChangePage[newx][newy] = ChangePage[x][y];
5743 Changed[newx][newy] = Changed[x][y];
5744 ChangeEvent[newx][newy] = ChangeEvent[x][y];
5746 ChangeDelay[x][y] = 0;
5747 ChangePage[x][y] = -1;
5748 Changed[x][y] = CE_BITMASK_DEFAULT;
5749 ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
5751 /* copy animation control values to new field */
5752 GfxFrame[newx][newy] = GfxFrame[x][y];
5753 GfxRandom[newx][newy] = GfxRandom[x][y]; /* keep same random value */
5754 GfxAction[newx][newy] = GfxAction[x][y]; /* keep action one frame */
5755 GfxDir[newx][newy] = GfxDir[x][y]; /* keep element direction */
5757 Pushed[x][y] = Pushed[newx][newy] = FALSE;
5759 ResetGfxAnimation(x, y); /* reset animation values for old field */
5762 /* some elements can leave other elements behind after moving */
5763 if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) &&
5764 ei->move_leave_element != EL_EMPTY &&
5765 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED ||
5766 ei->can_leave_element_last))
5768 Feld[x][y] = ei->move_leave_element;
5769 InitField(x, y, FALSE);
5771 if (GFX_CRUMBLED(Feld[x][y]))
5772 DrawLevelFieldCrumbledSandNeighbours(x, y);
5775 ei->can_leave_element_last = ei->can_leave_element;
5776 ei->can_leave_element = FALSE;
5780 /* 2.1.1 (does not work correctly for spring) */
5781 if (!CAN_MOVE(element))
5782 MovDir[newx][newy] = 0;
5786 /* (does not work for falling objects that slide horizontally) */
5787 if (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN)
5788 MovDir[newx][newy] = 0;
5791 if (!CAN_MOVE(element) ||
5792 (element == EL_SPRING && MovDir[newx][newy] == MV_DOWN))
5793 MovDir[newx][newy] = 0;
5796 if (!CAN_MOVE(element) ||
5797 (CAN_FALL(element) && direction == MV_DOWN))
5798 GfxDir[x][y] = MovDir[newx][newy] = 0;
5803 DrawLevelField(x, y);
5804 DrawLevelField(newx, newy);
5806 Stop[newx][newy] = TRUE; /* ignore this element until the next frame */
5808 /* prevent pushed element from moving on in pushed direction */
5809 if (pushed_by_player && CAN_MOVE(element) &&
5810 element_info[element].move_pattern & MV_ANY_DIRECTION &&
5811 !(element_info[element].move_pattern & direction))
5812 TurnRound(newx, newy);
5815 /* prevent elements on conveyor belt from moving on in last direction */
5816 if (pushed_by_conveyor && CAN_FALL(element) &&
5817 direction & MV_HORIZONTAL)
5818 MovDir[newx][newy] = 0;
5821 if (!pushed_by_player)
5823 WasJustMoving[newx][newy] = 3;
5825 if (CAN_FALL(element) && direction == MV_DOWN)
5826 WasJustFalling[newx][newy] = 3;
5829 if (DONT_TOUCH(element)) /* object may be nasty to player or others */
5831 TestIfBadThingTouchesHero(newx, newy);
5832 TestIfBadThingTouchesFriend(newx, newy);
5834 if (!IS_CUSTOM_ELEMENT(element))
5835 TestIfBadThingTouchesOtherBadThing(newx, newy);
5837 else if (element == EL_PENGUIN)
5838 TestIfFriendTouchesBadThing(newx, newy);
5840 if (CAN_FALL(element) && direction == MV_DOWN &&
5841 (newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
5845 TestIfElementTouchesCustomElement(x, y); /* empty or new element */
5849 if (ChangePage[newx][newy] != -1) /* delayed change */
5850 ChangeElement(newx, newy, ChangePage[newx][newy]);
5855 TestIfElementHitsCustomElement(newx, newy, direction);
5859 if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
5861 int hitting_element = Feld[newx][newy];
5863 /* !!! fix side (direction) orientation here and elsewhere !!! */
5864 CheckElementChangeSide(newx, newy, hitting_element, CE_HITTING_SOMETHING,
5868 if (IN_LEV_FIELD(nextx, nexty))
5870 int opposite_direction = MV_DIR_OPPOSITE(direction);
5871 int hitting_side = direction;
5872 int touched_side = opposite_direction;
5873 int touched_element = MovingOrBlocked2Element(nextx, nexty);
5874 boolean object_hit = (!IS_MOVING(nextx, nexty) ||
5875 MovDir[nextx][nexty] != direction ||
5876 ABS(MovPos[nextx][nexty]) <= TILEY / 2);
5882 CheckElementChangeSide(nextx, nexty, touched_element,
5883 CE_HIT_BY_SOMETHING, opposite_direction);
5885 if (IS_CUSTOM_ELEMENT(hitting_element) &&
5886 HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING))
5888 for (i = 0; i < element_info[hitting_element].num_change_pages; i++)
5890 struct ElementChangeInfo *change =
5891 &element_info[hitting_element].change_page[i];
5893 if (change->can_change &&
5894 change->events & CH_EVENT_BIT(CE_OTHER_IS_HITTING) &&
5895 change->trigger_side & touched_side &&
5896 change->trigger_element == touched_element)
5898 CheckElementChangePage(newx, newy, hitting_element,
5899 touched_element, CE_OTHER_IS_HITTING, i);
5905 if (IS_CUSTOM_ELEMENT(touched_element) &&
5906 HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_HIT))
5908 for (i = 0; i < element_info[touched_element].num_change_pages; i++)
5910 struct ElementChangeInfo *change =
5911 &element_info[touched_element].change_page[i];
5913 if (change->can_change &&
5914 change->events & CH_EVENT_BIT(CE_OTHER_GETS_HIT) &&
5915 change->trigger_side & hitting_side &&
5916 change->trigger_element == hitting_element)
5918 CheckElementChangePage(nextx, nexty, touched_element,
5919 hitting_element, CE_OTHER_GETS_HIT, i);
5930 TestIfPlayerTouchesCustomElement(newx, newy);
5931 TestIfElementTouchesCustomElement(newx, newy);
5934 int AmoebeNachbarNr(int ax, int ay)
5937 int element = Feld[ax][ay];
5939 static int xy[4][2] =
5947 for (i = 0; i < NUM_DIRECTIONS; i++)
5949 int x = ax + xy[i][0];
5950 int y = ay + xy[i][1];
5952 if (!IN_LEV_FIELD(x, y))
5955 if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
5956 group_nr = AmoebaNr[x][y];
5962 void AmoebenVereinigen(int ax, int ay)
5964 int i, x, y, xx, yy;
5965 int new_group_nr = AmoebaNr[ax][ay];
5966 static int xy[4][2] =
5974 if (new_group_nr == 0)
5977 for (i = 0; i < NUM_DIRECTIONS; i++)
5982 if (!IN_LEV_FIELD(x, y))
5985 if ((Feld[x][y] == EL_AMOEBA_FULL ||
5986 Feld[x][y] == EL_BD_AMOEBA ||
5987 Feld[x][y] == EL_AMOEBA_DEAD) &&
5988 AmoebaNr[x][y] != new_group_nr)
5990 int old_group_nr = AmoebaNr[x][y];
5992 if (old_group_nr == 0)
5995 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
5996 AmoebaCnt[old_group_nr] = 0;
5997 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
5998 AmoebaCnt2[old_group_nr] = 0;
6000 for (yy = 0; yy < lev_fieldy; yy++)
6002 for (xx = 0; xx < lev_fieldx; xx++)
6004 if (AmoebaNr[xx][yy] == old_group_nr)
6005 AmoebaNr[xx][yy] = new_group_nr;
6012 void AmoebeUmwandeln(int ax, int ay)
6016 if (Feld[ax][ay] == EL_AMOEBA_DEAD)
6018 int group_nr = AmoebaNr[ax][ay];
6023 printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
6024 printf("AmoebeUmwandeln(): This should never happen!\n");
6029 for (y = 0; y < lev_fieldy; y++)
6031 for (x = 0; x < lev_fieldx; x++)
6033 if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
6036 Feld[x][y] = EL_AMOEBA_TO_DIAMOND;
6040 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
6041 SND_AMOEBA_TURNING_TO_GEM :
6042 SND_AMOEBA_TURNING_TO_ROCK));
6047 static int xy[4][2] =
6055 for (i = 0; i < NUM_DIRECTIONS; i++)
6060 if (!IN_LEV_FIELD(x, y))
6063 if (Feld[x][y] == EL_AMOEBA_TO_DIAMOND)
6065 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
6066 SND_AMOEBA_TURNING_TO_GEM :
6067 SND_AMOEBA_TURNING_TO_ROCK));
6074 void AmoebeUmwandelnBD(int ax, int ay, int new_element)
6077 int group_nr = AmoebaNr[ax][ay];
6078 boolean done = FALSE;
6083 printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
6084 printf("AmoebeUmwandelnBD(): This should never happen!\n");
6089 for (y = 0; y < lev_fieldy; y++)
6091 for (x = 0; x < lev_fieldx; x++)
6093 if (AmoebaNr[x][y] == group_nr &&
6094 (Feld[x][y] == EL_AMOEBA_DEAD ||
6095 Feld[x][y] == EL_BD_AMOEBA ||
6096 Feld[x][y] == EL_AMOEBA_GROWING))
6099 Feld[x][y] = new_element;
6100 InitField(x, y, FALSE);
6101 DrawLevelField(x, y);
6108 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
6109 SND_BD_AMOEBA_TURNING_TO_ROCK :
6110 SND_BD_AMOEBA_TURNING_TO_GEM));
6113 void AmoebeWaechst(int x, int y)
6115 static unsigned long sound_delay = 0;
6116 static unsigned long sound_delay_value = 0;
6118 if (!MovDelay[x][y]) /* start new growing cycle */
6122 if (DelayReached(&sound_delay, sound_delay_value))
6125 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
6127 if (Store[x][y] == EL_BD_AMOEBA)
6128 PlayLevelSound(x, y, SND_BD_AMOEBA_GROWING);
6130 PlayLevelSound(x, y, SND_AMOEBA_GROWING);
6132 sound_delay_value = 30;
6136 if (MovDelay[x][y]) /* wait some time before growing bigger */
6139 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6141 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
6142 6 - MovDelay[x][y]);
6144 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
6147 if (!MovDelay[x][y])
6149 Feld[x][y] = Store[x][y];
6151 DrawLevelField(x, y);
6156 void AmoebaDisappearing(int x, int y)
6158 static unsigned long sound_delay = 0;
6159 static unsigned long sound_delay_value = 0;
6161 if (!MovDelay[x][y]) /* start new shrinking cycle */
6165 if (DelayReached(&sound_delay, sound_delay_value))
6166 sound_delay_value = 30;
6169 if (MovDelay[x][y]) /* wait some time before shrinking */
6172 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6174 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
6175 6 - MovDelay[x][y]);
6177 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
6180 if (!MovDelay[x][y])
6182 Feld[x][y] = EL_EMPTY;
6183 DrawLevelField(x, y);
6185 /* don't let mole enter this field in this cycle;
6186 (give priority to objects falling to this field from above) */
6192 void AmoebeAbleger(int ax, int ay)
6195 int element = Feld[ax][ay];
6196 int graphic = el2img(element);
6197 int newax = ax, neway = ay;
6198 static int xy[4][2] =
6206 if (!level.amoeba_speed)
6208 Feld[ax][ay] = EL_AMOEBA_DEAD;
6209 DrawLevelField(ax, ay);
6213 if (IS_ANIMATED(graphic))
6214 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6216 if (!MovDelay[ax][ay]) /* start making new amoeba field */
6217 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
6219 if (MovDelay[ax][ay]) /* wait some time before making new amoeba */
6222 if (MovDelay[ax][ay])
6226 if (element == EL_AMOEBA_WET) /* object is an acid / amoeba drop */
6229 int x = ax + xy[start][0];
6230 int y = ay + xy[start][1];
6232 if (!IN_LEV_FIELD(x, y))
6235 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6236 if (IS_FREE(x, y) ||
6237 Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
6243 if (newax == ax && neway == ay)
6246 else /* normal or "filled" (BD style) amoeba */
6249 boolean waiting_for_player = FALSE;
6251 for (i = 0; i < NUM_DIRECTIONS; i++)
6253 int j = (start + i) % 4;
6254 int x = ax + xy[j][0];
6255 int y = ay + xy[j][1];
6257 if (!IN_LEV_FIELD(x, y))
6260 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6261 if (IS_FREE(x, y) ||
6262 Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
6268 else if (IS_PLAYER(x, y))
6269 waiting_for_player = TRUE;
6272 if (newax == ax && neway == ay) /* amoeba cannot grow */
6274 if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
6276 Feld[ax][ay] = EL_AMOEBA_DEAD;
6277 DrawLevelField(ax, ay);
6278 AmoebaCnt[AmoebaNr[ax][ay]]--;
6280 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) /* amoeba is completely dead */
6282 if (element == EL_AMOEBA_FULL)
6283 AmoebeUmwandeln(ax, ay);
6284 else if (element == EL_BD_AMOEBA)
6285 AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
6290 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
6292 /* amoeba gets larger by growing in some direction */
6294 int new_group_nr = AmoebaNr[ax][ay];
6297 if (new_group_nr == 0)
6299 printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
6300 printf("AmoebeAbleger(): This should never happen!\n");
6305 AmoebaNr[newax][neway] = new_group_nr;
6306 AmoebaCnt[new_group_nr]++;
6307 AmoebaCnt2[new_group_nr]++;
6309 /* if amoeba touches other amoeba(s) after growing, unify them */
6310 AmoebenVereinigen(newax, neway);
6312 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
6314 AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
6320 if (element != EL_AMOEBA_WET || neway < ay || !IS_FREE(newax, neway) ||
6321 (neway == lev_fieldy - 1 && newax != ax))
6323 Feld[newax][neway] = EL_AMOEBA_GROWING; /* creation of new amoeba */
6324 Store[newax][neway] = element;
6326 else if (neway == ay)
6328 Feld[newax][neway] = EL_AMOEBA_DROP; /* drop left/right of amoeba */
6330 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
6332 PlayLevelSound(newax, neway, SND_AMOEBA_GROWING);
6337 InitMovingField(ax, ay, MV_DOWN); /* drop dripping from amoeba */
6338 Feld[ax][ay] = EL_AMOEBA_DROPPING;
6339 Store[ax][ay] = EL_AMOEBA_DROP;
6340 ContinueMoving(ax, ay);
6344 DrawLevelField(newax, neway);
6347 void Life(int ax, int ay)
6350 static int life[4] = { 2, 3, 3, 3 }; /* parameters for "game of life" */
6352 int element = Feld[ax][ay];
6353 int graphic = el2img(element);
6354 boolean changed = FALSE;
6356 if (IS_ANIMATED(graphic))
6357 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6362 if (!MovDelay[ax][ay]) /* start new "game of life" cycle */
6363 MovDelay[ax][ay] = life_time;
6365 if (MovDelay[ax][ay]) /* wait some time before next cycle */
6368 if (MovDelay[ax][ay])
6372 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
6374 int xx = ax+x1, yy = ay+y1;
6377 if (!IN_LEV_FIELD(xx, yy))
6380 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
6382 int x = xx+x2, y = yy+y2;
6384 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
6387 if (((Feld[x][y] == element ||
6388 (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y))) &&
6390 (IS_FREE(x, y) && Stop[x][y]))
6394 if (xx == ax && yy == ay) /* field in the middle */
6396 if (nachbarn < life[0] || nachbarn > life[1])
6398 Feld[xx][yy] = EL_EMPTY;
6400 DrawLevelField(xx, yy);
6401 Stop[xx][yy] = TRUE;
6405 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6406 else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_SAND)
6407 { /* free border field */
6408 if (nachbarn >= life[2] && nachbarn <= life[3])
6410 Feld[xx][yy] = element;
6411 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
6413 DrawLevelField(xx, yy);
6414 Stop[xx][yy] = TRUE;
6421 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
6422 SND_GAME_OF_LIFE_GROWING);
6425 static void InitRobotWheel(int x, int y)
6427 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
6430 static void RunRobotWheel(int x, int y)
6432 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
6435 static void StopRobotWheel(int x, int y)
6437 if (ZX == x && ZY == y)
6441 static void InitTimegateWheel(int x, int y)
6443 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
6446 static void RunTimegateWheel(int x, int y)
6448 PlayLevelSound(x, y, SND_TIMEGATE_SWITCH_ACTIVE);
6451 void CheckExit(int x, int y)
6453 if (local_player->gems_still_needed > 0 ||
6454 local_player->sokobanfields_still_needed > 0 ||
6455 local_player->lights_still_needed > 0)
6457 int element = Feld[x][y];
6458 int graphic = el2img(element);
6460 if (IS_ANIMATED(graphic))
6461 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6466 if (AllPlayersGone) /* do not re-open exit door closed after last player */
6469 Feld[x][y] = EL_EXIT_OPENING;
6471 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
6474 void CheckExitSP(int x, int y)
6476 if (local_player->gems_still_needed > 0)
6478 int element = Feld[x][y];
6479 int graphic = el2img(element);
6481 if (IS_ANIMATED(graphic))
6482 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6487 if (AllPlayersGone) /* do not re-open exit door closed after last player */
6490 Feld[x][y] = EL_SP_EXIT_OPENING;
6492 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
6495 static void CloseAllOpenTimegates()
6499 for (y = 0; y < lev_fieldy; y++)
6501 for (x = 0; x < lev_fieldx; x++)
6503 int element = Feld[x][y];
6505 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
6507 Feld[x][y] = EL_TIMEGATE_CLOSING;
6509 PlayLevelSoundAction(x, y, ACTION_CLOSING);
6511 PlayLevelSound(x, y, SND_TIMEGATE_CLOSING);
6518 void EdelsteinFunkeln(int x, int y)
6520 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
6523 if (Feld[x][y] == EL_BD_DIAMOND)
6526 if (MovDelay[x][y] == 0) /* next animation frame */
6527 MovDelay[x][y] = 11 * !SimpleRND(500);
6529 if (MovDelay[x][y] != 0) /* wait some time before next frame */
6533 if (setup.direct_draw && MovDelay[x][y])
6534 SetDrawtoField(DRAW_BUFFERED);
6536 DrawLevelElementAnimation(x, y, Feld[x][y]);
6538 if (MovDelay[x][y] != 0)
6540 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
6541 10 - MovDelay[x][y]);
6543 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
6545 if (setup.direct_draw)
6549 dest_x = FX + SCREENX(x) * TILEX;
6550 dest_y = FY + SCREENY(y) * TILEY;
6552 BlitBitmap(drawto_field, window,
6553 dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
6554 SetDrawtoField(DRAW_DIRECT);
6560 void MauerWaechst(int x, int y)
6564 if (!MovDelay[x][y]) /* next animation frame */
6565 MovDelay[x][y] = 3 * delay;
6567 if (MovDelay[x][y]) /* wait some time before next frame */
6571 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6573 int graphic = el_dir2img(Feld[x][y], GfxDir[x][y]);
6574 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
6576 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6579 if (!MovDelay[x][y])
6581 if (MovDir[x][y] == MV_LEFT)
6583 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
6584 DrawLevelField(x - 1, y);
6586 else if (MovDir[x][y] == MV_RIGHT)
6588 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y]))
6589 DrawLevelField(x + 1, y);
6591 else if (MovDir[x][y] == MV_UP)
6593 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
6594 DrawLevelField(x, y - 1);
6598 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
6599 DrawLevelField(x, y + 1);
6602 Feld[x][y] = Store[x][y];
6604 GfxDir[x][y] = MovDir[x][y] = MV_NO_MOVING;
6605 DrawLevelField(x, y);
6610 void MauerAbleger(int ax, int ay)
6612 int element = Feld[ax][ay];
6613 int graphic = el2img(element);
6614 boolean oben_frei = FALSE, unten_frei = FALSE;
6615 boolean links_frei = FALSE, rechts_frei = FALSE;
6616 boolean oben_massiv = FALSE, unten_massiv = FALSE;
6617 boolean links_massiv = FALSE, rechts_massiv = FALSE;
6618 boolean new_wall = FALSE;
6620 if (IS_ANIMATED(graphic))
6621 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6623 if (!MovDelay[ax][ay]) /* start building new wall */
6624 MovDelay[ax][ay] = 6;
6626 if (MovDelay[ax][ay]) /* wait some time before building new wall */
6629 if (MovDelay[ax][ay])
6633 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
6635 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
6637 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
6639 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
6642 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
6643 element == EL_EXPANDABLE_WALL_ANY)
6647 Feld[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
6648 Store[ax][ay-1] = element;
6649 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
6650 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
6651 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
6652 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
6657 Feld[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
6658 Store[ax][ay+1] = element;
6659 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
6660 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
6661 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
6662 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
6667 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6668 element == EL_EXPANDABLE_WALL_ANY ||
6669 element == EL_EXPANDABLE_WALL)
6673 Feld[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
6674 Store[ax-1][ay] = element;
6675 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
6676 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
6677 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
6678 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
6684 Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
6685 Store[ax+1][ay] = element;
6686 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
6687 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
6688 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
6689 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
6694 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
6695 DrawLevelField(ax, ay);
6697 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
6699 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
6700 unten_massiv = TRUE;
6701 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
6702 links_massiv = TRUE;
6703 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
6704 rechts_massiv = TRUE;
6706 if (((oben_massiv && unten_massiv) ||
6707 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6708 element == EL_EXPANDABLE_WALL) &&
6709 ((links_massiv && rechts_massiv) ||
6710 element == EL_EXPANDABLE_WALL_VERTICAL))
6711 Feld[ax][ay] = EL_WALL;
6715 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
6717 PlayLevelSound(ax, ay, SND_EXPANDABLE_WALL_GROWING);
6721 void CheckForDragon(int x, int y)
6724 boolean dragon_found = FALSE;
6725 static int xy[4][2] =
6733 for (i = 0; i < NUM_DIRECTIONS; i++)
6735 for (j = 0; j < 4; j++)
6737 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
6739 if (IN_LEV_FIELD(xx, yy) &&
6740 (Feld[xx][yy] == EL_FLAMES || Feld[xx][yy] == EL_DRAGON))
6742 if (Feld[xx][yy] == EL_DRAGON)
6743 dragon_found = TRUE;
6752 for (i = 0; i < NUM_DIRECTIONS; i++)
6754 for (j = 0; j < 3; j++)
6756 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
6758 if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES)
6760 Feld[xx][yy] = EL_EMPTY;
6761 DrawLevelField(xx, yy);
6770 static void InitBuggyBase(int x, int y)
6772 int element = Feld[x][y];
6773 int activating_delay = FRAMES_PER_SECOND / 4;
6776 (element == EL_SP_BUGGY_BASE ?
6777 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
6778 element == EL_SP_BUGGY_BASE_ACTIVATING ?
6780 element == EL_SP_BUGGY_BASE_ACTIVE ?
6781 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
6784 static void WarnBuggyBase(int x, int y)
6787 static int xy[4][2] =
6795 for (i = 0; i < NUM_DIRECTIONS; i++)
6797 int xx = x + xy[i][0], yy = y + xy[i][1];
6799 if (IS_PLAYER(xx, yy))
6801 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
6808 static void InitTrap(int x, int y)
6810 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
6813 static void ActivateTrap(int x, int y)
6815 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
6818 static void ChangeActiveTrap(int x, int y)
6820 int graphic = IMG_TRAP_ACTIVE;
6822 /* if new animation frame was drawn, correct crumbled sand border */
6823 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
6824 DrawLevelFieldCrumbledSand(x, y);
6827 static void ChangeElementNowExt(int x, int y, int target_element)
6829 int previous_move_direction = MovDir[x][y];
6831 /* check if element under player changes from accessible to unaccessible
6832 (needed for special case of dropping element which then changes) */
6833 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) &&
6834 IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
6841 Feld[x][y] = target_element;
6843 Changed[x][y] |= ChangeEvent[x][y]; /* ignore same changes in this frame */
6845 ResetGfxAnimation(x, y);
6846 ResetRandomAnimationValue(x, y);
6848 if (element_info[Feld[x][y]].move_direction_initial == MV_START_PREVIOUS)
6849 MovDir[x][y] = previous_move_direction;
6852 InitField_WithBug1(x, y, FALSE);
6854 InitField(x, y, FALSE);
6855 if (CAN_MOVE(Feld[x][y]))
6859 DrawLevelField(x, y);
6861 if (GFX_CRUMBLED(Feld[x][y]))
6862 DrawLevelFieldCrumbledSandNeighbours(x, y);
6864 TestIfBadThingTouchesHero(x, y);
6865 TestIfPlayerTouchesCustomElement(x, y);
6866 TestIfElementTouchesCustomElement(x, y);
6868 if (ELEM_IS_PLAYER(target_element))
6869 RelocatePlayer(x, y, target_element);
6872 static boolean ChangeElementNow(int x, int y, int element, int page)
6874 struct ElementChangeInfo *change = &element_info[element].change_page[page];
6877 /* always use default change event to prevent running into a loop */
6878 if (ChangeEvent[x][y] == CE_BITMASK_DEFAULT)
6879 ChangeEvent[x][y] = CH_EVENT_BIT(CE_DELAY);
6881 if (ChangeEvent[x][y] == CH_EVENT_BIT(CE_DELAY))
6883 /* reset actual trigger element and player */
6884 change->actual_trigger_element = EL_EMPTY;
6885 change->actual_trigger_player = EL_PLAYER_1;
6888 /* do not change already changed elements with same change event */
6890 if (Changed[x][y] & ChangeEvent[x][y])
6897 Changed[x][y] |= ChangeEvent[x][y]; /* ignore same changes in this frame */
6899 CheckTriggeredElementChangePage(x,y, Feld[x][y], CE_OTHER_IS_CHANGING, page);
6901 if (change->explode)
6908 if (change->use_target_content)
6910 boolean complete_replace = TRUE;
6911 boolean can_replace[3][3];
6914 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
6917 boolean is_diggable;
6918 boolean is_destructible;
6919 int ex = x + xx - 1;
6920 int ey = y + yy - 1;
6921 int content_element = change->target_content[xx][yy];
6924 can_replace[xx][yy] = TRUE;
6926 if (ex == x && ey == y) /* do not check changing element itself */
6929 if (content_element == EL_EMPTY_SPACE)
6931 can_replace[xx][yy] = FALSE; /* do not replace border with space */
6936 if (!IN_LEV_FIELD(ex, ey))
6938 can_replace[xx][yy] = FALSE;
6939 complete_replace = FALSE;
6946 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
6947 e = MovingOrBlocked2Element(ex, ey);
6950 is_empty = (IS_FREE(ex, ey) || (IS_PLAYER(ex, ey) &&
6951 IS_WALKABLE(content_element)));
6952 is_diggable = (is_empty || IS_DIGGABLE(e));
6953 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
6955 can_replace[xx][yy] =
6956 ((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
6957 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
6958 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible));
6960 if (!can_replace[xx][yy])
6961 complete_replace = FALSE;
6963 empty_for_element = (IS_FREE(ex, ey) || (IS_FREE_OR_PLAYER(ex, ey) &&
6964 IS_WALKABLE(content_element)));
6966 half_destructible = (empty_for_element || IS_DIGGABLE(e));
6968 half_destructible = (IS_FREE(ex, ey) || IS_DIGGABLE(e));
6971 if ((change->replace_when <= CP_WHEN_EMPTY && !empty_for_element) ||
6972 (change->replace_when <= CP_WHEN_DIGGABLE && !half_destructible) ||
6973 (change->replace_when <= CP_WHEN_DESTRUCTIBLE && IS_INDESTRUCTIBLE(e)))
6975 can_replace[xx][yy] = FALSE;
6976 complete_replace = FALSE;
6981 if (!change->only_if_complete || complete_replace)
6983 boolean something_has_changed = FALSE;
6985 if (change->only_if_complete && change->use_random_replace &&
6986 RND(100) < change->random_percentage)
6989 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
6991 int ex = x + xx - 1;
6992 int ey = y + yy - 1;
6993 int content_element;
6995 if (can_replace[xx][yy] && (!change->use_random_replace ||
6996 RND(100) < change->random_percentage))
6998 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
6999 RemoveMovingField(ex, ey);
7001 ChangeEvent[ex][ey] = ChangeEvent[x][y];
7003 content_element = change->target_content[xx][yy];
7004 target_element = GET_TARGET_ELEMENT(content_element, change);
7006 ChangeElementNowExt(ex, ey, target_element);
7008 something_has_changed = TRUE;
7010 /* for symmetry reasons, freeze newly created border elements */
7011 if (ex != x || ey != y)
7012 Stop[ex][ey] = TRUE; /* no more moving in this frame */
7016 if (something_has_changed)
7017 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
7022 target_element = GET_TARGET_ELEMENT(change->target_element, change);
7024 ChangeElementNowExt(x, y, target_element);
7026 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
7032 static void ChangeElement(int x, int y, int page)
7034 int element = MovingOrBlocked2Element(x, y);
7035 struct ElementInfo *ei = &element_info[element];
7036 struct ElementChangeInfo *change = &ei->change_page[page];
7040 if (!CAN_CHANGE(element))
7043 printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
7044 x, y, element, element_info[element].token_name);
7045 printf("ChangeElement(): This should never happen!\n");
7051 if (ChangeDelay[x][y] == 0) /* initialize element change */
7053 ChangeDelay[x][y] = ( change->delay_fixed * change->delay_frames +
7054 RND(change->delay_random * change->delay_frames)) + 1;
7056 ResetGfxAnimation(x, y);
7057 ResetRandomAnimationValue(x, y);
7059 if (change->pre_change_function)
7060 change->pre_change_function(x, y);
7063 ChangeDelay[x][y]--;
7065 if (ChangeDelay[x][y] != 0) /* continue element change */
7067 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7069 if (IS_ANIMATED(graphic))
7070 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7072 if (change->change_function)
7073 change->change_function(x, y);
7075 else /* finish element change */
7077 if (ChangePage[x][y] != -1) /* remember page from delayed change */
7079 page = ChangePage[x][y];
7080 ChangePage[x][y] = -1;
7082 change = &ei->change_page[page];
7086 if (IS_MOVING(x, y) && !change->explode)
7088 if (IS_MOVING(x, y)) /* never change a running system ;-) */
7091 ChangeDelay[x][y] = 1; /* try change after next move step */
7092 ChangePage[x][y] = page; /* remember page to use for change */
7097 if (ChangeElementNow(x, y, element, page))
7099 if (change->post_change_function)
7100 change->post_change_function(x, y);
7105 static boolean CheckTriggeredElementChangeExt(int lx, int ly,
7106 int trigger_element,
7113 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
7115 if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
7118 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7120 int element = EL_CUSTOM_START + i;
7122 boolean change_element = FALSE;
7125 if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7128 for (j = 0; j < element_info[element].num_change_pages; j++)
7130 struct ElementChangeInfo *change = &element_info[element].change_page[j];
7132 if (change->can_change &&
7133 change->events & CH_EVENT_BIT(trigger_event) &&
7134 change->trigger_side & trigger_side &&
7135 change->trigger_player & trigger_player &&
7136 change->trigger_page & trigger_page_bits &&
7137 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
7140 if (!(change->events & CH_EVENT_BIT(trigger_event)))
7141 printf("::: !!! %d triggers %d: using wrong page %d [event %d]\n",
7142 trigger_element-EL_CUSTOM_START+1, i+1, j, trigger_event);
7145 change_element = TRUE;
7148 change->actual_trigger_element = trigger_element;
7149 change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
7155 if (!change_element)
7158 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7161 if (x == lx && y == ly) /* do not change trigger element itself */
7165 if (Feld[x][y] == element)
7167 ChangeDelay[x][y] = 1;
7168 ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
7169 ChangeElement(x, y, page);
7177 static boolean CheckElementChangeExt(int x, int y,
7179 int trigger_element,
7185 if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7188 if (Feld[x][y] == EL_BLOCKED)
7190 Blocked2Moving(x, y, &x, &y);
7191 element = Feld[x][y];
7195 if (trigger_page < 0)
7197 boolean change_element = FALSE;
7200 for (i = 0; i < element_info[element].num_change_pages; i++)
7202 struct ElementChangeInfo *change = &element_info[element].change_page[i];
7204 if (change->can_change &&
7205 change->events & CH_EVENT_BIT(trigger_event) &&
7206 change->trigger_side & trigger_side &&
7207 change->trigger_player & trigger_player)
7209 change_element = TRUE;
7212 change->actual_trigger_element = trigger_element;
7213 change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
7219 if (!change_element)
7224 struct ElementInfo *ei = &element_info[element];
7225 struct ElementChangeInfo *change = &ei->change_page[trigger_page];
7227 change->actual_trigger_element = trigger_element;
7228 change->actual_trigger_player = EL_PLAYER_1; /* unused */
7233 /* !!! this check misses pages with same event, but different side !!! */
7235 if (trigger_page < 0)
7236 trigger_page = element_info[element].event_page_nr[trigger_event];
7238 if (!(element_info[element].change_page[trigger_page].trigger_side & trigger_side))
7242 ChangeDelay[x][y] = 1;
7243 ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
7244 ChangeElement(x, y, trigger_page);
7249 static void PlayPlayerSound(struct PlayerInfo *player)
7251 int jx = player->jx, jy = player->jy;
7252 int element = player->element_nr;
7253 int last_action = player->last_action_waiting;
7254 int action = player->action_waiting;
7256 if (player->is_waiting)
7258 if (action != last_action)
7259 PlayLevelSoundElementAction(jx, jy, element, action);
7261 PlayLevelSoundElementActionIfLoop(jx, jy, element, action);
7265 if (action != last_action)
7266 StopSound(element_info[element].sound[last_action]);
7268 if (last_action == ACTION_SLEEPING)
7269 PlayLevelSoundElementAction(jx, jy, element, ACTION_AWAKENING);
7273 static void PlayAllPlayersSound()
7277 for (i = 0; i < MAX_PLAYERS; i++)
7278 if (stored_player[i].active)
7279 PlayPlayerSound(&stored_player[i]);
7282 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
7284 boolean last_waiting = player->is_waiting;
7285 int move_dir = player->MovDir;
7287 player->last_action_waiting = player->action_waiting;
7291 if (!last_waiting) /* not waiting -> waiting */
7293 player->is_waiting = TRUE;
7295 player->frame_counter_bored =
7297 game.player_boring_delay_fixed +
7298 SimpleRND(game.player_boring_delay_random);
7299 player->frame_counter_sleeping =
7301 game.player_sleeping_delay_fixed +
7302 SimpleRND(game.player_sleeping_delay_random);
7304 InitPlayerGfxAnimation(player, ACTION_WAITING, player->MovDir);
7307 if (game.player_sleeping_delay_fixed +
7308 game.player_sleeping_delay_random > 0 &&
7309 player->anim_delay_counter == 0 &&
7310 player->post_delay_counter == 0 &&
7311 FrameCounter >= player->frame_counter_sleeping)
7312 player->is_sleeping = TRUE;
7313 else if (game.player_boring_delay_fixed +
7314 game.player_boring_delay_random > 0 &&
7315 FrameCounter >= player->frame_counter_bored)
7316 player->is_bored = TRUE;
7318 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
7319 player->is_bored ? ACTION_BORING :
7322 if (player->is_sleeping)
7324 if (player->num_special_action_sleeping > 0)
7326 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7328 int last_special_action = player->special_action_sleeping;
7329 int num_special_action = player->num_special_action_sleeping;
7330 int special_action =
7331 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
7332 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
7333 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
7334 last_special_action + 1 : ACTION_SLEEPING);
7335 int special_graphic =
7336 el_act_dir2img(player->element_nr, special_action, move_dir);
7338 player->anim_delay_counter =
7339 graphic_info[special_graphic].anim_delay_fixed +
7340 SimpleRND(graphic_info[special_graphic].anim_delay_random);
7341 player->post_delay_counter =
7342 graphic_info[special_graphic].post_delay_fixed +
7343 SimpleRND(graphic_info[special_graphic].post_delay_random);
7345 player->special_action_sleeping = special_action;
7348 if (player->anim_delay_counter > 0)
7350 player->action_waiting = player->special_action_sleeping;
7351 player->anim_delay_counter--;
7353 else if (player->post_delay_counter > 0)
7355 player->post_delay_counter--;
7359 else if (player->is_bored)
7361 if (player->num_special_action_bored > 0)
7363 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7365 int special_action =
7366 ACTION_BORING_1 + SimpleRND(player->num_special_action_bored);
7367 int special_graphic =
7368 el_act_dir2img(player->element_nr, special_action, move_dir);
7370 player->anim_delay_counter =
7371 graphic_info[special_graphic].anim_delay_fixed +
7372 SimpleRND(graphic_info[special_graphic].anim_delay_random);
7373 player->post_delay_counter =
7374 graphic_info[special_graphic].post_delay_fixed +
7375 SimpleRND(graphic_info[special_graphic].post_delay_random);
7377 player->special_action_bored = special_action;
7380 if (player->anim_delay_counter > 0)
7382 player->action_waiting = player->special_action_bored;
7383 player->anim_delay_counter--;
7385 else if (player->post_delay_counter > 0)
7387 player->post_delay_counter--;
7392 else if (last_waiting) /* waiting -> not waiting */
7394 player->is_waiting = FALSE;
7395 player->is_bored = FALSE;
7396 player->is_sleeping = FALSE;
7398 player->frame_counter_bored = -1;
7399 player->frame_counter_sleeping = -1;
7401 player->anim_delay_counter = 0;
7402 player->post_delay_counter = 0;
7404 player->action_waiting = ACTION_DEFAULT;
7406 player->special_action_bored = ACTION_DEFAULT;
7407 player->special_action_sleeping = ACTION_DEFAULT;
7412 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
7415 static byte stored_player_action[MAX_PLAYERS];
7416 static int num_stored_actions = 0;
7418 boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
7419 int left = player_action & JOY_LEFT;
7420 int right = player_action & JOY_RIGHT;
7421 int up = player_action & JOY_UP;
7422 int down = player_action & JOY_DOWN;
7423 int button1 = player_action & JOY_BUTTON_1;
7424 int button2 = player_action & JOY_BUTTON_2;
7425 int dx = (left ? -1 : right ? 1 : 0);
7426 int dy = (up ? -1 : down ? 1 : 0);
7429 stored_player_action[player->index_nr] = 0;
7430 num_stored_actions++;
7434 printf("::: player %d [%d]\n", player->index_nr, FrameCounter);
7437 if (!player->active || tape.pausing)
7441 printf("::: [%d %d %d %d] [%d %d]\n",
7442 left, right, up, down, button1, button2);
7448 printf("::: player %d acts [%d]\n", player->index_nr, FrameCounter);
7453 if (player->MovPos == 0)
7454 CheckGravityMovement(player);
7457 snapped = SnapField(player, dx, dy);
7461 dropped = DropElement(player);
7463 moved = MovePlayer(player, dx, dy);
7466 if (tape.single_step && tape.recording && !tape.pausing)
7468 if (button1 || (dropped && !moved))
7470 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
7471 SnapField(player, 0, 0); /* stop snapping */
7475 SetPlayerWaiting(player, FALSE);
7478 return player_action;
7480 stored_player_action[player->index_nr] = player_action;
7486 printf("::: player %d waits [%d]\n", player->index_nr, FrameCounter);
7489 /* no actions for this player (no input at player's configured device) */
7491 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
7492 SnapField(player, 0, 0);
7493 CheckGravityMovementWhenNotMoving(player);
7495 if (player->MovPos == 0)
7496 SetPlayerWaiting(player, TRUE);
7498 if (player->MovPos == 0) /* needed for tape.playing */
7499 player->is_moving = FALSE;
7501 player->is_dropping = 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 void PlayerActions(struct PlayerInfo *player, byte player_action)
7521 static byte stored_player_action[MAX_PLAYERS];
7522 static int num_stored_actions = 0;
7523 boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
7524 int left = player_action & JOY_LEFT;
7525 int right = player_action & JOY_RIGHT;
7526 int up = player_action & JOY_UP;
7527 int down = player_action & JOY_DOWN;
7528 int button1 = player_action & JOY_BUTTON_1;
7529 int button2 = player_action & JOY_BUTTON_2;
7530 int dx = (left ? -1 : right ? 1 : 0);
7531 int dy = (up ? -1 : down ? 1 : 0);
7533 stored_player_action[player->index_nr] = 0;
7534 num_stored_actions++;
7536 printf("::: player %d [%d]\n", player->index_nr, FrameCounter);
7538 if (!player->active || tape.pausing)
7543 printf("::: player %d acts [%d]\n", player->index_nr, FrameCounter);
7546 snapped = SnapField(player, dx, dy);
7550 dropped = DropElement(player);
7552 moved = MovePlayer(player, dx, dy);
7555 if (tape.single_step && tape.recording && !tape.pausing)
7557 if (button1 || (dropped && !moved))
7559 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
7560 SnapField(player, 0, 0); /* stop snapping */
7564 stored_player_action[player->index_nr] = player_action;
7568 printf("::: player %d waits [%d]\n", player->index_nr, FrameCounter);
7570 /* no actions for this player (no input at player's configured device) */
7572 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
7573 SnapField(player, 0, 0);
7574 CheckGravityMovementWhenNotMoving(player);
7576 if (player->MovPos == 0)
7577 InitPlayerGfxAnimation(player, ACTION_DEFAULT, player->MovDir);
7579 if (player->MovPos == 0) /* needed for tape.playing */
7580 player->is_moving = FALSE;
7583 if (tape.recording && num_stored_actions >= MAX_PLAYERS)
7585 printf("::: player %d recorded [%d]\n", player->index_nr, FrameCounter);
7587 TapeRecordAction(stored_player_action);
7588 num_stored_actions = 0;
7595 static unsigned long action_delay = 0;
7596 unsigned long action_delay_value;
7597 int magic_wall_x = 0, magic_wall_y = 0;
7598 int i, x, y, element, graphic;
7599 byte *recorded_player_action;
7600 byte summarized_player_action = 0;
7602 byte tape_action[MAX_PLAYERS];
7605 if (game_status != GAME_MODE_PLAYING)
7608 action_delay_value =
7609 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
7611 if (tape.playing && tape.index_search && !tape.pausing)
7612 action_delay_value = 0;
7614 /* ---------- main game synchronization point ---------- */
7616 WaitUntilDelayReached(&action_delay, action_delay_value);
7618 if (network_playing && !network_player_action_received)
7622 printf("DEBUG: try to get network player actions in time\n");
7626 #if defined(PLATFORM_UNIX)
7627 /* last chance to get network player actions without main loop delay */
7631 if (game_status != GAME_MODE_PLAYING)
7634 if (!network_player_action_received)
7638 printf("DEBUG: failed to get network player actions in time\n");
7649 printf("::: getting new tape action [%d]\n", FrameCounter);
7652 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
7655 if (recorded_player_action == NULL && tape.pausing)
7660 printf("::: %d\n", stored_player[0].action);
7664 if (recorded_player_action != NULL)
7665 for (i = 0; i < MAX_PLAYERS; i++)
7666 stored_player[i].action = recorded_player_action[i];
7669 for (i = 0; i < MAX_PLAYERS; i++)
7671 summarized_player_action |= stored_player[i].action;
7673 if (!network_playing)
7674 stored_player[i].effective_action = stored_player[i].action;
7677 #if defined(PLATFORM_UNIX)
7678 if (network_playing)
7679 SendToServer_MovePlayer(summarized_player_action);
7682 if (!options.network && !setup.team_mode)
7683 local_player->effective_action = summarized_player_action;
7686 if (recorded_player_action != NULL)
7687 for (i = 0; i < MAX_PLAYERS; i++)
7688 stored_player[i].effective_action = recorded_player_action[i];
7692 for (i = 0; i < MAX_PLAYERS; i++)
7694 tape_action[i] = stored_player[i].effective_action;
7696 if (tape.recording && tape_action[i] && !tape.player_participates[i])
7697 tape.player_participates[i] = TRUE; /* player just appeared from CE */
7700 /* only save actions from input devices, but not programmed actions */
7702 TapeRecordAction(tape_action);
7705 for (i = 0; i < MAX_PLAYERS; i++)
7707 int actual_player_action = stored_player[i].effective_action;
7710 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
7711 - rnd_equinox_tetrachloride 048
7712 - rnd_equinox_tetrachloride_ii 096
7713 - rnd_emanuel_schmieg 002
7714 - doctor_sloan_ww 001, 020
7716 if (stored_player[i].MovPos == 0)
7717 CheckGravityMovement(&stored_player[i]);
7721 /* overwrite programmed action with tape action */
7722 if (stored_player[i].programmed_action)
7723 actual_player_action = stored_player[i].programmed_action;
7727 if (stored_player[i].programmed_action)
7728 printf("::: %d\n", stored_player[i].programmed_action);
7731 if (recorded_player_action)
7734 if (stored_player[i].programmed_action &&
7735 stored_player[i].programmed_action != recorded_player_action[i])
7736 printf("::: %d: %d <-> %d\n", i,
7737 stored_player[i].programmed_action, recorded_player_action[i]);
7741 actual_player_action = recorded_player_action[i];
7746 /* overwrite tape action with programmed action */
7747 if (stored_player[i].programmed_action)
7748 actual_player_action = stored_player[i].programmed_action;
7753 printf("::: action: %d: %x [%d]\n",
7754 stored_player[i].MovPos, actual_player_action, FrameCounter);
7758 PlayerActions(&stored_player[i], actual_player_action);
7760 tape_action[i] = PlayerActions(&stored_player[i], actual_player_action);
7762 if (tape.recording && tape_action[i] && !tape.player_participates[i])
7763 tape.player_participates[i] = TRUE; /* player just appeared from CE */
7766 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
7771 TapeRecordAction(tape_action);
7774 network_player_action_received = FALSE;
7776 ScrollScreen(NULL, SCROLL_GO_ON);
7782 for (i = 0; i < MAX_PLAYERS; i++)
7783 stored_player[i].Frame++;
7787 /* for downwards compatibility, the following code emulates a fixed bug that
7788 occured when pushing elements (causing elements that just made their last
7789 pushing step to already (if possible) make their first falling step in the
7790 same game frame, which is bad); this code is also needed to use the famous
7791 "spring push bug" which is used in older levels and might be wanted to be
7792 used also in newer levels, but in this case the buggy pushing code is only
7793 affecting the "spring" element and no other elements */
7796 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
7798 if (game.engine_version < VERSION_IDENT(2,2,0,7))
7801 for (i = 0; i < MAX_PLAYERS; i++)
7803 struct PlayerInfo *player = &stored_player[i];
7808 if (player->active && player->is_pushing && player->is_moving &&
7810 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
7811 Feld[x][y] == EL_SPRING))
7813 if (player->active && player->is_pushing && player->is_moving &&
7817 ContinueMoving(x, y);
7819 /* continue moving after pushing (this is actually a bug) */
7820 if (!IS_MOVING(x, y))
7829 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7831 Changed[x][y] = CE_BITMASK_DEFAULT;
7832 ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
7835 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
7837 printf("GameActions(): x = %d, y = %d: ChangePage != -1\n", x, y);
7838 printf("GameActions(): This should never happen!\n");
7840 ChangePage[x][y] = -1;
7845 if (WasJustMoving[x][y] > 0)
7846 WasJustMoving[x][y]--;
7847 if (WasJustFalling[x][y] > 0)
7848 WasJustFalling[x][y]--;
7853 /* reset finished pushing action (not done in ContinueMoving() to allow
7854 continous pushing animation for elements with zero push delay) */
7855 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
7857 ResetGfxAnimation(x, y);
7858 DrawLevelField(x, y);
7863 if (IS_BLOCKED(x, y))
7867 Blocked2Moving(x, y, &oldx, &oldy);
7868 if (!IS_MOVING(oldx, oldy))
7870 printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
7871 printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
7872 printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
7873 printf("GameActions(): This should never happen!\n");
7879 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7881 element = Feld[x][y];
7883 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7885 graphic = el2img(element);
7891 printf("::: %d,%d: %d [%d]\n", x, y, element, FrameCounter);
7893 element = graphic = 0;
7897 if (graphic_info[graphic].anim_global_sync)
7898 GfxFrame[x][y] = FrameCounter;
7900 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
7901 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
7902 ResetRandomAnimationValue(x, y);
7904 SetRandomAnimationValue(x, y);
7907 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
7910 if (IS_INACTIVE(element))
7912 if (IS_ANIMATED(graphic))
7913 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7919 /* this may take place after moving, so 'element' may have changed */
7921 if (IS_CHANGING(x, y))
7923 if (IS_CHANGING(x, y) &&
7924 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
7928 ChangeElement(x, y, ChangePage[x][y] != -1 ? ChangePage[x][y] :
7929 element_info[element].event_page_nr[CE_DELAY]);
7931 ChangeElement(x, y, element_info[element].event_page_nr[CE_DELAY]);
7934 element = Feld[x][y];
7935 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7939 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
7944 element = Feld[x][y];
7945 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7947 if (element == EL_MOLE)
7948 printf("::: %d, %d, %d [%d]\n",
7949 IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y],
7953 if (element == EL_YAMYAM)
7954 printf("::: %d, %d, %d\n",
7955 IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y]);
7959 if (IS_ANIMATED(graphic) &&
7963 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7966 if (element == EL_BUG)
7967 printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
7971 if (element == EL_MOLE)
7972 printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
7976 if (IS_GEM(element) || element == EL_SP_INFOTRON)
7977 EdelsteinFunkeln(x, y);
7979 else if ((element == EL_ACID ||
7980 element == EL_EXIT_OPEN ||
7981 element == EL_SP_EXIT_OPEN ||
7982 element == EL_SP_TERMINAL ||
7983 element == EL_SP_TERMINAL_ACTIVE ||
7984 element == EL_EXTRA_TIME ||
7985 element == EL_SHIELD_NORMAL ||
7986 element == EL_SHIELD_DEADLY) &&
7987 IS_ANIMATED(graphic))
7988 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7989 else if (IS_MOVING(x, y))
7990 ContinueMoving(x, y);
7991 else if (IS_ACTIVE_BOMB(element))
7992 CheckDynamite(x, y);
7994 else if (element == EL_EXPLOSION && !game.explosions_delayed)
7995 Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
7997 else if (element == EL_AMOEBA_GROWING)
7998 AmoebeWaechst(x, y);
7999 else if (element == EL_AMOEBA_SHRINKING)
8000 AmoebaDisappearing(x, y);
8002 #if !USE_NEW_AMOEBA_CODE
8003 else if (IS_AMOEBALIVE(element))
8004 AmoebeAbleger(x, y);
8007 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
8009 else if (element == EL_EXIT_CLOSED)
8011 else if (element == EL_SP_EXIT_CLOSED)
8013 else if (element == EL_EXPANDABLE_WALL_GROWING)
8015 else if (element == EL_EXPANDABLE_WALL ||
8016 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
8017 element == EL_EXPANDABLE_WALL_VERTICAL ||
8018 element == EL_EXPANDABLE_WALL_ANY)
8020 else if (element == EL_FLAMES)
8021 CheckForDragon(x, y);
8023 else if (IS_AUTO_CHANGING(element))
8024 ChangeElement(x, y);
8026 else if (element == EL_EXPLOSION)
8027 ; /* drawing of correct explosion animation is handled separately */
8028 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
8029 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
8032 /* this may take place after moving, so 'element' may have changed */
8033 if (IS_AUTO_CHANGING(Feld[x][y]))
8034 ChangeElement(x, y);
8037 if (IS_BELT_ACTIVE(element))
8038 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
8040 if (game.magic_wall_active)
8042 int jx = local_player->jx, jy = local_player->jy;
8044 /* play the element sound at the position nearest to the player */
8045 if ((element == EL_MAGIC_WALL_FULL ||
8046 element == EL_MAGIC_WALL_ACTIVE ||
8047 element == EL_MAGIC_WALL_EMPTYING ||
8048 element == EL_BD_MAGIC_WALL_FULL ||
8049 element == EL_BD_MAGIC_WALL_ACTIVE ||
8050 element == EL_BD_MAGIC_WALL_EMPTYING) &&
8051 ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
8059 #if USE_NEW_AMOEBA_CODE
8060 /* new experimental amoeba growth stuff */
8062 if (!(FrameCounter % 8))
8065 static unsigned long random = 1684108901;
8067 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
8070 x = (random >> 10) % lev_fieldx;
8071 y = (random >> 20) % lev_fieldy;
8073 x = RND(lev_fieldx);
8074 y = RND(lev_fieldy);
8076 element = Feld[x][y];
8078 /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
8079 if (!IS_PLAYER(x,y) &&
8080 (element == EL_EMPTY ||
8081 element == EL_SAND ||
8082 element == EL_QUICKSAND_EMPTY ||
8083 element == EL_ACID_SPLASH_LEFT ||
8084 element == EL_ACID_SPLASH_RIGHT))
8086 if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
8087 (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
8088 (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
8089 (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
8090 Feld[x][y] = EL_AMOEBA_DROP;
8093 random = random * 129 + 1;
8099 if (game.explosions_delayed)
8102 game.explosions_delayed = FALSE;
8104 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8106 element = Feld[x][y];
8108 if (ExplodeField[x][y])
8109 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
8110 else if (element == EL_EXPLOSION)
8111 Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
8113 ExplodeField[x][y] = EX_NO_EXPLOSION;
8116 game.explosions_delayed = TRUE;
8119 if (game.magic_wall_active)
8121 if (!(game.magic_wall_time_left % 4))
8123 int element = Feld[magic_wall_x][magic_wall_y];
8125 if (element == EL_BD_MAGIC_WALL_FULL ||
8126 element == EL_BD_MAGIC_WALL_ACTIVE ||
8127 element == EL_BD_MAGIC_WALL_EMPTYING)
8128 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
8130 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
8133 if (game.magic_wall_time_left > 0)
8135 game.magic_wall_time_left--;
8136 if (!game.magic_wall_time_left)
8138 for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8140 element = Feld[x][y];
8142 if (element == EL_MAGIC_WALL_ACTIVE ||
8143 element == EL_MAGIC_WALL_FULL)
8145 Feld[x][y] = EL_MAGIC_WALL_DEAD;
8146 DrawLevelField(x, y);
8148 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
8149 element == EL_BD_MAGIC_WALL_FULL)
8151 Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
8152 DrawLevelField(x, y);
8156 game.magic_wall_active = FALSE;
8161 if (game.light_time_left > 0)
8163 game.light_time_left--;
8165 if (game.light_time_left == 0)
8166 RedrawAllLightSwitchesAndInvisibleElements();
8169 if (game.timegate_time_left > 0)
8171 game.timegate_time_left--;
8173 if (game.timegate_time_left == 0)
8174 CloseAllOpenTimegates();
8177 for (i = 0; i < MAX_PLAYERS; i++)
8179 struct PlayerInfo *player = &stored_player[i];
8181 if (SHIELD_ON(player))
8183 if (player->shield_deadly_time_left)
8184 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
8185 else if (player->shield_normal_time_left)
8186 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
8190 if (TimeFrames >= FRAMES_PER_SECOND)
8195 if (!level.use_step_counter)
8199 for (i = 0; i < MAX_PLAYERS; i++)
8201 struct PlayerInfo *player = &stored_player[i];
8203 if (SHIELD_ON(player))
8205 player->shield_normal_time_left--;
8207 if (player->shield_deadly_time_left > 0)
8208 player->shield_deadly_time_left--;
8216 if (TimeLeft <= 10 && setup.time_limit)
8217 PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
8219 DrawGameValue_Time(TimeLeft);
8221 if (!TimeLeft && setup.time_limit)
8222 for (i = 0; i < MAX_PLAYERS; i++)
8223 KillHero(&stored_player[i]);
8225 else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
8226 DrawGameValue_Time(TimePlayed);
8229 if (tape.recording || tape.playing)
8230 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
8234 PlayAllPlayersSound();
8236 if (options.debug) /* calculate frames per second */
8238 static unsigned long fps_counter = 0;
8239 static int fps_frames = 0;
8240 unsigned long fps_delay_ms = Counter() - fps_counter;
8244 if (fps_delay_ms >= 500) /* calculate fps every 0.5 seconds */
8246 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
8249 fps_counter = Counter();
8252 redraw_mask |= REDRAW_FPS;
8256 if (stored_player[0].jx != stored_player[0].last_jx ||
8257 stored_player[0].jy != stored_player[0].last_jy)
8258 printf("::: %d, %d, %d, %d, %d\n",
8259 stored_player[0].MovDir,
8260 stored_player[0].MovPos,
8261 stored_player[0].GfxPos,
8262 stored_player[0].Frame,
8263 stored_player[0].StepFrame);
8270 for (i = 0; i < MAX_PLAYERS; i++)
8273 MOVE_DELAY_NORMAL_SPEED / stored_player[i].move_delay_value;
8275 stored_player[i].Frame += move_frames;
8277 if (stored_player[i].MovPos != 0)
8278 stored_player[i].StepFrame += move_frames;
8280 if (stored_player[i].drop_delay > 0)
8281 stored_player[i].drop_delay--;
8286 if (local_player->show_envelope != 0 && local_player->MovPos == 0)
8288 ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
8290 local_player->show_envelope = 0;
8295 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
8297 int min_x = x, min_y = y, max_x = x, max_y = y;
8300 for (i = 0; i < MAX_PLAYERS; i++)
8302 int jx = stored_player[i].jx, jy = stored_player[i].jy;
8304 if (!stored_player[i].active || &stored_player[i] == player)
8307 min_x = MIN(min_x, jx);
8308 min_y = MIN(min_y, jy);
8309 max_x = MAX(max_x, jx);
8310 max_y = MAX(max_y, jy);
8313 return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
8316 static boolean AllPlayersInVisibleScreen()
8320 for (i = 0; i < MAX_PLAYERS; i++)
8322 int jx = stored_player[i].jx, jy = stored_player[i].jy;
8324 if (!stored_player[i].active)
8327 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8334 void ScrollLevel(int dx, int dy)
8336 int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
8339 BlitBitmap(drawto_field, drawto_field,
8340 FX + TILEX * (dx == -1) - softscroll_offset,
8341 FY + TILEY * (dy == -1) - softscroll_offset,
8342 SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
8343 SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
8344 FX + TILEX * (dx == 1) - softscroll_offset,
8345 FY + TILEY * (dy == 1) - softscroll_offset);
8349 x = (dx == 1 ? BX1 : BX2);
8350 for (y = BY1; y <= BY2; y++)
8351 DrawScreenField(x, y);
8356 y = (dy == 1 ? BY1 : BY2);
8357 for (x = BX1; x <= BX2; x++)
8358 DrawScreenField(x, y);
8361 redraw_mask |= REDRAW_FIELD;
8364 static boolean canEnterSupaplexPort(int x, int y, int dx, int dy)
8366 int nextx = x + dx, nexty = y + dy;
8367 int element = Feld[x][y];
8370 element != EL_SP_PORT_LEFT &&
8371 element != EL_SP_GRAVITY_PORT_LEFT &&
8372 element != EL_SP_PORT_HORIZONTAL &&
8373 element != EL_SP_PORT_ANY) ||
8375 element != EL_SP_PORT_RIGHT &&
8376 element != EL_SP_GRAVITY_PORT_RIGHT &&
8377 element != EL_SP_PORT_HORIZONTAL &&
8378 element != EL_SP_PORT_ANY) ||
8380 element != EL_SP_PORT_UP &&
8381 element != EL_SP_GRAVITY_PORT_UP &&
8382 element != EL_SP_PORT_VERTICAL &&
8383 element != EL_SP_PORT_ANY) ||
8385 element != EL_SP_PORT_DOWN &&
8386 element != EL_SP_GRAVITY_PORT_DOWN &&
8387 element != EL_SP_PORT_VERTICAL &&
8388 element != EL_SP_PORT_ANY) ||
8389 !IN_LEV_FIELD(nextx, nexty) ||
8390 !IS_FREE(nextx, nexty))
8396 static void CheckGravityMovement(struct PlayerInfo *player)
8398 if (game.gravity && !player->programmed_action)
8401 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
8402 int move_dir_vertical = player->effective_action & MV_VERTICAL;
8404 int move_dir_horizontal = player->action & MV_HORIZONTAL;
8405 int move_dir_vertical = player->action & MV_VERTICAL;
8408 (player->last_move_dir & MV_HORIZONTAL ?
8409 (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
8410 (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
8411 int jx = player->jx, jy = player->jy;
8412 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
8413 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
8414 int new_jx = jx + dx, new_jy = jy + dy;
8416 boolean player_is_snapping = player->effective_action & JOY_BUTTON_1;
8418 boolean player_is_snapping = player->action & JOY_BUTTON_1;
8421 boolean player_can_fall_down =
8422 (IN_LEV_FIELD(jx, jy + 1) &&
8423 (IS_FREE(jx, jy + 1) ||
8424 (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)));
8426 boolean player_can_fall_down =
8427 (IN_LEV_FIELD(jx, jy + 1) &&
8428 (IS_FREE(jx, jy + 1)));
8430 boolean player_is_moving_to_valid_field =
8433 !player_is_snapping &&
8435 IN_LEV_FIELD(new_jx, new_jy) &&
8436 (Feld[new_jx][new_jy] == EL_SP_BASE ||
8437 Feld[new_jx][new_jy] == EL_SAND ||
8438 (IS_SP_PORT(Feld[new_jx][new_jy]) &&
8439 canEnterSupaplexPort(new_jx, new_jy, dx, dy))));
8440 /* !!! extend EL_SAND to anything diggable !!! */
8442 boolean player_is_standing_on_valid_field =
8443 (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
8444 (IS_WALKABLE(Feld[jx][jy]) &&
8445 !(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
8448 printf("::: checking gravity NOW [%d, %d, %d] [%d] ...\n",
8449 player_can_fall_down,
8450 player_is_standing_on_valid_field,
8451 player_is_moving_to_valid_field,
8452 (player_is_moving_to_valid_field ? Feld[new_jx][new_jy] : -1));
8455 if (player_can_fall_down &&
8456 !player_is_standing_on_valid_field &&
8457 !player_is_moving_to_valid_field)
8460 printf("::: setting programmed_action to MV_DOWN [%d,%d - %d] ...\n",
8461 jx, jy, FrameCounter);
8464 player->programmed_action = MV_DOWN;
8469 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
8472 return CheckGravityMovement(player);
8475 if (game.gravity && !player->programmed_action)
8477 int jx = player->jx, jy = player->jy;
8478 boolean field_under_player_is_free =
8479 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
8480 boolean player_is_standing_on_valid_field =
8481 (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
8482 (IS_WALKABLE(Feld[jx][jy]) &&
8483 !(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
8485 if (field_under_player_is_free && !player_is_standing_on_valid_field)
8486 player->programmed_action = MV_DOWN;
8492 -----------------------------------------------------------------------------
8493 dx, dy: direction (non-diagonal) to try to move the player to
8494 real_dx, real_dy: direction as read from input device (can be diagonal)
8497 boolean MovePlayerOneStep(struct PlayerInfo *player,
8498 int dx, int dy, int real_dx, int real_dy)
8501 static int trigger_sides[4][2] =
8503 /* enter side leave side */
8504 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* moving left */
8505 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* moving right */
8506 { CH_SIDE_BOTTOM, CH_SIDE_TOP }, /* moving up */
8507 { CH_SIDE_TOP, CH_SIDE_BOTTOM } /* moving down */
8509 int move_direction = (dx == -1 ? MV_LEFT :
8510 dx == +1 ? MV_RIGHT :
8512 dy == +1 ? MV_DOWN : MV_NO_MOVING);
8513 int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0];
8514 int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
8516 int jx = player->jx, jy = player->jy;
8517 int new_jx = jx + dx, new_jy = jy + dy;
8521 if (!player->active || (!dx && !dy))
8522 return MF_NO_ACTION;
8524 player->MovDir = (dx < 0 ? MV_LEFT :
8527 dy > 0 ? MV_DOWN : MV_NO_MOVING);
8529 if (!IN_LEV_FIELD(new_jx, new_jy))
8530 return MF_NO_ACTION;
8532 if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
8533 return MF_NO_ACTION;
8536 element = MovingOrBlocked2Element(new_jx, new_jy);
8538 element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
8541 if (DONT_RUN_INTO(element))
8543 if (element == EL_ACID && dx == 0 && dy == 1)
8545 SplashAcid(new_jx, new_jy);
8546 Feld[jx][jy] = EL_PLAYER_1;
8547 InitMovingField(jx, jy, MV_DOWN);
8548 Store[jx][jy] = EL_ACID;
8549 ContinueMoving(jx, jy);
8553 TestIfHeroRunsIntoBadThing(jx, jy, player->MovDir);
8558 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
8559 if (can_move != MF_MOVING)
8562 /* check if DigField() has caused relocation of the player */
8563 if (player->jx != jx || player->jy != jy)
8564 return MF_NO_ACTION;
8566 StorePlayer[jx][jy] = 0;
8567 player->last_jx = jx;
8568 player->last_jy = jy;
8569 player->jx = new_jx;
8570 player->jy = new_jy;
8571 StorePlayer[new_jx][new_jy] = player->element_nr;
8574 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
8576 player->step_counter++;
8578 player->drop_delay = 0;
8580 PlayerVisit[jx][jy] = FrameCounter;
8582 ScrollPlayer(player, SCROLL_INIT);
8585 if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
8587 CheckTriggeredElementChangeSide(jx, jy, Feld[jx][jy], CE_OTHER_GETS_LEFT,
8589 CheckElementChangeSide(jx, jy, Feld[jx][jy], CE_LEFT_BY_PLAYER,leave_side);
8592 if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
8594 CheckTriggeredElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy],
8595 CE_OTHER_GETS_ENTERED, enter_side);
8596 CheckElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy],
8597 CE_ENTERED_BY_PLAYER, enter_side);
8604 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
8606 int jx = player->jx, jy = player->jy;
8607 int old_jx = jx, old_jy = jy;
8608 int moved = MF_NO_ACTION;
8611 if (!player->active)
8616 if (player->MovPos == 0)
8618 player->is_moving = FALSE;
8619 player->is_digging = FALSE;
8620 player->is_collecting = FALSE;
8621 player->is_snapping = FALSE;
8622 player->is_pushing = FALSE;
8628 if (!player->active || (!dx && !dy))
8633 if (!FrameReached(&player->move_delay, player->move_delay_value) &&
8639 if (!FrameReached(&player->move_delay, player->move_delay_value))
8642 if (!FrameReached(&player->move_delay, player->move_delay_value) &&
8643 !(tape.playing && tape.file_version < FILE_VERSION_2_0))
8649 /* remove the last programmed player action */
8650 player->programmed_action = 0;
8654 /* should only happen if pre-1.2 tape recordings are played */
8655 /* this is only for backward compatibility */
8657 int original_move_delay_value = player->move_delay_value;
8660 printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
8664 /* scroll remaining steps with finest movement resolution */
8665 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
8667 while (player->MovPos)
8669 ScrollPlayer(player, SCROLL_GO_ON);
8670 ScrollScreen(NULL, SCROLL_GO_ON);
8676 player->move_delay_value = original_move_delay_value;
8679 if (player->last_move_dir & MV_HORIZONTAL)
8681 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
8682 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
8686 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
8687 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
8693 if (moved & MF_MOVING && !ScreenMovPos &&
8694 (player == local_player || !options.network))
8696 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
8697 int offset = (setup.scroll_delay ? 3 : 0);
8699 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8701 /* actual player has left the screen -- scroll in that direction */
8702 if (jx != old_jx) /* player has moved horizontally */
8703 scroll_x += (jx - old_jx);
8704 else /* player has moved vertically */
8705 scroll_y += (jy - old_jy);
8709 if (jx != old_jx) /* player has moved horizontally */
8711 if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
8712 (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
8713 scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
8715 /* don't scroll over playfield boundaries */
8716 if (scroll_x < SBX_Left || scroll_x > SBX_Right)
8717 scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
8719 /* don't scroll more than one field at a time */
8720 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
8722 /* don't scroll against the player's moving direction */
8723 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
8724 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
8725 scroll_x = old_scroll_x;
8727 else /* player has moved vertically */
8729 if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
8730 (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
8731 scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
8733 /* don't scroll over playfield boundaries */
8734 if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
8735 scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
8737 /* don't scroll more than one field at a time */
8738 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
8740 /* don't scroll against the player's moving direction */
8741 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
8742 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
8743 scroll_y = old_scroll_y;
8747 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
8749 if (!options.network && !AllPlayersInVisibleScreen())
8751 scroll_x = old_scroll_x;
8752 scroll_y = old_scroll_y;
8756 ScrollScreen(player, SCROLL_INIT);
8757 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
8764 InitPlayerGfxAnimation(player, ACTION_DEFAULT);
8766 if (!(moved & MF_MOVING) && !player->is_pushing)
8771 player->StepFrame = 0;
8773 if (moved & MF_MOVING)
8775 if (old_jx != jx && old_jy == jy)
8776 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
8777 else if (old_jx == jx && old_jy != jy)
8778 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
8780 DrawLevelField(jx, jy); /* for "crumbled sand" */
8782 player->last_move_dir = player->MovDir;
8783 player->is_moving = TRUE;
8785 player->is_snapping = FALSE;
8789 player->is_switching = FALSE;
8792 player->is_dropping = FALSE;
8797 static int trigger_sides[4][2] =
8799 /* enter side leave side */
8800 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* moving left */
8801 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* moving right */
8802 { CH_SIDE_BOTTOM, CH_SIDE_TOP }, /* moving up */
8803 { CH_SIDE_TOP, CH_SIDE_BOTTOM } /* moving down */
8805 int move_direction = player->MovDir;
8806 int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0];
8807 int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
8810 if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
8812 CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8814 player->index_bit, leave_side);
8815 CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8817 player->index_bit, leave_side);
8820 if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
8822 CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
8823 CE_OTHER_GETS_ENTERED,
8824 player->index_bit, enter_side);
8825 CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
8826 player->index_bit, enter_side);
8837 CheckGravityMovementWhenNotMoving(player);
8840 player->last_move_dir = MV_NO_MOVING;
8842 player->is_moving = FALSE;
8845 if (game.engine_version < VERSION_IDENT(3,0,7,0))
8847 TestIfHeroTouchesBadThing(jx, jy);
8848 TestIfPlayerTouchesCustomElement(jx, jy);
8851 if (!player->active)
8857 void ScrollPlayer(struct PlayerInfo *player, int mode)
8859 int jx = player->jx, jy = player->jy;
8860 int last_jx = player->last_jx, last_jy = player->last_jy;
8861 int move_stepsize = TILEX / player->move_delay_value;
8863 if (!player->active || !player->MovPos)
8866 if (mode == SCROLL_INIT)
8868 player->actual_frame_counter = FrameCounter;
8869 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8871 if (Feld[last_jx][last_jy] == EL_EMPTY)
8872 Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
8880 else if (!FrameReached(&player->actual_frame_counter, 1))
8883 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
8884 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8886 if (!player->block_last_field &&
8887 Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
8888 Feld[last_jx][last_jy] = EL_EMPTY;
8890 /* before DrawPlayer() to draw correct player graphic for this case */
8891 if (player->MovPos == 0)
8892 CheckGravityMovement(player);
8895 DrawPlayer(player); /* needed here only to cleanup last field */
8898 if (player->MovPos == 0) /* player reached destination field */
8901 if (player->move_delay_reset_counter > 0)
8903 player->move_delay_reset_counter--;
8905 if (player->move_delay_reset_counter == 0)
8907 /* continue with normal speed after quickly moving through gate */
8908 HALVE_PLAYER_SPEED(player);
8910 /* be able to make the next move without delay */
8911 player->move_delay = 0;
8915 if (IS_PASSABLE(Feld[last_jx][last_jy]))
8917 /* continue with normal speed after quickly moving through gate */
8918 HALVE_PLAYER_SPEED(player);
8920 /* be able to make the next move without delay */
8921 player->move_delay = 0;
8925 if (player->block_last_field &&
8926 Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
8927 Feld[last_jx][last_jy] = EL_EMPTY;
8929 player->last_jx = jx;
8930 player->last_jy = jy;
8932 if (Feld[jx][jy] == EL_EXIT_OPEN ||
8933 Feld[jx][jy] == EL_SP_EXIT_OPEN ||
8934 Feld[jx][jy] == EL_SP_EXIT_OPENING) /* <-- special case */
8936 DrawPlayer(player); /* needed here only to cleanup last field */
8939 if (local_player->friends_still_needed == 0 ||
8940 IS_SP_ELEMENT(Feld[jx][jy]))
8941 player->LevelSolved = player->GameOver = TRUE;
8945 /* !!! ENABLE THIS FOR NEW VERSIONS !!! */
8947 static int trigger_sides[4][2] =
8949 /* enter side leave side */
8950 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* moving left */
8951 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* moving right */
8952 { CH_SIDE_BOTTOM, CH_SIDE_TOP }, /* moving up */
8953 { CH_SIDE_TOP, CH_SIDE_BOTTOM } /* moving down */
8955 int move_direction = player->MovDir;
8956 int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0];
8957 int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
8958 int old_jx = last_jx;
8959 int old_jy = last_jy;
8962 if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
8964 CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8966 player->index_bit, leave_side);
8967 CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
8969 player->index_bit, leave_side);
8972 if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
8974 CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
8975 CE_OTHER_GETS_ENTERED,
8976 player->index_bit, enter_side);
8977 CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
8978 player->index_bit, enter_side);
8985 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
8987 TestIfHeroTouchesBadThing(jx, jy);
8988 TestIfPlayerTouchesCustomElement(jx, jy);
8990 TestIfElementTouchesCustomElement(jx, jy); /* for empty space */
8993 if (!player->active)
8997 if (level.use_step_counter)
9003 for (i = 0; i < MAX_PLAYERS; i++)
9005 struct PlayerInfo *player = &stored_player[i];
9007 if (SHIELD_ON(player))
9009 player->shield_normal_time_left--;
9011 if (player->shield_deadly_time_left > 0)
9012 player->shield_deadly_time_left--;
9020 if (TimeLeft <= 10 && setup.time_limit)
9021 PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
9023 DrawGameValue_Time(TimeLeft);
9025 if (!TimeLeft && setup.time_limit)
9026 for (i = 0; i < MAX_PLAYERS; i++)
9027 KillHero(&stored_player[i]);
9029 else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
9030 DrawGameValue_Time(TimePlayed);
9033 if (tape.single_step && tape.recording && !tape.pausing &&
9034 !player->programmed_action)
9035 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
9039 void ScrollScreen(struct PlayerInfo *player, int mode)
9041 static unsigned long screen_frame_counter = 0;
9043 if (mode == SCROLL_INIT)
9045 /* set scrolling step size according to actual player's moving speed */
9046 ScrollStepSize = TILEX / player->move_delay_value;
9048 screen_frame_counter = FrameCounter;
9049 ScreenMovDir = player->MovDir;
9050 ScreenMovPos = player->MovPos;
9051 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
9054 else if (!FrameReached(&screen_frame_counter, 1))
9059 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
9060 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
9061 redraw_mask |= REDRAW_FIELD;
9064 ScreenMovDir = MV_NO_MOVING;
9067 void TestIfPlayerTouchesCustomElement(int x, int y)
9069 static int xy[4][2] =
9076 static int trigger_sides[4][2] =
9078 /* center side border side */
9079 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, /* check top */
9080 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* check left */
9081 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* check right */
9082 { CH_SIDE_BOTTOM, CH_SIDE_TOP } /* check bottom */
9084 static int touch_dir[4] =
9091 int center_element = Feld[x][y]; /* should always be non-moving! */
9094 for (i = 0; i < NUM_DIRECTIONS; i++)
9096 int xx = x + xy[i][0];
9097 int yy = y + xy[i][1];
9098 int center_side = trigger_sides[i][0];
9099 int border_side = trigger_sides[i][1];
9102 if (!IN_LEV_FIELD(xx, yy))
9105 if (IS_PLAYER(x, y))
9107 struct PlayerInfo *player = PLAYERINFO(x, y);
9109 if (game.engine_version < VERSION_IDENT(3,0,7,0))
9110 border_element = Feld[xx][yy]; /* may be moving! */
9111 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
9112 border_element = Feld[xx][yy];
9113 else if (MovDir[xx][yy] & touch_dir[i]) /* elements are touching */
9114 border_element = MovingOrBlocked2Element(xx, yy);
9116 continue; /* center and border element do not touch */
9118 CheckTriggeredElementChangePlayer(xx, yy, border_element,
9119 CE_OTHER_GETS_TOUCHED,
9120 player->index_bit, border_side);
9121 CheckElementChangePlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
9122 player->index_bit, border_side);
9124 else if (IS_PLAYER(xx, yy))
9126 struct PlayerInfo *player = PLAYERINFO(xx, yy);
9128 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
9130 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
9131 continue; /* center and border element do not touch */
9134 CheckTriggeredElementChangePlayer(x, y, center_element,
9135 CE_OTHER_GETS_TOUCHED,
9136 player->index_bit, center_side);
9137 CheckElementChangePlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
9138 player->index_bit, center_side);
9145 void TestIfElementTouchesCustomElement(int x, int y)
9147 static int xy[4][2] =
9154 static int trigger_sides[4][2] =
9156 /* center side border side */
9157 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, /* check top */
9158 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, /* check left */
9159 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, /* check right */
9160 { CH_SIDE_BOTTOM, CH_SIDE_TOP } /* check bottom */
9162 static int touch_dir[4] =
9169 boolean change_center_element = FALSE;
9170 int center_element_change_page = 0;
9171 int center_element = Feld[x][y]; /* should always be non-moving! */
9172 int border_trigger_element;
9175 for (i = 0; i < NUM_DIRECTIONS; i++)
9177 int xx = x + xy[i][0];
9178 int yy = y + xy[i][1];
9179 int center_side = trigger_sides[i][0];
9180 int border_side = trigger_sides[i][1];
9183 if (!IN_LEV_FIELD(xx, yy))
9186 if (game.engine_version < VERSION_IDENT(3,0,7,0))
9187 border_element = Feld[xx][yy]; /* may be moving! */
9188 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
9189 border_element = Feld[xx][yy];
9190 else if (MovDir[xx][yy] & touch_dir[i]) /* elements are touching */
9191 border_element = MovingOrBlocked2Element(xx, yy);
9193 continue; /* center and border element do not touch */
9195 /* check for change of center element (but change it only once) */
9196 if (IS_CUSTOM_ELEMENT(center_element) &&
9197 HAS_ANY_CHANGE_EVENT(center_element, CE_OTHER_IS_TOUCHING) &&
9198 !change_center_element)
9200 for (j = 0; j < element_info[center_element].num_change_pages; j++)
9202 struct ElementChangeInfo *change =
9203 &element_info[center_element].change_page[j];
9205 if (change->can_change &&
9206 change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
9207 change->trigger_side & border_side &&
9209 IS_EQUAL_OR_IN_GROUP(border_element, change->trigger_element)
9211 change->trigger_element == border_element
9215 change_center_element = TRUE;
9216 center_element_change_page = j;
9217 border_trigger_element = border_element;
9224 /* check for change of border element */
9225 if (IS_CUSTOM_ELEMENT(border_element) &&
9226 HAS_ANY_CHANGE_EVENT(border_element, CE_OTHER_IS_TOUCHING))
9228 for (j = 0; j < element_info[border_element].num_change_pages; j++)
9230 struct ElementChangeInfo *change =
9231 &element_info[border_element].change_page[j];
9233 if (change->can_change &&
9234 change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
9235 change->trigger_side & center_side &&
9237 IS_EQUAL_OR_IN_GROUP(center_element, change->trigger_element)
9239 change->trigger_element == center_element
9244 printf("::: border_element %d, %d\n", x, y);
9247 CheckElementChangePage(xx, yy, border_element, center_element,
9248 CE_OTHER_IS_TOUCHING, j);
9255 if (change_center_element)
9258 printf("::: center_element %d, %d\n", x, y);
9261 CheckElementChangePage(x, y, center_element, border_trigger_element,
9262 CE_OTHER_IS_TOUCHING, center_element_change_page);
9266 void TestIfElementHitsCustomElement(int x, int y, int direction)
9268 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
9269 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
9270 int hitx = x + dx, hity = y + dy;
9271 int hitting_element = Feld[x][y];
9272 int touched_element;
9274 boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
9275 !IS_FREE(hitx, hity) &&
9276 (!IS_MOVING(hitx, hity) ||
9277 MovDir[hitx][hity] != direction ||
9278 ABS(MovPos[hitx][hity]) <= TILEY / 2));
9281 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
9285 if (IN_LEV_FIELD(hitx, hity) && !object_hit)
9289 touched_element = (IN_LEV_FIELD(hitx, hity) ?
9290 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
9292 CheckElementChangeSide(x, y, hitting_element, touched_element,
9293 CE_HITTING_SOMETHING, direction);
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;
9301 int touched_element = MovingOrBlocked2Element(hitx, hity);
9304 boolean object_hit = (!IS_MOVING(hitx, hity) ||
9305 MovDir[hitx][hity] != direction ||
9306 ABS(MovPos[hitx][hity]) <= TILEY / 2);
9315 CheckElementChangeSide(hitx, hity, touched_element, hitting_element,
9316 CE_HIT_BY_SOMETHING, opposite_direction);
9318 if (IS_CUSTOM_ELEMENT(hitting_element) &&
9319 HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING))
9321 for (i = 0; i < element_info[hitting_element].num_change_pages; i++)
9323 struct ElementChangeInfo *change =
9324 &element_info[hitting_element].change_page[i];
9326 if (change->can_change &&
9327 change->events & CH_EVENT_BIT(CE_OTHER_IS_HITTING) &&
9328 change->trigger_side & touched_side &&
9331 IS_EQUAL_OR_IN_GROUP(touched_element, change->trigger_element)
9333 change->trigger_element == touched_element
9337 CheckElementChangePage(x, y, hitting_element, touched_element,
9338 CE_OTHER_IS_HITTING, i);
9344 if (IS_CUSTOM_ELEMENT(touched_element) &&
9345 HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_HIT))
9347 for (i = 0; i < element_info[touched_element].num_change_pages; i++)
9349 struct ElementChangeInfo *change =
9350 &element_info[touched_element].change_page[i];
9352 if (change->can_change &&
9353 change->events & CH_EVENT_BIT(CE_OTHER_GETS_HIT) &&
9354 change->trigger_side & hitting_side &&
9356 IS_EQUAL_OR_IN_GROUP(hitting_element, change->trigger_element)
9358 change->trigger_element == hitting_element
9362 CheckElementChangePage(hitx, hity, touched_element,
9363 hitting_element, CE_OTHER_GETS_HIT, i);
9373 void TestIfElementSmashesCustomElement(int x, int y, int direction)
9375 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
9376 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
9377 int hitx = x + dx, hity = y + dy;
9378 int hitting_element = Feld[x][y];
9379 int touched_element;
9381 boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
9382 !IS_FREE(hitx, hity) &&
9383 (!IS_MOVING(hitx, hity) ||
9384 MovDir[hitx][hity] != direction ||
9385 ABS(MovPos[hitx][hity]) <= TILEY / 2));
9388 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
9392 if (IN_LEV_FIELD(hitx, hity) && !object_hit)
9396 touched_element = (IN_LEV_FIELD(hitx, hity) ?
9397 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
9399 CheckElementChangeSide(x, y, hitting_element, touched_element,
9400 EP_CAN_SMASH_EVERYTHING, direction);
9402 if (IN_LEV_FIELD(hitx, hity))
9404 int opposite_direction = MV_DIR_OPPOSITE(direction);
9405 int hitting_side = direction;
9406 int touched_side = opposite_direction;
9408 int touched_element = MovingOrBlocked2Element(hitx, hity);
9411 boolean object_hit = (!IS_MOVING(hitx, hity) ||
9412 MovDir[hitx][hity] != direction ||
9413 ABS(MovPos[hitx][hity]) <= TILEY / 2);
9422 CheckElementChangeSide(hitx, hity, touched_element, hitting_element,
9423 CE_SMASHED_BY_SOMETHING, opposite_direction);
9425 if (IS_CUSTOM_ELEMENT(hitting_element) &&
9426 HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_SMASHING))
9428 for (i = 0; i < element_info[hitting_element].num_change_pages; i++)
9430 struct ElementChangeInfo *change =
9431 &element_info[hitting_element].change_page[i];
9433 if (change->can_change &&
9434 change->events & CH_EVENT_BIT(CE_OTHER_IS_SMASHING) &&
9435 change->trigger_side & touched_side &&
9438 IS_EQUAL_OR_IN_GROUP(touched_element, change->trigger_element)
9440 change->trigger_element == touched_element
9444 CheckElementChangePage(x, y, hitting_element, touched_element,
9445 CE_OTHER_IS_SMASHING, i);
9451 if (IS_CUSTOM_ELEMENT(touched_element) &&
9452 HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_SMASHED))
9454 for (i = 0; i < element_info[touched_element].num_change_pages; i++)
9456 struct ElementChangeInfo *change =
9457 &element_info[touched_element].change_page[i];
9459 if (change->can_change &&
9460 change->events & CH_EVENT_BIT(CE_OTHER_GETS_SMASHED) &&
9461 change->trigger_side & hitting_side &&
9463 IS_EQUAL_OR_IN_GROUP(hitting_element, change->trigger_element)
9465 change->trigger_element == hitting_element
9469 CheckElementChangePage(hitx, hity, touched_element,
9470 hitting_element, CE_OTHER_GETS_SMASHED, i);
9480 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
9482 int i, kill_x = -1, kill_y = -1;
9483 static int test_xy[4][2] =
9490 static int test_dir[4] =
9498 for (i = 0; i < NUM_DIRECTIONS; i++)
9500 int test_x, test_y, test_move_dir, test_element;
9502 test_x = good_x + test_xy[i][0];
9503 test_y = good_y + test_xy[i][1];
9504 if (!IN_LEV_FIELD(test_x, test_y))
9508 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9511 test_element = Feld[test_x][test_y];
9513 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
9516 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9517 2nd case: DONT_TOUCH style bad thing does not move away from good thing
9519 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
9520 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
9528 if (kill_x != -1 || kill_y != -1)
9530 if (IS_PLAYER(good_x, good_y))
9532 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
9534 if (player->shield_deadly_time_left > 0)
9535 Bang(kill_x, kill_y);
9536 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
9540 Bang(good_x, good_y);
9544 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
9546 int i, kill_x = -1, kill_y = -1;
9547 int bad_element = Feld[bad_x][bad_y];
9548 static int test_xy[4][2] =
9555 static int touch_dir[4] =
9562 static int test_dir[4] =
9570 if (bad_element == EL_EXPLOSION) /* skip just exploding bad things */
9573 for (i = 0; i < NUM_DIRECTIONS; i++)
9575 int test_x, test_y, test_move_dir, test_element;
9577 test_x = bad_x + test_xy[i][0];
9578 test_y = bad_y + test_xy[i][1];
9579 if (!IN_LEV_FIELD(test_x, test_y))
9583 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9585 test_element = Feld[test_x][test_y];
9587 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9588 2nd case: DONT_TOUCH style bad thing does not move away from good thing
9590 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
9591 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
9593 /* good thing is player or penguin that does not move away */
9594 if (IS_PLAYER(test_x, test_y))
9596 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
9598 if (bad_element == EL_ROBOT && player->is_moving)
9599 continue; /* robot does not kill player if he is moving */
9601 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
9603 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
9604 continue; /* center and border element do not touch */
9611 else if (test_element == EL_PENGUIN)
9620 if (kill_x != -1 || kill_y != -1)
9622 if (IS_PLAYER(kill_x, kill_y))
9624 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
9626 if (player->shield_deadly_time_left > 0)
9628 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
9632 Bang(kill_x, kill_y);
9636 void TestIfHeroTouchesBadThing(int x, int y)
9638 TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9641 void TestIfHeroRunsIntoBadThing(int x, int y, int move_dir)
9643 TestIfGoodThingHitsBadThing(x, y, move_dir);
9646 void TestIfBadThingTouchesHero(int x, int y)
9648 TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9651 void TestIfBadThingRunsIntoHero(int x, int y, int move_dir)
9653 TestIfBadThingHitsGoodThing(x, y, move_dir);
9656 void TestIfFriendTouchesBadThing(int x, int y)
9658 TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9661 void TestIfBadThingTouchesFriend(int x, int y)
9663 TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9666 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
9668 int i, kill_x = bad_x, kill_y = bad_y;
9669 static int xy[4][2] =
9677 for (i = 0; i < NUM_DIRECTIONS; i++)
9681 x = bad_x + xy[i][0];
9682 y = bad_y + xy[i][1];
9683 if (!IN_LEV_FIELD(x, y))
9686 element = Feld[x][y];
9687 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
9688 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
9696 if (kill_x != bad_x || kill_y != bad_y)
9700 void KillHero(struct PlayerInfo *player)
9702 int jx = player->jx, jy = player->jy;
9704 if (!player->active)
9707 /* remove accessible field at the player's position */
9708 Feld[jx][jy] = EL_EMPTY;
9710 /* deactivate shield (else Bang()/Explode() would not work right) */
9711 player->shield_normal_time_left = 0;
9712 player->shield_deadly_time_left = 0;
9718 static void KillHeroUnlessEnemyProtected(int x, int y)
9720 if (!PLAYER_ENEMY_PROTECTED(x, y))
9721 KillHero(PLAYERINFO(x, y));
9724 static void KillHeroUnlessExplosionProtected(int x, int y)
9726 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
9727 KillHero(PLAYERINFO(x, y));
9730 void BuryHero(struct PlayerInfo *player)
9732 int jx = player->jx, jy = player->jy;
9734 if (!player->active)
9738 PlayLevelSoundElementAction(jx, jy, player->element_nr, ACTION_DYING);
9740 PlayLevelSound(jx, jy, SND_CLASS_PLAYER_DYING);
9742 PlayLevelSound(jx, jy, SND_GAME_LOSING);
9744 player->GameOver = TRUE;
9748 void RemoveHero(struct PlayerInfo *player)
9750 int jx = player->jx, jy = player->jy;
9751 int i, found = FALSE;
9753 player->present = FALSE;
9754 player->active = FALSE;
9756 if (!ExplodeField[jx][jy])
9757 StorePlayer[jx][jy] = 0;
9759 for (i = 0; i < MAX_PLAYERS; i++)
9760 if (stored_player[i].active)
9764 AllPlayersGone = TRUE;
9771 =============================================================================
9772 checkDiagonalPushing()
9773 -----------------------------------------------------------------------------
9774 check if diagonal input device direction results in pushing of object
9775 (by checking if the alternative direction is walkable, diggable, ...)
9776 =============================================================================
9779 static boolean checkDiagonalPushing(struct PlayerInfo *player,
9780 int x, int y, int real_dx, int real_dy)
9782 int jx, jy, dx, dy, xx, yy;
9784 if (real_dx == 0 || real_dy == 0) /* no diagonal direction => push */
9787 /* diagonal direction: check alternative direction */
9792 xx = jx + (dx == 0 ? real_dx : 0);
9793 yy = jy + (dy == 0 ? real_dy : 0);
9795 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
9799 =============================================================================
9801 -----------------------------------------------------------------------------
9802 x, y: field next to player (non-diagonal) to try to dig to
9803 real_dx, real_dy: direction as read from input device (can be diagonal)
9804 =============================================================================
9807 int DigField(struct PlayerInfo *player,
9808 int oldx, int oldy, int x, int y,
9809 int real_dx, int real_dy, int mode)
9811 static int trigger_sides[4] =
9813 CH_SIDE_RIGHT, /* moving left */
9814 CH_SIDE_LEFT, /* moving right */
9815 CH_SIDE_BOTTOM, /* moving up */
9816 CH_SIDE_TOP, /* moving down */
9819 boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0,0));
9821 int jx = oldx, jy = oldy;
9822 int dx = x - jx, dy = y - jy;
9823 int nextx = x + dx, nexty = y + dy;
9824 int move_direction = (dx == -1 ? MV_LEFT :
9825 dx == +1 ? MV_RIGHT :
9827 dy == +1 ? MV_DOWN : MV_NO_MOVING);
9828 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
9829 int dig_side = trigger_sides[MV_DIR_BIT(move_direction)];
9830 int old_element = Feld[jx][jy];
9833 if (player->MovPos == 0)
9835 player->is_digging = FALSE;
9836 player->is_collecting = FALSE;
9839 if (player->MovPos == 0) /* last pushing move finished */
9840 player->is_pushing = FALSE;
9842 if (mode == DF_NO_PUSH) /* player just stopped pushing */
9844 player->is_switching = FALSE;
9845 player->push_delay = 0;
9847 return MF_NO_ACTION;
9850 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
9851 return MF_NO_ACTION;
9856 if (IS_TUBE(Feld[jx][jy]) || IS_TUBE(Back[jx][jy]))
9858 if (IS_TUBE(Feld[jx][jy]) ||
9859 (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0)))
9863 int tube_element = (IS_TUBE(Feld[jx][jy]) ? Feld[jx][jy] : Back[jx][jy]);
9864 int tube_leave_directions[][2] =
9866 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
9867 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
9868 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
9869 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
9870 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
9871 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
9872 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
9873 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
9874 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
9875 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
9876 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
9877 { -1, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
9880 while (tube_leave_directions[i][0] != tube_element)
9883 if (tube_leave_directions[i][0] == -1) /* should not happen */
9887 if (!(tube_leave_directions[i][1] & move_direction))
9888 return MF_NO_ACTION; /* tube has no opening in this direction */
9893 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
9894 old_element = Back[jx][jy];
9898 if (IS_WALKABLE(old_element) &&
9899 !(element_info[old_element].access_direction & move_direction))
9900 return MF_NO_ACTION; /* field has no opening in this direction */
9902 element = Feld[x][y];
9904 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
9905 game.engine_version >= VERSION_IDENT(2,2,0,0))
9906 return MF_NO_ACTION;
9910 case EL_SP_PORT_LEFT:
9911 case EL_SP_PORT_RIGHT:
9913 case EL_SP_PORT_DOWN:
9914 case EL_SP_PORT_HORIZONTAL:
9915 case EL_SP_PORT_VERTICAL:
9916 case EL_SP_PORT_ANY:
9917 case EL_SP_GRAVITY_PORT_LEFT:
9918 case EL_SP_GRAVITY_PORT_RIGHT:
9919 case EL_SP_GRAVITY_PORT_UP:
9920 case EL_SP_GRAVITY_PORT_DOWN:
9922 if (!canEnterSupaplexPort(x, y, dx, dy))
9923 return MF_NO_ACTION;
9926 element != EL_SP_PORT_LEFT &&
9927 element != EL_SP_GRAVITY_PORT_LEFT &&
9928 element != EL_SP_PORT_HORIZONTAL &&
9929 element != EL_SP_PORT_ANY) ||
9931 element != EL_SP_PORT_RIGHT &&
9932 element != EL_SP_GRAVITY_PORT_RIGHT &&
9933 element != EL_SP_PORT_HORIZONTAL &&
9934 element != EL_SP_PORT_ANY) ||
9936 element != EL_SP_PORT_UP &&
9937 element != EL_SP_GRAVITY_PORT_UP &&
9938 element != EL_SP_PORT_VERTICAL &&
9939 element != EL_SP_PORT_ANY) ||
9941 element != EL_SP_PORT_DOWN &&
9942 element != EL_SP_GRAVITY_PORT_DOWN &&
9943 element != EL_SP_PORT_VERTICAL &&
9944 element != EL_SP_PORT_ANY) ||
9945 !IN_LEV_FIELD(nextx, nexty) ||
9946 !IS_FREE(nextx, nexty))
9947 return MF_NO_ACTION;
9950 if (element == EL_SP_GRAVITY_PORT_LEFT ||
9951 element == EL_SP_GRAVITY_PORT_RIGHT ||
9952 element == EL_SP_GRAVITY_PORT_UP ||
9953 element == EL_SP_GRAVITY_PORT_DOWN)
9954 game.gravity = !game.gravity;
9956 /* automatically move to the next field with double speed */
9957 player->programmed_action = move_direction;
9959 if (player->move_delay_reset_counter == 0)
9961 player->move_delay_reset_counter = 2; /* two double speed steps */
9963 DOUBLE_PLAYER_SPEED(player);
9966 player->move_delay_reset_counter = 2;
9968 DOUBLE_PLAYER_SPEED(player);
9972 printf("::: passing port %d,%d [%d]\n", x, y, FrameCounter);
9975 PlayLevelSound(x, y, SND_CLASS_SP_PORT_PASSING);
9980 case EL_TUBE_VERTICAL:
9981 case EL_TUBE_HORIZONTAL:
9982 case EL_TUBE_VERTICAL_LEFT:
9983 case EL_TUBE_VERTICAL_RIGHT:
9984 case EL_TUBE_HORIZONTAL_UP:
9985 case EL_TUBE_HORIZONTAL_DOWN:
9986 case EL_TUBE_LEFT_UP:
9987 case EL_TUBE_LEFT_DOWN:
9988 case EL_TUBE_RIGHT_UP:
9989 case EL_TUBE_RIGHT_DOWN:
9992 int tube_enter_directions[][2] =
9994 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
9995 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
9996 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
9997 { EL_TUBE_VERTICAL_LEFT, MV_RIGHT | MV_UP | MV_DOWN },
9998 { EL_TUBE_VERTICAL_RIGHT, MV_LEFT | MV_UP | MV_DOWN },
9999 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_DOWN },
10000 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_UP },
10001 { EL_TUBE_LEFT_UP, MV_RIGHT | MV_DOWN },
10002 { EL_TUBE_LEFT_DOWN, MV_RIGHT | MV_UP },
10003 { EL_TUBE_RIGHT_UP, MV_LEFT | MV_DOWN },
10004 { EL_TUBE_RIGHT_DOWN, MV_LEFT | MV_UP },
10005 { -1, MV_NO_MOVING }
10008 while (tube_enter_directions[i][0] != element)
10011 if (tube_enter_directions[i][0] == -1) /* should not happen */
10015 if (!(tube_enter_directions[i][1] & move_direction))
10016 return MF_NO_ACTION; /* tube has no opening in this direction */
10018 PlayLevelSound(x, y, SND_CLASS_TUBE_WALKING);
10025 if (IS_WALKABLE(element))
10027 int sound_action = ACTION_WALKING;
10029 if (!(element_info[element].access_direction & opposite_direction))
10030 return MF_NO_ACTION; /* field not accessible from this direction */
10032 if (element >= EL_GATE_1 && element <= EL_GATE_4)
10034 if (!player->key[element - EL_GATE_1])
10035 return MF_NO_ACTION;
10037 else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY)
10039 if (!player->key[element - EL_GATE_1_GRAY])
10040 return MF_NO_ACTION;
10042 else if (element == EL_EXIT_OPEN ||
10043 element == EL_SP_EXIT_OPEN ||
10044 element == EL_SP_EXIT_OPENING)
10046 sound_action = ACTION_PASSING; /* player is passing exit */
10048 else if (element == EL_EMPTY)
10050 sound_action = ACTION_MOVING; /* nothing to walk on */
10053 /* play sound from background or player, whatever is available */
10054 if (element_info[element].sound[sound_action] != SND_UNDEFINED)
10055 PlayLevelSoundElementAction(x, y, element, sound_action);
10057 PlayLevelSoundElementAction(x, y, player->element_nr, sound_action);
10061 else if (IS_PASSABLE(element))
10063 if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
10064 return MF_NO_ACTION;
10066 if (IS_CUSTOM_ELEMENT(element) &&
10067 !(element_info[element].access_direction & opposite_direction))
10068 return MF_NO_ACTION; /* field not accessible from this direction */
10071 if (CAN_MOVE(element)) /* only fixed elements can be passed! */
10072 return MF_NO_ACTION;
10075 if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4)
10077 if (!player->key[element - EL_EM_GATE_1])
10078 return MF_NO_ACTION;
10080 else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY)
10082 if (!player->key[element - EL_EM_GATE_1_GRAY])
10083 return MF_NO_ACTION;
10086 /* automatically move to the next field with double speed */
10087 player->programmed_action = move_direction;
10089 if (player->move_delay_reset_counter == 0)
10091 player->move_delay_reset_counter = 2; /* two double speed steps */
10093 DOUBLE_PLAYER_SPEED(player);
10096 player->move_delay_reset_counter = 2;
10098 DOUBLE_PLAYER_SPEED(player);
10101 PlayLevelSoundAction(x, y, ACTION_PASSING);
10105 else if (IS_DIGGABLE(element))
10109 if (mode != DF_SNAP)
10112 GfxElement[x][y] = GFX_ELEMENT(element);
10115 (GFX_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
10117 player->is_digging = TRUE;
10120 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
10122 CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_DIGGED,
10123 player->index_bit, CH_SIDE_ANY);
10126 if (mode == DF_SNAP)
10127 TestIfElementTouchesCustomElement(x, y); /* for empty space */
10132 else if (IS_COLLECTIBLE(element))
10136 if (mode != DF_SNAP)
10138 GfxElement[x][y] = element;
10139 player->is_collecting = TRUE;
10142 if (element == EL_SPEED_PILL)
10143 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
10144 else if (element == EL_EXTRA_TIME && level.time > 0)
10147 DrawGameValue_Time(TimeLeft);
10149 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
10151 player->shield_normal_time_left += 10;
10152 if (element == EL_SHIELD_DEADLY)
10153 player->shield_deadly_time_left += 10;
10155 else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
10157 if (player->inventory_size < MAX_INVENTORY_SIZE)
10158 player->inventory_element[player->inventory_size++] = element;
10160 DrawGameValue_Dynamite(local_player->inventory_size);
10162 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
10164 player->dynabomb_count++;
10165 player->dynabombs_left++;
10167 else if (element == EL_DYNABOMB_INCREASE_SIZE)
10169 player->dynabomb_size++;
10171 else if (element == EL_DYNABOMB_INCREASE_POWER)
10173 player->dynabomb_xl = TRUE;
10175 else if ((element >= EL_KEY_1 && element <= EL_KEY_4) ||
10176 (element >= EL_EM_KEY_1 && element <= EL_EM_KEY_4))
10178 int key_nr = (element >= EL_KEY_1 && element <= EL_KEY_4 ?
10179 element - EL_KEY_1 : element - EL_EM_KEY_1);
10181 player->key[key_nr] = TRUE;
10183 DrawGameValue_Keys(player);
10185 redraw_mask |= REDRAW_DOOR_1;
10187 else if (IS_ENVELOPE(element))
10190 player->show_envelope = element;
10192 ShowEnvelope(element - EL_ENVELOPE_1);
10195 else if (IS_DROPPABLE(element)) /* can be collected and dropped */
10199 if (element_info[element].collect_count == 0)
10200 player->inventory_infinite_element = element;
10202 for (i = 0; i < element_info[element].collect_count; i++)
10203 if (player->inventory_size < MAX_INVENTORY_SIZE)
10204 player->inventory_element[player->inventory_size++] = element;
10206 DrawGameValue_Dynamite(local_player->inventory_size);
10208 else if (element_info[element].collect_count > 0)
10210 local_player->gems_still_needed -=
10211 element_info[element].collect_count;
10212 if (local_player->gems_still_needed < 0)
10213 local_player->gems_still_needed = 0;
10215 DrawGameValue_Emeralds(local_player->gems_still_needed);
10218 RaiseScoreElement(element);
10219 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
10221 CheckTriggeredElementChangePlayer(x, y, element,
10222 CE_OTHER_GETS_COLLECTED,
10223 player->index_bit, CH_SIDE_ANY);
10226 if (mode == DF_SNAP)
10227 TestIfElementTouchesCustomElement(x, y); /* for empty space */
10232 else if (IS_PUSHABLE(element))
10234 if (mode == DF_SNAP && element != EL_BD_ROCK)
10235 return MF_NO_ACTION;
10237 if (CAN_FALL(element) && dy)
10238 return MF_NO_ACTION;
10240 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
10241 !(element == EL_SPRING && level.use_spring_bug))
10242 return MF_NO_ACTION;
10245 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
10246 ((move_direction & MV_VERTICAL &&
10247 ((element_info[element].move_pattern & MV_LEFT &&
10248 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
10249 (element_info[element].move_pattern & MV_RIGHT &&
10250 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
10251 (move_direction & MV_HORIZONTAL &&
10252 ((element_info[element].move_pattern & MV_UP &&
10253 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
10254 (element_info[element].move_pattern & MV_DOWN &&
10255 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
10256 return MF_NO_ACTION;
10260 /* do not push elements already moving away faster than player */
10261 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
10262 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
10263 return MF_NO_ACTION;
10265 if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
10266 return MF_NO_ACTION;
10270 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
10272 if (player->push_delay_value == -1)
10273 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10275 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
10277 if (!player->is_pushing)
10278 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10282 if (game.engine_version >= VERSION_IDENT(2,2,0,7) &&
10283 (game.engine_version < VERSION_IDENT(3,0,7,1) ||
10284 !player_is_pushing))
10285 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10288 if (!player->is_pushing &&
10289 game.engine_version >= VERSION_IDENT(2,2,0,7))
10290 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10294 printf("::: push delay: %ld [%d, %d] [%d]\n",
10295 player->push_delay_value, FrameCounter, game.engine_version,
10296 player->is_pushing);
10299 player->is_pushing = TRUE;
10301 if (!(IN_LEV_FIELD(nextx, nexty) &&
10302 (IS_FREE(nextx, nexty) ||
10303 (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
10304 IS_SB_ELEMENT(element)))))
10305 return MF_NO_ACTION;
10307 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
10308 return MF_NO_ACTION;
10310 if (player->push_delay == 0) /* new pushing; restart delay */
10311 player->push_delay = FrameCounter;
10313 if (!FrameReached(&player->push_delay, player->push_delay_value) &&
10314 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
10315 element != EL_SPRING && element != EL_BALLOON)
10317 /* make sure that there is no move delay before next try to push */
10318 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
10319 player->move_delay = INITIAL_MOVE_DELAY_OFF;
10321 return MF_NO_ACTION;
10325 printf("::: NOW PUSHING... [%d]\n", FrameCounter);
10328 if (IS_SB_ELEMENT(element))
10330 if (element == EL_SOKOBAN_FIELD_FULL)
10332 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
10333 local_player->sokobanfields_still_needed++;
10336 if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
10338 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
10339 local_player->sokobanfields_still_needed--;
10342 Feld[x][y] = EL_SOKOBAN_OBJECT;
10344 if (Back[x][y] == Back[nextx][nexty])
10345 PlayLevelSoundAction(x, y, ACTION_PUSHING);
10346 else if (Back[x][y] != 0)
10347 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
10350 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
10353 if (local_player->sokobanfields_still_needed == 0 &&
10354 game.emulation == EMU_SOKOBAN)
10356 player->LevelSolved = player->GameOver = TRUE;
10357 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
10361 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
10363 InitMovingField(x, y, move_direction);
10364 GfxAction[x][y] = ACTION_PUSHING;
10366 if (mode == DF_SNAP)
10367 ContinueMoving(x, y);
10369 MovPos[x][y] = (dx != 0 ? dx : dy);
10371 Pushed[x][y] = TRUE;
10372 Pushed[nextx][nexty] = TRUE;
10374 if (game.engine_version < VERSION_IDENT(2,2,0,7))
10375 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
10377 player->push_delay_value = -1; /* get new value later */
10379 CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PUSHED,
10380 player->index_bit, dig_side);
10381 CheckElementChangePlayer(x, y, element, CE_PUSHED_BY_PLAYER,
10382 player->index_bit, dig_side);
10386 else if (IS_SWITCHABLE(element))
10388 if (PLAYER_SWITCHING(player, x, y))
10391 player->is_switching = TRUE;
10392 player->switch_x = x;
10393 player->switch_y = y;
10395 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
10397 if (element == EL_ROBOT_WHEEL)
10399 Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
10403 DrawLevelField(x, y);
10405 else if (element == EL_SP_TERMINAL)
10409 for (yy = 0; yy < lev_fieldy; yy++) for (xx=0; xx < lev_fieldx; xx++)
10411 if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
10413 else if (Feld[xx][yy] == EL_SP_TERMINAL)
10414 Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
10417 else if (IS_BELT_SWITCH(element))
10419 ToggleBeltSwitch(x, y);
10421 else if (element == EL_SWITCHGATE_SWITCH_UP ||
10422 element == EL_SWITCHGATE_SWITCH_DOWN)
10424 ToggleSwitchgateSwitch(x, y);
10426 else if (element == EL_LIGHT_SWITCH ||
10427 element == EL_LIGHT_SWITCH_ACTIVE)
10429 ToggleLightSwitch(x, y);
10432 PlayLevelSound(x, y, element == EL_LIGHT_SWITCH ?
10433 SND_LIGHT_SWITCH_ACTIVATING :
10434 SND_LIGHT_SWITCH_DEACTIVATING);
10437 else if (element == EL_TIMEGATE_SWITCH)
10439 ActivateTimegateSwitch(x, y);
10441 else if (element == EL_BALLOON_SWITCH_LEFT ||
10442 element == EL_BALLOON_SWITCH_RIGHT ||
10443 element == EL_BALLOON_SWITCH_UP ||
10444 element == EL_BALLOON_SWITCH_DOWN ||
10445 element == EL_BALLOON_SWITCH_ANY)
10447 if (element == EL_BALLOON_SWITCH_ANY)
10448 game.balloon_dir = move_direction;
10450 game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
10451 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
10452 element == EL_BALLOON_SWITCH_UP ? MV_UP :
10453 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
10456 else if (element == EL_LAMP)
10458 Feld[x][y] = EL_LAMP_ACTIVE;
10459 local_player->lights_still_needed--;
10461 DrawLevelField(x, y);
10463 else if (element == EL_TIME_ORB_FULL)
10465 Feld[x][y] = EL_TIME_ORB_EMPTY;
10467 DrawGameValue_Time(TimeLeft);
10469 DrawLevelField(x, y);
10472 PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
10480 if (!PLAYER_SWITCHING(player, x, y))
10482 player->is_switching = TRUE;
10483 player->switch_x = x;
10484 player->switch_y = y;
10486 CheckTriggeredElementChangePlayer(x, y, element,
10487 CE_OTHER_IS_SWITCHING,
10488 player->index_bit, dig_side);
10489 CheckElementChangePlayer(x, y, element, CE_SWITCHED,
10490 player->index_bit, dig_side);
10493 CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PRESSED,
10494 player->index_bit, dig_side);
10495 CheckElementChangePlayer(x, y, element, CE_PRESSED_BY_PLAYER,
10496 player->index_bit, dig_side);
10499 return MF_NO_ACTION;
10502 player->push_delay = 0;
10504 if (Feld[x][y] != element) /* really digged/collected something */
10505 player->is_collecting = !player->is_digging;
10510 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
10512 int jx = player->jx, jy = player->jy;
10513 int x = jx + dx, y = jy + dy;
10514 int snap_direction = (dx == -1 ? MV_LEFT :
10515 dx == +1 ? MV_RIGHT :
10517 dy == +1 ? MV_DOWN : MV_NO_MOVING);
10520 if (player->MovPos)
10523 if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0,0))
10527 if (!player->active || !IN_LEV_FIELD(x, y))
10535 if (player->MovPos == 0)
10536 player->is_pushing = FALSE;
10538 player->is_snapping = FALSE;
10540 if (player->MovPos == 0)
10542 player->is_moving = FALSE;
10543 player->is_digging = FALSE;
10544 player->is_collecting = FALSE;
10550 if (player->is_snapping)
10553 player->MovDir = snap_direction;
10556 if (player->MovPos == 0)
10559 player->is_moving = FALSE;
10560 player->is_digging = FALSE;
10561 player->is_collecting = FALSE;
10564 player->is_dropping = FALSE;
10566 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
10569 player->is_snapping = TRUE;
10572 if (player->MovPos == 0)
10575 player->is_moving = FALSE;
10576 player->is_digging = FALSE;
10577 player->is_collecting = FALSE;
10580 DrawLevelField(x, y);
10586 boolean DropElement(struct PlayerInfo *player)
10588 int jx = player->jx, jy = player->jy;
10589 int old_element = Feld[jx][jy];
10590 int new_element = (player->inventory_size > 0 ?
10591 player->inventory_element[player->inventory_size - 1] :
10592 player->inventory_infinite_element != EL_UNDEFINED ?
10593 player->inventory_infinite_element :
10594 player->dynabombs_left > 0 ?
10595 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
10598 /* check if player is active, not moving and ready to drop */
10599 if (!player->active || player->MovPos || player->drop_delay > 0)
10602 /* check if player has anything that can be dropped */
10604 if (new_element == EL_UNDEFINED)
10607 if (player->inventory_size == 0 &&
10608 player->inventory_infinite_element == EL_UNDEFINED &&
10609 player->dynabombs_left == 0)
10613 /* check if anything can be dropped at the current position */
10614 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
10617 /* collected custom elements can only be dropped on empty fields */
10619 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
10622 if (player->inventory_size > 0 &&
10623 IS_CUSTOM_ELEMENT(player->inventory_element[player->inventory_size - 1])
10624 && old_element != EL_EMPTY)
10628 if (old_element != EL_EMPTY)
10629 Back[jx][jy] = old_element; /* store old element on this field */
10631 ResetGfxAnimation(jx, jy);
10632 ResetRandomAnimationValue(jx, jy);
10634 if (player->inventory_size > 0 ||
10635 player->inventory_infinite_element != EL_UNDEFINED)
10637 if (player->inventory_size > 0)
10639 player->inventory_size--;
10642 new_element = player->inventory_element[player->inventory_size];
10645 DrawGameValue_Dynamite(local_player->inventory_size);
10647 if (new_element == EL_DYNAMITE)
10648 new_element = EL_DYNAMITE_ACTIVE;
10649 else if (new_element == EL_SP_DISK_RED)
10650 new_element = EL_SP_DISK_RED_ACTIVE;
10653 Feld[jx][jy] = new_element;
10655 if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
10656 DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
10658 PlayLevelSoundAction(jx, jy, ACTION_DROPPING);
10661 /* needed if previous element just changed to "empty" in the last frame */
10662 Changed[jx][jy] = 0; /* allow another change */
10665 CheckTriggeredElementChangePlayer(jx, jy, new_element,
10666 CE_OTHER_GETS_DROPPED,
10667 player->index_bit, CH_SIDE_ANY);
10668 CheckElementChangePlayer(jx, jy, new_element, CE_DROPPED_BY_PLAYER,
10669 player->index_bit, CH_SIDE_ANY);
10671 TestIfElementTouchesCustomElement(jx, jy);
10673 else /* player is dropping a dyna bomb */
10675 player->dynabombs_left--;
10678 new_element = EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr;
10681 Feld[jx][jy] = new_element;
10683 if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
10684 DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
10686 PlayLevelSoundAction(jx, jy, ACTION_DROPPING);
10693 if (Feld[jx][jy] == new_element) /* uninitialized unless CE change */
10696 InitField_WithBug1(jx, jy, FALSE);
10698 InitField(jx, jy, FALSE);
10699 if (CAN_MOVE(Feld[jx][jy]))
10700 InitMovDir(jx, jy);
10704 new_element = Feld[jx][jy];
10706 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
10707 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
10709 int move_stepsize = element_info[new_element].move_stepsize;
10710 int direction, dx, dy, nextx, nexty;
10712 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
10713 MovDir[jx][jy] = player->MovDir;
10715 direction = MovDir[jx][jy];
10716 dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
10717 dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
10721 if (IN_LEV_FIELD(nextx, nexty) && IS_FREE(nextx, nexty))
10724 WasJustMoving[jx][jy] = 3;
10726 InitMovingField(jx, jy, direction);
10727 ContinueMoving(jx, jy);
10732 Changed[jx][jy] = 0; /* allow another change */
10735 TestIfElementHitsCustomElement(jx, jy, direction);
10737 CheckElementChangeSide(jx, jy, new_element, touched_element,
10738 CE_HITTING_SOMETHING, direction);
10742 player->drop_delay = 2 * TILEX / move_stepsize + 1;
10746 player->drop_delay = 8 + 8 + 8;
10751 player->is_dropping = TRUE;
10757 /* ------------------------------------------------------------------------- */
10758 /* game sound playing functions */
10759 /* ------------------------------------------------------------------------- */
10761 static int *loop_sound_frame = NULL;
10762 static int *loop_sound_volume = NULL;
10764 void InitPlayLevelSound()
10766 int num_sounds = getSoundListSize();
10768 checked_free(loop_sound_frame);
10769 checked_free(loop_sound_volume);
10771 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
10772 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
10775 static void PlayLevelSound(int x, int y, int nr)
10777 int sx = SCREENX(x), sy = SCREENY(y);
10778 int volume, stereo_position;
10779 int max_distance = 8;
10780 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
10782 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
10783 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
10786 if (!IN_LEV_FIELD(x, y) ||
10787 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
10788 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
10791 volume = SOUND_MAX_VOLUME;
10793 if (!IN_SCR_FIELD(sx, sy))
10795 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
10796 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
10798 volume -= volume * (dx > dy ? dx : dy) / max_distance;
10801 stereo_position = (SOUND_MAX_LEFT +
10802 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
10803 (SCR_FIELDX + 2 * max_distance));
10805 if (IS_LOOP_SOUND(nr))
10807 /* This assures that quieter loop sounds do not overwrite louder ones,
10808 while restarting sound volume comparison with each new game frame. */
10810 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
10813 loop_sound_volume[nr] = volume;
10814 loop_sound_frame[nr] = FrameCounter;
10817 PlaySoundExt(nr, volume, stereo_position, type);
10820 static void PlayLevelSoundNearest(int x, int y, int sound_action)
10822 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
10823 x > LEVELX(BX2) ? LEVELX(BX2) : x,
10824 y < LEVELY(BY1) ? LEVELY(BY1) :
10825 y > LEVELY(BY2) ? LEVELY(BY2) : y,
10829 static void PlayLevelSoundAction(int x, int y, int action)
10831 PlayLevelSoundElementAction(x, y, Feld[x][y], action);
10834 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
10836 int sound_effect = element_info[element].sound[action];
10838 if (sound_effect != SND_UNDEFINED)
10839 PlayLevelSound(x, y, sound_effect);
10842 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
10845 int sound_effect = element_info[element].sound[action];
10847 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10848 PlayLevelSound(x, y, sound_effect);
10851 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
10853 int sound_effect = element_info[Feld[x][y]].sound[action];
10855 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10856 PlayLevelSound(x, y, sound_effect);
10859 static void StopLevelSoundActionIfLoop(int x, int y, int action)
10861 int sound_effect = element_info[Feld[x][y]].sound[action];
10863 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10864 StopSound(sound_effect);
10867 static void PlayLevelMusic()
10869 if (levelset.music[level_nr] != MUS_UNDEFINED)
10870 PlayMusic(levelset.music[level_nr]); /* from config file */
10872 PlayMusic(MAP_NOCONF_MUSIC(level_nr)); /* from music dir */
10875 void RaiseScore(int value)
10877 local_player->score += value;
10879 DrawGameValue_Score(local_player->score);
10882 void RaiseScoreElement(int element)
10887 case EL_BD_DIAMOND:
10888 case EL_EMERALD_YELLOW:
10889 case EL_EMERALD_RED:
10890 case EL_EMERALD_PURPLE:
10891 case EL_SP_INFOTRON:
10892 RaiseScore(level.score[SC_EMERALD]);
10895 RaiseScore(level.score[SC_DIAMOND]);
10898 RaiseScore(level.score[SC_CRYSTAL]);
10901 RaiseScore(level.score[SC_PEARL]);
10904 case EL_BD_BUTTERFLY:
10905 case EL_SP_ELECTRON:
10906 RaiseScore(level.score[SC_BUG]);
10909 case EL_BD_FIREFLY:
10910 case EL_SP_SNIKSNAK:
10911 RaiseScore(level.score[SC_SPACESHIP]);
10914 case EL_DARK_YAMYAM:
10915 RaiseScore(level.score[SC_YAMYAM]);
10918 RaiseScore(level.score[SC_ROBOT]);
10921 RaiseScore(level.score[SC_PACMAN]);
10924 RaiseScore(level.score[SC_NUT]);
10927 case EL_SP_DISK_RED:
10928 case EL_DYNABOMB_INCREASE_NUMBER:
10929 case EL_DYNABOMB_INCREASE_SIZE:
10930 case EL_DYNABOMB_INCREASE_POWER:
10931 RaiseScore(level.score[SC_DYNAMITE]);
10933 case EL_SHIELD_NORMAL:
10934 case EL_SHIELD_DEADLY:
10935 RaiseScore(level.score[SC_SHIELD]);
10937 case EL_EXTRA_TIME:
10938 RaiseScore(level.score[SC_TIME_BONUS]);
10944 RaiseScore(level.score[SC_KEY]);
10947 RaiseScore(element_info[element].collect_score);
10952 void RequestQuitGame(boolean ask_if_really_quit)
10954 if (AllPlayersGone ||
10955 !ask_if_really_quit ||
10956 level_editor_test_game ||
10957 Request("Do you really want to quit the game ?",
10958 REQ_ASK | REQ_STAY_CLOSED))
10960 #if defined(PLATFORM_UNIX)
10961 if (options.network)
10962 SendToServer_StopPlaying();
10966 game_status = GAME_MODE_MAIN;
10974 if (tape.playing && tape.index_search)
10976 SetDrawDeactivationMask(REDRAW_NONE);
10977 audio.sound_deactivated = FALSE;
10981 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
10984 if (tape.playing && tape.index_search)
10986 SetDrawDeactivationMask(REDRAW_FIELD);
10987 audio.sound_deactivated = TRUE;
10995 /* ---------- new game button stuff ---------------------------------------- */
10997 /* graphic position values for game buttons */
10998 #define GAME_BUTTON_XSIZE 30
10999 #define GAME_BUTTON_YSIZE 30
11000 #define GAME_BUTTON_XPOS 5
11001 #define GAME_BUTTON_YPOS 215
11002 #define SOUND_BUTTON_XPOS 5
11003 #define SOUND_BUTTON_YPOS (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
11005 #define GAME_BUTTON_STOP_XPOS (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
11006 #define GAME_BUTTON_PAUSE_XPOS (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
11007 #define GAME_BUTTON_PLAY_XPOS (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
11008 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
11009 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
11010 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
11017 } gamebutton_info[NUM_GAME_BUTTONS] =
11020 GAME_BUTTON_STOP_XPOS, GAME_BUTTON_YPOS,
11025 GAME_BUTTON_PAUSE_XPOS, GAME_BUTTON_YPOS,
11026 GAME_CTRL_ID_PAUSE,
11030 GAME_BUTTON_PLAY_XPOS, GAME_BUTTON_YPOS,
11035 SOUND_BUTTON_MUSIC_XPOS, SOUND_BUTTON_YPOS,
11036 SOUND_CTRL_ID_MUSIC,
11037 "background music on/off"
11040 SOUND_BUTTON_LOOPS_XPOS, SOUND_BUTTON_YPOS,
11041 SOUND_CTRL_ID_LOOPS,
11042 "sound loops on/off"
11045 SOUND_BUTTON_SIMPLE_XPOS, SOUND_BUTTON_YPOS,
11046 SOUND_CTRL_ID_SIMPLE,
11047 "normal sounds on/off"
11051 void CreateGameButtons()
11055 for (i = 0; i < NUM_GAME_BUTTONS; i++)
11057 Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
11058 struct GadgetInfo *gi;
11061 unsigned long event_mask;
11062 int gd_xoffset, gd_yoffset;
11063 int gd_x1, gd_x2, gd_y1, gd_y2;
11066 gd_xoffset = gamebutton_info[i].x;
11067 gd_yoffset = gamebutton_info[i].y;
11068 gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
11069 gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
11071 if (id == GAME_CTRL_ID_STOP ||
11072 id == GAME_CTRL_ID_PAUSE ||
11073 id == GAME_CTRL_ID_PLAY)
11075 button_type = GD_TYPE_NORMAL_BUTTON;
11077 event_mask = GD_EVENT_RELEASED;
11078 gd_y1 = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
11079 gd_y2 = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
11083 button_type = GD_TYPE_CHECK_BUTTON;
11085 ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
11086 (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
11087 (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
11088 event_mask = GD_EVENT_PRESSED;
11089 gd_y1 = DOOR_GFX_PAGEY1 + gd_yoffset;
11090 gd_y2 = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
11093 gi = CreateGadget(GDI_CUSTOM_ID, id,
11094 GDI_INFO_TEXT, gamebutton_info[i].infotext,
11095 GDI_X, DX + gd_xoffset,
11096 GDI_Y, DY + gd_yoffset,
11097 GDI_WIDTH, GAME_BUTTON_XSIZE,
11098 GDI_HEIGHT, GAME_BUTTON_YSIZE,
11099 GDI_TYPE, button_type,
11100 GDI_STATE, GD_BUTTON_UNPRESSED,
11101 GDI_CHECKED, checked,
11102 GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
11103 GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
11104 GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
11105 GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
11106 GDI_EVENT_MASK, event_mask,
11107 GDI_CALLBACK_ACTION, HandleGameButtons,
11111 Error(ERR_EXIT, "cannot create gadget");
11113 game_gadget[id] = gi;
11117 void FreeGameButtons()
11121 for (i = 0; i < NUM_GAME_BUTTONS; i++)
11122 FreeGadget(game_gadget[i]);
11125 static void MapGameButtons()
11129 for (i = 0; i < NUM_GAME_BUTTONS; i++)
11130 MapGadget(game_gadget[i]);
11133 void UnmapGameButtons()
11137 for (i = 0; i < NUM_GAME_BUTTONS; i++)
11138 UnmapGadget(game_gadget[i]);
11141 static void HandleGameButtons(struct GadgetInfo *gi)
11143 int id = gi->custom_id;
11145 if (game_status != GAME_MODE_PLAYING)
11150 case GAME_CTRL_ID_STOP:
11151 RequestQuitGame(TRUE);
11154 case GAME_CTRL_ID_PAUSE:
11155 if (options.network)
11157 #if defined(PLATFORM_UNIX)
11159 SendToServer_ContinuePlaying();
11161 SendToServer_PausePlaying();
11165 TapeTogglePause(TAPE_TOGGLE_MANUAL);
11168 case GAME_CTRL_ID_PLAY:
11171 #if defined(PLATFORM_UNIX)
11172 if (options.network)
11173 SendToServer_ContinuePlaying();
11177 tape.pausing = FALSE;
11178 DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
11183 case SOUND_CTRL_ID_MUSIC:
11184 if (setup.sound_music)
11186 setup.sound_music = FALSE;
11189 else if (audio.music_available)
11191 setup.sound = setup.sound_music = TRUE;
11193 SetAudioMode(setup.sound);
11199 case SOUND_CTRL_ID_LOOPS:
11200 if (setup.sound_loops)
11201 setup.sound_loops = FALSE;
11202 else if (audio.loops_available)
11204 setup.sound = setup.sound_loops = TRUE;
11205 SetAudioMode(setup.sound);
11209 case SOUND_CTRL_ID_SIMPLE:
11210 if (setup.sound_simple)
11211 setup.sound_simple = FALSE;
11212 else if (audio.sound_available)
11214 setup.sound = setup.sound_simple = TRUE;
11215 SetAudioMode(setup.sound);