1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
12 #include "libgame/libgame.h"
26 #define DEBUG_INIT_PLAYER 1
27 #define DEBUG_PLAYER_ACTIONS 0
30 #define USE_NEW_AMOEBA_CODE FALSE
33 #define USE_QUICKSAND_BD_ROCK_BUGFIX 0
34 #define USE_QUICKSAND_IMPACT_BUGFIX 0
35 #define USE_DELAYED_GFX_REDRAW 0
36 #define USE_NEW_PLAYER_ASSIGNMENTS 1
38 #if USE_DELAYED_GFX_REDRAW
39 #define TEST_DrawLevelField(x, y) \
40 GfxRedraw[x][y] |= GFX_REDRAW_TILE
41 #define TEST_DrawLevelFieldCrumbled(x, y) \
42 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED
43 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
44 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS
45 #define TEST_DrawTwinkleOnField(x, y) \
46 GfxRedraw[x][y] |= GFX_REDRAW_TILE_TWINKLED
48 #define TEST_DrawLevelField(x, y) \
50 #define TEST_DrawLevelFieldCrumbled(x, y) \
51 DrawLevelFieldCrumbled(x, y)
52 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
53 DrawLevelFieldCrumbledNeighbours(x, y)
54 #define TEST_DrawTwinkleOnField(x, y) \
55 DrawTwinkleOnField(x, y)
65 #define MP_NO_ACTION 0
68 #define MP_DONT_RUN_INTO (MP_MOVING | MP_ACTION)
72 #define SCROLL_GO_ON 1
74 // for Bang()/Explode()
75 #define EX_PHASE_START 0
76 #define EX_TYPE_NONE 0
77 #define EX_TYPE_NORMAL (1 << 0)
78 #define EX_TYPE_CENTER (1 << 1)
79 #define EX_TYPE_BORDER (1 << 2)
80 #define EX_TYPE_CROSS (1 << 3)
81 #define EX_TYPE_DYNA (1 << 4)
82 #define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER)
84 #define PANEL_OFF() (game.panel.active == FALSE)
85 #define PANEL_DEACTIVATED(p) ((p)->x < 0 || (p)->y < 0 || PANEL_OFF())
86 #define PANEL_XPOS(p) (DX + ALIGNED_TEXT_XPOS(p))
87 #define PANEL_YPOS(p) (DY + ALIGNED_TEXT_YPOS(p))
89 // game panel display and control definitions
90 #define GAME_PANEL_LEVEL_NUMBER 0
91 #define GAME_PANEL_GEMS 1
92 #define GAME_PANEL_INVENTORY_COUNT 2
93 #define GAME_PANEL_INVENTORY_FIRST_1 3
94 #define GAME_PANEL_INVENTORY_FIRST_2 4
95 #define GAME_PANEL_INVENTORY_FIRST_3 5
96 #define GAME_PANEL_INVENTORY_FIRST_4 6
97 #define GAME_PANEL_INVENTORY_FIRST_5 7
98 #define GAME_PANEL_INVENTORY_FIRST_6 8
99 #define GAME_PANEL_INVENTORY_FIRST_7 9
100 #define GAME_PANEL_INVENTORY_FIRST_8 10
101 #define GAME_PANEL_INVENTORY_LAST_1 11
102 #define GAME_PANEL_INVENTORY_LAST_2 12
103 #define GAME_PANEL_INVENTORY_LAST_3 13
104 #define GAME_PANEL_INVENTORY_LAST_4 14
105 #define GAME_PANEL_INVENTORY_LAST_5 15
106 #define GAME_PANEL_INVENTORY_LAST_6 16
107 #define GAME_PANEL_INVENTORY_LAST_7 17
108 #define GAME_PANEL_INVENTORY_LAST_8 18
109 #define GAME_PANEL_KEY_1 19
110 #define GAME_PANEL_KEY_2 20
111 #define GAME_PANEL_KEY_3 21
112 #define GAME_PANEL_KEY_4 22
113 #define GAME_PANEL_KEY_5 23
114 #define GAME_PANEL_KEY_6 24
115 #define GAME_PANEL_KEY_7 25
116 #define GAME_PANEL_KEY_8 26
117 #define GAME_PANEL_KEY_WHITE 27
118 #define GAME_PANEL_KEY_WHITE_COUNT 28
119 #define GAME_PANEL_SCORE 29
120 #define GAME_PANEL_HIGHSCORE 30
121 #define GAME_PANEL_TIME 31
122 #define GAME_PANEL_TIME_HH 32
123 #define GAME_PANEL_TIME_MM 33
124 #define GAME_PANEL_TIME_SS 34
125 #define GAME_PANEL_TIME_ANIM 35
126 #define GAME_PANEL_HEALTH 36
127 #define GAME_PANEL_HEALTH_ANIM 37
128 #define GAME_PANEL_FRAME 38
129 #define GAME_PANEL_SHIELD_NORMAL 39
130 #define GAME_PANEL_SHIELD_NORMAL_TIME 40
131 #define GAME_PANEL_SHIELD_DEADLY 41
132 #define GAME_PANEL_SHIELD_DEADLY_TIME 42
133 #define GAME_PANEL_EXIT 43
134 #define GAME_PANEL_EMC_MAGIC_BALL 44
135 #define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 45
136 #define GAME_PANEL_LIGHT_SWITCH 46
137 #define GAME_PANEL_LIGHT_SWITCH_TIME 47
138 #define GAME_PANEL_TIMEGATE_SWITCH 48
139 #define GAME_PANEL_TIMEGATE_SWITCH_TIME 49
140 #define GAME_PANEL_SWITCHGATE_SWITCH 50
141 #define GAME_PANEL_EMC_LENSES 51
142 #define GAME_PANEL_EMC_LENSES_TIME 52
143 #define GAME_PANEL_EMC_MAGNIFIER 53
144 #define GAME_PANEL_EMC_MAGNIFIER_TIME 54
145 #define GAME_PANEL_BALLOON_SWITCH 55
146 #define GAME_PANEL_DYNABOMB_NUMBER 56
147 #define GAME_PANEL_DYNABOMB_SIZE 57
148 #define GAME_PANEL_DYNABOMB_POWER 58
149 #define GAME_PANEL_PENGUINS 59
150 #define GAME_PANEL_SOKOBAN_OBJECTS 60
151 #define GAME_PANEL_SOKOBAN_FIELDS 61
152 #define GAME_PANEL_ROBOT_WHEEL 62
153 #define GAME_PANEL_CONVEYOR_BELT_1 63
154 #define GAME_PANEL_CONVEYOR_BELT_2 64
155 #define GAME_PANEL_CONVEYOR_BELT_3 65
156 #define GAME_PANEL_CONVEYOR_BELT_4 66
157 #define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 67
158 #define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 68
159 #define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 69
160 #define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 70
161 #define GAME_PANEL_MAGIC_WALL 71
162 #define GAME_PANEL_MAGIC_WALL_TIME 72
163 #define GAME_PANEL_GRAVITY_STATE 73
164 #define GAME_PANEL_GRAPHIC_1 74
165 #define GAME_PANEL_GRAPHIC_2 75
166 #define GAME_PANEL_GRAPHIC_3 76
167 #define GAME_PANEL_GRAPHIC_4 77
168 #define GAME_PANEL_GRAPHIC_5 78
169 #define GAME_PANEL_GRAPHIC_6 79
170 #define GAME_PANEL_GRAPHIC_7 80
171 #define GAME_PANEL_GRAPHIC_8 81
172 #define GAME_PANEL_ELEMENT_1 82
173 #define GAME_PANEL_ELEMENT_2 83
174 #define GAME_PANEL_ELEMENT_3 84
175 #define GAME_PANEL_ELEMENT_4 85
176 #define GAME_PANEL_ELEMENT_5 86
177 #define GAME_PANEL_ELEMENT_6 87
178 #define GAME_PANEL_ELEMENT_7 88
179 #define GAME_PANEL_ELEMENT_8 89
180 #define GAME_PANEL_ELEMENT_COUNT_1 90
181 #define GAME_PANEL_ELEMENT_COUNT_2 91
182 #define GAME_PANEL_ELEMENT_COUNT_3 92
183 #define GAME_PANEL_ELEMENT_COUNT_4 93
184 #define GAME_PANEL_ELEMENT_COUNT_5 94
185 #define GAME_PANEL_ELEMENT_COUNT_6 95
186 #define GAME_PANEL_ELEMENT_COUNT_7 96
187 #define GAME_PANEL_ELEMENT_COUNT_8 97
188 #define GAME_PANEL_CE_SCORE_1 98
189 #define GAME_PANEL_CE_SCORE_2 99
190 #define GAME_PANEL_CE_SCORE_3 100
191 #define GAME_PANEL_CE_SCORE_4 101
192 #define GAME_PANEL_CE_SCORE_5 102
193 #define GAME_PANEL_CE_SCORE_6 103
194 #define GAME_PANEL_CE_SCORE_7 104
195 #define GAME_PANEL_CE_SCORE_8 105
196 #define GAME_PANEL_CE_SCORE_1_ELEMENT 106
197 #define GAME_PANEL_CE_SCORE_2_ELEMENT 107
198 #define GAME_PANEL_CE_SCORE_3_ELEMENT 108
199 #define GAME_PANEL_CE_SCORE_4_ELEMENT 109
200 #define GAME_PANEL_CE_SCORE_5_ELEMENT 110
201 #define GAME_PANEL_CE_SCORE_6_ELEMENT 111
202 #define GAME_PANEL_CE_SCORE_7_ELEMENT 112
203 #define GAME_PANEL_CE_SCORE_8_ELEMENT 113
204 #define GAME_PANEL_PLAYER_NAME 114
205 #define GAME_PANEL_LEVEL_NAME 115
206 #define GAME_PANEL_LEVEL_AUTHOR 116
208 #define NUM_GAME_PANEL_CONTROLS 117
210 struct GamePanelOrderInfo
216 static struct GamePanelOrderInfo game_panel_order[NUM_GAME_PANEL_CONTROLS];
218 struct GamePanelControlInfo
222 struct TextPosInfo *pos;
225 int graphic, graphic_active;
227 int value, last_value;
228 int frame, last_frame;
233 static struct GamePanelControlInfo game_panel_controls[] =
236 GAME_PANEL_LEVEL_NUMBER,
237 &game.panel.level_number,
246 GAME_PANEL_INVENTORY_COUNT,
247 &game.panel.inventory_count,
251 GAME_PANEL_INVENTORY_FIRST_1,
252 &game.panel.inventory_first[0],
256 GAME_PANEL_INVENTORY_FIRST_2,
257 &game.panel.inventory_first[1],
261 GAME_PANEL_INVENTORY_FIRST_3,
262 &game.panel.inventory_first[2],
266 GAME_PANEL_INVENTORY_FIRST_4,
267 &game.panel.inventory_first[3],
271 GAME_PANEL_INVENTORY_FIRST_5,
272 &game.panel.inventory_first[4],
276 GAME_PANEL_INVENTORY_FIRST_6,
277 &game.panel.inventory_first[5],
281 GAME_PANEL_INVENTORY_FIRST_7,
282 &game.panel.inventory_first[6],
286 GAME_PANEL_INVENTORY_FIRST_8,
287 &game.panel.inventory_first[7],
291 GAME_PANEL_INVENTORY_LAST_1,
292 &game.panel.inventory_last[0],
296 GAME_PANEL_INVENTORY_LAST_2,
297 &game.panel.inventory_last[1],
301 GAME_PANEL_INVENTORY_LAST_3,
302 &game.panel.inventory_last[2],
306 GAME_PANEL_INVENTORY_LAST_4,
307 &game.panel.inventory_last[3],
311 GAME_PANEL_INVENTORY_LAST_5,
312 &game.panel.inventory_last[4],
316 GAME_PANEL_INVENTORY_LAST_6,
317 &game.panel.inventory_last[5],
321 GAME_PANEL_INVENTORY_LAST_7,
322 &game.panel.inventory_last[6],
326 GAME_PANEL_INVENTORY_LAST_8,
327 &game.panel.inventory_last[7],
371 GAME_PANEL_KEY_WHITE,
372 &game.panel.key_white,
376 GAME_PANEL_KEY_WHITE_COUNT,
377 &game.panel.key_white_count,
386 GAME_PANEL_HIGHSCORE,
387 &game.panel.highscore,
411 GAME_PANEL_TIME_ANIM,
412 &game.panel.time_anim,
415 IMG_GFX_GAME_PANEL_TIME_ANIM,
416 IMG_GFX_GAME_PANEL_TIME_ANIM_ACTIVE
424 GAME_PANEL_HEALTH_ANIM,
425 &game.panel.health_anim,
428 IMG_GFX_GAME_PANEL_HEALTH_ANIM,
429 IMG_GFX_GAME_PANEL_HEALTH_ANIM_ACTIVE
437 GAME_PANEL_SHIELD_NORMAL,
438 &game.panel.shield_normal,
442 GAME_PANEL_SHIELD_NORMAL_TIME,
443 &game.panel.shield_normal_time,
447 GAME_PANEL_SHIELD_DEADLY,
448 &game.panel.shield_deadly,
452 GAME_PANEL_SHIELD_DEADLY_TIME,
453 &game.panel.shield_deadly_time,
462 GAME_PANEL_EMC_MAGIC_BALL,
463 &game.panel.emc_magic_ball,
467 GAME_PANEL_EMC_MAGIC_BALL_SWITCH,
468 &game.panel.emc_magic_ball_switch,
472 GAME_PANEL_LIGHT_SWITCH,
473 &game.panel.light_switch,
477 GAME_PANEL_LIGHT_SWITCH_TIME,
478 &game.panel.light_switch_time,
482 GAME_PANEL_TIMEGATE_SWITCH,
483 &game.panel.timegate_switch,
487 GAME_PANEL_TIMEGATE_SWITCH_TIME,
488 &game.panel.timegate_switch_time,
492 GAME_PANEL_SWITCHGATE_SWITCH,
493 &game.panel.switchgate_switch,
497 GAME_PANEL_EMC_LENSES,
498 &game.panel.emc_lenses,
502 GAME_PANEL_EMC_LENSES_TIME,
503 &game.panel.emc_lenses_time,
507 GAME_PANEL_EMC_MAGNIFIER,
508 &game.panel.emc_magnifier,
512 GAME_PANEL_EMC_MAGNIFIER_TIME,
513 &game.panel.emc_magnifier_time,
517 GAME_PANEL_BALLOON_SWITCH,
518 &game.panel.balloon_switch,
522 GAME_PANEL_DYNABOMB_NUMBER,
523 &game.panel.dynabomb_number,
527 GAME_PANEL_DYNABOMB_SIZE,
528 &game.panel.dynabomb_size,
532 GAME_PANEL_DYNABOMB_POWER,
533 &game.panel.dynabomb_power,
538 &game.panel.penguins,
542 GAME_PANEL_SOKOBAN_OBJECTS,
543 &game.panel.sokoban_objects,
547 GAME_PANEL_SOKOBAN_FIELDS,
548 &game.panel.sokoban_fields,
552 GAME_PANEL_ROBOT_WHEEL,
553 &game.panel.robot_wheel,
557 GAME_PANEL_CONVEYOR_BELT_1,
558 &game.panel.conveyor_belt[0],
562 GAME_PANEL_CONVEYOR_BELT_2,
563 &game.panel.conveyor_belt[1],
567 GAME_PANEL_CONVEYOR_BELT_3,
568 &game.panel.conveyor_belt[2],
572 GAME_PANEL_CONVEYOR_BELT_4,
573 &game.panel.conveyor_belt[3],
577 GAME_PANEL_CONVEYOR_BELT_1_SWITCH,
578 &game.panel.conveyor_belt_switch[0],
582 GAME_PANEL_CONVEYOR_BELT_2_SWITCH,
583 &game.panel.conveyor_belt_switch[1],
587 GAME_PANEL_CONVEYOR_BELT_3_SWITCH,
588 &game.panel.conveyor_belt_switch[2],
592 GAME_PANEL_CONVEYOR_BELT_4_SWITCH,
593 &game.panel.conveyor_belt_switch[3],
597 GAME_PANEL_MAGIC_WALL,
598 &game.panel.magic_wall,
602 GAME_PANEL_MAGIC_WALL_TIME,
603 &game.panel.magic_wall_time,
607 GAME_PANEL_GRAVITY_STATE,
608 &game.panel.gravity_state,
612 GAME_PANEL_GRAPHIC_1,
613 &game.panel.graphic[0],
617 GAME_PANEL_GRAPHIC_2,
618 &game.panel.graphic[1],
622 GAME_PANEL_GRAPHIC_3,
623 &game.panel.graphic[2],
627 GAME_PANEL_GRAPHIC_4,
628 &game.panel.graphic[3],
632 GAME_PANEL_GRAPHIC_5,
633 &game.panel.graphic[4],
637 GAME_PANEL_GRAPHIC_6,
638 &game.panel.graphic[5],
642 GAME_PANEL_GRAPHIC_7,
643 &game.panel.graphic[6],
647 GAME_PANEL_GRAPHIC_8,
648 &game.panel.graphic[7],
652 GAME_PANEL_ELEMENT_1,
653 &game.panel.element[0],
657 GAME_PANEL_ELEMENT_2,
658 &game.panel.element[1],
662 GAME_PANEL_ELEMENT_3,
663 &game.panel.element[2],
667 GAME_PANEL_ELEMENT_4,
668 &game.panel.element[3],
672 GAME_PANEL_ELEMENT_5,
673 &game.panel.element[4],
677 GAME_PANEL_ELEMENT_6,
678 &game.panel.element[5],
682 GAME_PANEL_ELEMENT_7,
683 &game.panel.element[6],
687 GAME_PANEL_ELEMENT_8,
688 &game.panel.element[7],
692 GAME_PANEL_ELEMENT_COUNT_1,
693 &game.panel.element_count[0],
697 GAME_PANEL_ELEMENT_COUNT_2,
698 &game.panel.element_count[1],
702 GAME_PANEL_ELEMENT_COUNT_3,
703 &game.panel.element_count[2],
707 GAME_PANEL_ELEMENT_COUNT_4,
708 &game.panel.element_count[3],
712 GAME_PANEL_ELEMENT_COUNT_5,
713 &game.panel.element_count[4],
717 GAME_PANEL_ELEMENT_COUNT_6,
718 &game.panel.element_count[5],
722 GAME_PANEL_ELEMENT_COUNT_7,
723 &game.panel.element_count[6],
727 GAME_PANEL_ELEMENT_COUNT_8,
728 &game.panel.element_count[7],
732 GAME_PANEL_CE_SCORE_1,
733 &game.panel.ce_score[0],
737 GAME_PANEL_CE_SCORE_2,
738 &game.panel.ce_score[1],
742 GAME_PANEL_CE_SCORE_3,
743 &game.panel.ce_score[2],
747 GAME_PANEL_CE_SCORE_4,
748 &game.panel.ce_score[3],
752 GAME_PANEL_CE_SCORE_5,
753 &game.panel.ce_score[4],
757 GAME_PANEL_CE_SCORE_6,
758 &game.panel.ce_score[5],
762 GAME_PANEL_CE_SCORE_7,
763 &game.panel.ce_score[6],
767 GAME_PANEL_CE_SCORE_8,
768 &game.panel.ce_score[7],
772 GAME_PANEL_CE_SCORE_1_ELEMENT,
773 &game.panel.ce_score_element[0],
777 GAME_PANEL_CE_SCORE_2_ELEMENT,
778 &game.panel.ce_score_element[1],
782 GAME_PANEL_CE_SCORE_3_ELEMENT,
783 &game.panel.ce_score_element[2],
787 GAME_PANEL_CE_SCORE_4_ELEMENT,
788 &game.panel.ce_score_element[3],
792 GAME_PANEL_CE_SCORE_5_ELEMENT,
793 &game.panel.ce_score_element[4],
797 GAME_PANEL_CE_SCORE_6_ELEMENT,
798 &game.panel.ce_score_element[5],
802 GAME_PANEL_CE_SCORE_7_ELEMENT,
803 &game.panel.ce_score_element[6],
807 GAME_PANEL_CE_SCORE_8_ELEMENT,
808 &game.panel.ce_score_element[7],
812 GAME_PANEL_PLAYER_NAME,
813 &game.panel.player_name,
817 GAME_PANEL_LEVEL_NAME,
818 &game.panel.level_name,
822 GAME_PANEL_LEVEL_AUTHOR,
823 &game.panel.level_author,
834 // values for delayed check of falling and moving elements and for collision
835 #define CHECK_DELAY_MOVING 3
836 #define CHECK_DELAY_FALLING CHECK_DELAY_MOVING
837 #define CHECK_DELAY_COLLISION 2
838 #define CHECK_DELAY_IMPACT CHECK_DELAY_COLLISION
840 // values for initial player move delay (initial delay counter value)
841 #define INITIAL_MOVE_DELAY_OFF -1
842 #define INITIAL_MOVE_DELAY_ON 0
844 // values for player movement speed (which is in fact a delay value)
845 #define MOVE_DELAY_MIN_SPEED 32
846 #define MOVE_DELAY_NORMAL_SPEED 8
847 #define MOVE_DELAY_HIGH_SPEED 4
848 #define MOVE_DELAY_MAX_SPEED 1
850 #define DOUBLE_MOVE_DELAY(x) (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x))
851 #define HALVE_MOVE_DELAY(x) (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x))
853 #define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY( (p)->move_delay_value))
854 #define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
856 // values for scroll positions
857 #define SCROLL_POSITION_X(x) ((x) < SBX_Left + MIDPOSX ? SBX_Left : \
858 (x) > SBX_Right + MIDPOSX ? SBX_Right :\
860 #define SCROLL_POSITION_Y(y) ((y) < SBY_Upper + MIDPOSY ? SBY_Upper :\
861 (y) > SBY_Lower + MIDPOSY ? SBY_Lower :\
864 // values for other actions
865 #define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED)
866 #define MOVE_STEPSIZE_MIN (1)
867 #define MOVE_STEPSIZE_MAX (TILEX)
869 #define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0)
870 #define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0)
872 #define INIT_GFX_RANDOM() (GetSimpleRandom(1000000))
874 #define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \
875 RND(element_info[e].push_delay_random))
876 #define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \
877 RND(element_info[e].drop_delay_random))
878 #define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
879 RND(element_info[e].move_delay_random))
880 #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
881 (element_info[e].move_delay_random))
882 #define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\
883 RND(element_info[e].ce_value_random_initial))
884 #define GET_CE_SCORE(e) ( (element_info[e].collect_score))
885 #define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \
886 RND((c)->delay_random * (c)->delay_frames))
887 #define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \
888 RND((c)->delay_random))
891 #define GET_VALID_RUNTIME_ELEMENT(e) \
892 ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e))
894 #define RESOLVED_REFERENCE_ELEMENT(be, e) \
895 ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \
896 (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \
897 (be) + (e) - EL_SELF)
899 #define GET_PLAYER_FROM_BITS(p) \
900 (EL_PLAYER_1 + ((p) != PLAYER_BITS_ANY ? log_2(p) : 0))
902 #define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \
903 ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \
904 (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
905 (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \
906 (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \
907 (e) == EL_CURRENT_CE_VALUE ? (cv) : \
908 (e) == EL_CURRENT_CE_SCORE ? (cs) : \
909 (e) >= EL_PREV_CE_8 && (e) <= EL_NEXT_CE_8 ? \
910 RESOLVED_REFERENCE_ELEMENT(be, e) : \
913 #define CAN_GROW_INTO(e) \
914 ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
916 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
917 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
920 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
921 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
922 (CAN_MOVE_INTO_ACID(e) && \
923 Tile[x][y] == EL_ACID) || \
926 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
927 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
928 (CAN_MOVE_INTO_ACID(e) && \
929 Tile[x][y] == EL_ACID) || \
932 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
933 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
935 (CAN_MOVE_INTO_ACID(e) && \
936 Tile[x][y] == EL_ACID) || \
937 (DONT_COLLIDE_WITH(e) && \
939 !PLAYER_ENEMY_PROTECTED(x, y))))
941 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
942 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
944 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
945 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
947 #define ANDROID_CAN_ENTER_FIELD(e, x, y) \
948 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Tile[x][y] == EL_EMC_PLANT)
950 #define ANDROID_CAN_CLONE_FIELD(x, y) \
951 (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Tile[x][y]) || \
952 CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT)))
954 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
955 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
957 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
958 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Tile[x][y] == EL_DIAMOND)
960 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
961 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Tile[x][y]))
963 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
964 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Tile[x][y]))
966 #define PIG_CAN_ENTER_FIELD(e, x, y) \
967 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Tile[x][y]))
969 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
970 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Tile[x][y] == EL_EXIT_OPEN || \
971 Tile[x][y] == EL_EM_EXIT_OPEN || \
972 Tile[x][y] == EL_STEEL_EXIT_OPEN || \
973 Tile[x][y] == EL_EM_STEEL_EXIT_OPEN || \
974 IS_FOOD_PENGUIN(Tile[x][y])))
975 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
976 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
978 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
979 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
981 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
982 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
984 #define SPRING_CAN_BUMP_FROM_FIELD(x, y) \
985 (IN_LEV_FIELD(x, y) && (Tile[x][y] == EL_EMC_SPRING_BUMPER || \
986 Tile[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
988 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
990 #define CE_ENTER_FIELD_COND(e, x, y) \
991 (!IS_PLAYER(x, y) && \
992 IS_EQUAL_OR_IN_GROUP(Tile[x][y], MOVE_ENTER_EL(e)))
994 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
995 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
997 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
998 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
1000 #define ACCESS_FROM(e, d) (element_info[e].access_direction &(d))
1001 #define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d))
1002 #define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d))
1003 #define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
1005 #define MM_HEALTH(x) (MIN(MAX(0, MAX_HEALTH - (x)), MAX_HEALTH))
1007 // game button identifiers
1008 #define GAME_CTRL_ID_STOP 0
1009 #define GAME_CTRL_ID_PAUSE 1
1010 #define GAME_CTRL_ID_PLAY 2
1011 #define GAME_CTRL_ID_UNDO 3
1012 #define GAME_CTRL_ID_REDO 4
1013 #define GAME_CTRL_ID_SAVE 5
1014 #define GAME_CTRL_ID_PAUSE2 6
1015 #define GAME_CTRL_ID_LOAD 7
1016 #define GAME_CTRL_ID_PANEL_STOP 8
1017 #define GAME_CTRL_ID_PANEL_PAUSE 9
1018 #define GAME_CTRL_ID_PANEL_PLAY 10
1019 #define GAME_CTRL_ID_TOUCH_STOP 11
1020 #define GAME_CTRL_ID_TOUCH_PAUSE 12
1021 #define SOUND_CTRL_ID_MUSIC 13
1022 #define SOUND_CTRL_ID_LOOPS 14
1023 #define SOUND_CTRL_ID_SIMPLE 15
1024 #define SOUND_CTRL_ID_PANEL_MUSIC 16
1025 #define SOUND_CTRL_ID_PANEL_LOOPS 17
1026 #define SOUND_CTRL_ID_PANEL_SIMPLE 18
1028 #define NUM_GAME_BUTTONS 19
1031 // forward declaration for internal use
1033 static void CreateField(int, int, int);
1035 static void ResetGfxAnimation(int, int);
1037 static void SetPlayerWaiting(struct PlayerInfo *, boolean);
1038 static void AdvanceFrameAndPlayerCounters(int);
1040 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
1041 static boolean MovePlayer(struct PlayerInfo *, int, int);
1042 static void ScrollPlayer(struct PlayerInfo *, int);
1043 static void ScrollScreen(struct PlayerInfo *, int);
1045 static int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
1046 static boolean DigFieldByCE(int, int, int);
1047 static boolean SnapField(struct PlayerInfo *, int, int);
1048 static boolean DropElement(struct PlayerInfo *);
1050 static void InitBeltMovement(void);
1051 static void CloseAllOpenTimegates(void);
1052 static void CheckGravityMovement(struct PlayerInfo *);
1053 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
1054 static void KillPlayerUnlessEnemyProtected(int, int);
1055 static void KillPlayerUnlessExplosionProtected(int, int);
1057 static void TestIfPlayerTouchesCustomElement(int, int);
1058 static void TestIfElementTouchesCustomElement(int, int);
1059 static void TestIfElementHitsCustomElement(int, int, int);
1061 static void HandleElementChange(int, int, int);
1062 static void ExecuteCustomElementAction(int, int, int, int);
1063 static boolean ChangeElement(int, int, int, int);
1065 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
1066 #define CheckTriggeredElementChange(x, y, e, ev) \
1067 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1)
1068 #define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \
1069 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
1070 #define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \
1071 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1072 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \
1073 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
1075 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
1076 #define CheckElementChange(x, y, e, te, ev) \
1077 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
1078 #define CheckElementChangeByPlayer(x, y, e, ev, p, s) \
1079 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
1080 #define CheckElementChangeBySide(x, y, e, te, ev, s) \
1081 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
1083 static void PlayLevelSound(int, int, int);
1084 static void PlayLevelSoundNearest(int, int, int);
1085 static void PlayLevelSoundAction(int, int, int);
1086 static void PlayLevelSoundElementAction(int, int, int, int);
1087 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
1088 static void PlayLevelSoundActionIfLoop(int, int, int);
1089 static void StopLevelSoundActionIfLoop(int, int, int);
1090 static void PlayLevelMusic(void);
1091 static void FadeLevelSoundsAndMusic(void);
1093 static void HandleGameButtons(struct GadgetInfo *);
1095 int AmoebaNeighbourNr(int, int);
1096 void AmoebaToDiamond(int, int);
1097 void ContinueMoving(int, int);
1098 void Bang(int, int);
1099 void InitMovDir(int, int);
1100 void InitAmoebaNr(int, int);
1101 int NewHiScore(int);
1103 void TestIfGoodThingHitsBadThing(int, int, int);
1104 void TestIfBadThingHitsGoodThing(int, int, int);
1105 void TestIfPlayerTouchesBadThing(int, int);
1106 void TestIfPlayerRunsIntoBadThing(int, int, int);
1107 void TestIfBadThingTouchesPlayer(int, int);
1108 void TestIfBadThingRunsIntoPlayer(int, int, int);
1109 void TestIfFriendTouchesBadThing(int, int);
1110 void TestIfBadThingTouchesFriend(int, int);
1111 void TestIfBadThingTouchesOtherBadThing(int, int);
1112 void TestIfGoodThingGetsHitByBadThing(int, int, int);
1114 void KillPlayer(struct PlayerInfo *);
1115 void BuryPlayer(struct PlayerInfo *);
1116 void RemovePlayer(struct PlayerInfo *);
1117 void ExitPlayer(struct PlayerInfo *);
1119 static int getInvisibleActiveFromInvisibleElement(int);
1120 static int getInvisibleFromInvisibleActiveElement(int);
1122 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
1124 // for detection of endless loops, caused by custom element programming
1125 // (using maximal playfield width x 10 is just a rough approximation)
1126 #define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10)
1128 #define RECURSION_LOOP_DETECTION_START(e, rc) \
1130 if (recursion_loop_detected) \
1133 if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \
1135 recursion_loop_detected = TRUE; \
1136 recursion_loop_element = (e); \
1139 recursion_loop_depth++; \
1142 #define RECURSION_LOOP_DETECTION_END() \
1144 recursion_loop_depth--; \
1147 static int recursion_loop_depth;
1148 static boolean recursion_loop_detected;
1149 static boolean recursion_loop_element;
1151 static int map_player_action[MAX_PLAYERS];
1154 // ----------------------------------------------------------------------------
1155 // definition of elements that automatically change to other elements after
1156 // a specified time, eventually calling a function when changing
1157 // ----------------------------------------------------------------------------
1159 // forward declaration for changer functions
1160 static void InitBuggyBase(int, int);
1161 static void WarnBuggyBase(int, int);
1163 static void InitTrap(int, int);
1164 static void ActivateTrap(int, int);
1165 static void ChangeActiveTrap(int, int);
1167 static void InitRobotWheel(int, int);
1168 static void RunRobotWheel(int, int);
1169 static void StopRobotWheel(int, int);
1171 static void InitTimegateWheel(int, int);
1172 static void RunTimegateWheel(int, int);
1174 static void InitMagicBallDelay(int, int);
1175 static void ActivateMagicBall(int, int);
1177 struct ChangingElementInfo
1182 void (*pre_change_function)(int x, int y);
1183 void (*change_function)(int x, int y);
1184 void (*post_change_function)(int x, int y);
1187 static struct ChangingElementInfo change_delay_list[] =
1222 EL_STEEL_EXIT_OPENING,
1230 EL_STEEL_EXIT_CLOSING,
1231 EL_STEEL_EXIT_CLOSED,
1254 EL_EM_STEEL_EXIT_OPENING,
1255 EL_EM_STEEL_EXIT_OPEN,
1262 EL_EM_STEEL_EXIT_CLOSING,
1286 EL_SWITCHGATE_OPENING,
1294 EL_SWITCHGATE_CLOSING,
1295 EL_SWITCHGATE_CLOSED,
1302 EL_TIMEGATE_OPENING,
1310 EL_TIMEGATE_CLOSING,
1319 EL_ACID_SPLASH_LEFT,
1327 EL_ACID_SPLASH_RIGHT,
1336 EL_SP_BUGGY_BASE_ACTIVATING,
1343 EL_SP_BUGGY_BASE_ACTIVATING,
1344 EL_SP_BUGGY_BASE_ACTIVE,
1351 EL_SP_BUGGY_BASE_ACTIVE,
1375 EL_ROBOT_WHEEL_ACTIVE,
1383 EL_TIMEGATE_SWITCH_ACTIVE,
1391 EL_DC_TIMEGATE_SWITCH_ACTIVE,
1392 EL_DC_TIMEGATE_SWITCH,
1399 EL_EMC_MAGIC_BALL_ACTIVE,
1400 EL_EMC_MAGIC_BALL_ACTIVE,
1407 EL_EMC_SPRING_BUMPER_ACTIVE,
1408 EL_EMC_SPRING_BUMPER,
1415 EL_DIAGONAL_SHRINKING,
1423 EL_DIAGONAL_GROWING,
1444 int push_delay_fixed, push_delay_random;
1448 { EL_SPRING, 0, 0 },
1449 { EL_BALLOON, 0, 0 },
1451 { EL_SOKOBAN_OBJECT, 2, 0 },
1452 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
1453 { EL_SATELLITE, 2, 0 },
1454 { EL_SP_DISK_YELLOW, 2, 0 },
1456 { EL_UNDEFINED, 0, 0 },
1464 move_stepsize_list[] =
1466 { EL_AMOEBA_DROP, 2 },
1467 { EL_AMOEBA_DROPPING, 2 },
1468 { EL_QUICKSAND_FILLING, 1 },
1469 { EL_QUICKSAND_EMPTYING, 1 },
1470 { EL_QUICKSAND_FAST_FILLING, 2 },
1471 { EL_QUICKSAND_FAST_EMPTYING, 2 },
1472 { EL_MAGIC_WALL_FILLING, 2 },
1473 { EL_MAGIC_WALL_EMPTYING, 2 },
1474 { EL_BD_MAGIC_WALL_FILLING, 2 },
1475 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
1476 { EL_DC_MAGIC_WALL_FILLING, 2 },
1477 { EL_DC_MAGIC_WALL_EMPTYING, 2 },
1479 { EL_UNDEFINED, 0 },
1487 collect_count_list[] =
1490 { EL_BD_DIAMOND, 1 },
1491 { EL_EMERALD_YELLOW, 1 },
1492 { EL_EMERALD_RED, 1 },
1493 { EL_EMERALD_PURPLE, 1 },
1495 { EL_SP_INFOTRON, 1 },
1499 { EL_UNDEFINED, 0 },
1507 access_direction_list[] =
1509 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1510 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
1511 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
1512 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
1513 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
1514 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
1515 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
1516 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
1517 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
1518 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
1519 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
1521 { EL_SP_PORT_LEFT, MV_RIGHT },
1522 { EL_SP_PORT_RIGHT, MV_LEFT },
1523 { EL_SP_PORT_UP, MV_DOWN },
1524 { EL_SP_PORT_DOWN, MV_UP },
1525 { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT },
1526 { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN },
1527 { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1528 { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT },
1529 { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT },
1530 { EL_SP_GRAVITY_PORT_UP, MV_DOWN },
1531 { EL_SP_GRAVITY_PORT_DOWN, MV_UP },
1532 { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT },
1533 { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT },
1534 { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN },
1535 { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP },
1536 { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT },
1537 { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT },
1538 { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN },
1539 { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP },
1541 { EL_UNDEFINED, MV_NONE }
1544 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
1546 #define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
1547 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
1548 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
1549 IS_JUST_CHANGING(x, y))
1551 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
1553 // static variables for playfield scan mode (scanning forward or backward)
1554 static int playfield_scan_start_x = 0;
1555 static int playfield_scan_start_y = 0;
1556 static int playfield_scan_delta_x = 1;
1557 static int playfield_scan_delta_y = 1;
1559 #define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \
1560 (y) >= 0 && (y) <= lev_fieldy - 1; \
1561 (y) += playfield_scan_delta_y) \
1562 for ((x) = playfield_scan_start_x; \
1563 (x) >= 0 && (x) <= lev_fieldx - 1; \
1564 (x) += playfield_scan_delta_x)
1567 void DEBUG_SetMaximumDynamite(void)
1571 for (i = 0; i < MAX_INVENTORY_SIZE; i++)
1572 if (local_player->inventory_size < MAX_INVENTORY_SIZE)
1573 local_player->inventory_element[local_player->inventory_size++] =
1578 static void InitPlayfieldScanModeVars(void)
1580 if (game.use_reverse_scan_direction)
1582 playfield_scan_start_x = lev_fieldx - 1;
1583 playfield_scan_start_y = lev_fieldy - 1;
1585 playfield_scan_delta_x = -1;
1586 playfield_scan_delta_y = -1;
1590 playfield_scan_start_x = 0;
1591 playfield_scan_start_y = 0;
1593 playfield_scan_delta_x = 1;
1594 playfield_scan_delta_y = 1;
1598 static void InitPlayfieldScanMode(int mode)
1600 game.use_reverse_scan_direction =
1601 (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE);
1603 InitPlayfieldScanModeVars();
1606 static int get_move_delay_from_stepsize(int move_stepsize)
1609 MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX);
1611 // make sure that stepsize value is always a power of 2
1612 move_stepsize = (1 << log_2(move_stepsize));
1614 return TILEX / move_stepsize;
1617 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
1620 int player_nr = player->index_nr;
1621 int move_delay = get_move_delay_from_stepsize(move_stepsize);
1622 boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
1624 // do no immediately change move delay -- the player might just be moving
1625 player->move_delay_value_next = move_delay;
1627 // information if player can move must be set separately
1628 player->cannot_move = cannot_move;
1632 player->move_delay = game.initial_move_delay[player_nr];
1633 player->move_delay_value = game.initial_move_delay_value[player_nr];
1635 player->move_delay_value_next = -1;
1637 player->move_delay_reset_counter = 0;
1641 void GetPlayerConfig(void)
1643 GameFrameDelay = setup.game_frame_delay;
1645 if (!audio.sound_available)
1646 setup.sound_simple = FALSE;
1648 if (!audio.loops_available)
1649 setup.sound_loops = FALSE;
1651 if (!audio.music_available)
1652 setup.sound_music = FALSE;
1654 if (!video.fullscreen_available)
1655 setup.fullscreen = FALSE;
1657 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
1659 SetAudioMode(setup.sound);
1662 int GetElementFromGroupElement(int element)
1664 if (IS_GROUP_ELEMENT(element))
1666 struct ElementGroupInfo *group = element_info[element].group;
1667 int last_anim_random_frame = gfx.anim_random_frame;
1670 if (group->choice_mode == ANIM_RANDOM)
1671 gfx.anim_random_frame = RND(group->num_elements_resolved);
1673 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
1674 group->choice_mode, 0,
1677 if (group->choice_mode == ANIM_RANDOM)
1678 gfx.anim_random_frame = last_anim_random_frame;
1680 group->choice_pos++;
1682 element = group->element_resolved[element_pos];
1688 static void IncrementSokobanFieldsNeeded(void)
1690 if (level.sb_fields_needed)
1691 game.sokoban_fields_still_needed++;
1694 static void IncrementSokobanObjectsNeeded(void)
1696 if (level.sb_objects_needed)
1697 game.sokoban_objects_still_needed++;
1700 static void DecrementSokobanFieldsNeeded(void)
1702 if (game.sokoban_fields_still_needed > 0)
1703 game.sokoban_fields_still_needed--;
1706 static void DecrementSokobanObjectsNeeded(void)
1708 if (game.sokoban_objects_still_needed > 0)
1709 game.sokoban_objects_still_needed--;
1712 static void InitPlayerField(int x, int y, int element, boolean init_game)
1714 if (element == EL_SP_MURPHY)
1718 if (stored_player[0].present)
1720 Tile[x][y] = EL_SP_MURPHY_CLONE;
1726 stored_player[0].initial_element = element;
1727 stored_player[0].use_murphy = TRUE;
1729 if (!level.use_artwork_element[0])
1730 stored_player[0].artwork_element = EL_SP_MURPHY;
1733 Tile[x][y] = EL_PLAYER_1;
1739 struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
1740 int jx = player->jx, jy = player->jy;
1742 player->present = TRUE;
1744 player->block_last_field = (element == EL_SP_MURPHY ?
1745 level.sp_block_last_field :
1746 level.block_last_field);
1748 // ---------- initialize player's last field block delay ------------------
1750 // always start with reliable default value (no adjustment needed)
1751 player->block_delay_adjustment = 0;
1753 // special case 1: in Supaplex, Murphy blocks last field one more frame
1754 if (player->block_last_field && element == EL_SP_MURPHY)
1755 player->block_delay_adjustment = 1;
1757 // special case 2: in game engines before 3.1.1, blocking was different
1758 if (game.use_block_last_field_bug)
1759 player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
1761 if (!network.enabled || player->connected_network)
1763 player->active = TRUE;
1765 // remove potentially duplicate players
1766 if (StorePlayer[jx][jy] == Tile[x][y])
1767 StorePlayer[jx][jy] = 0;
1769 StorePlayer[x][y] = Tile[x][y];
1771 #if DEBUG_INIT_PLAYER
1772 Debug("game:init:player", "- player element %d activated",
1773 player->element_nr);
1774 Debug("game:init:player", " (local player is %d and currently %s)",
1775 local_player->element_nr,
1776 local_player->active ? "active" : "not active");
1780 Tile[x][y] = EL_EMPTY;
1782 player->jx = player->last_jx = x;
1783 player->jy = player->last_jy = y;
1786 // always check if player was just killed and should be reanimated
1788 int player_nr = GET_PLAYER_NR(element);
1789 struct PlayerInfo *player = &stored_player[player_nr];
1791 if (player->active && player->killed)
1792 player->reanimated = TRUE; // if player was just killed, reanimate him
1796 static void InitField(int x, int y, boolean init_game)
1798 int element = Tile[x][y];
1807 InitPlayerField(x, y, element, init_game);
1810 case EL_SOKOBAN_FIELD_PLAYER:
1811 element = Tile[x][y] = EL_PLAYER_1;
1812 InitField(x, y, init_game);
1814 element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
1815 InitField(x, y, init_game);
1818 case EL_SOKOBAN_FIELD_EMPTY:
1819 IncrementSokobanFieldsNeeded();
1822 case EL_SOKOBAN_OBJECT:
1823 IncrementSokobanObjectsNeeded();
1827 if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
1828 Tile[x][y] = EL_ACID_POOL_TOPLEFT;
1829 else if (x > 0 && Tile[x-1][y] == EL_ACID)
1830 Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
1831 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
1832 Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
1833 else if (y > 0 && Tile[x][y-1] == EL_ACID)
1834 Tile[x][y] = EL_ACID_POOL_BOTTOM;
1835 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
1836 Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
1845 case EL_SPACESHIP_RIGHT:
1846 case EL_SPACESHIP_UP:
1847 case EL_SPACESHIP_LEFT:
1848 case EL_SPACESHIP_DOWN:
1849 case EL_BD_BUTTERFLY:
1850 case EL_BD_BUTTERFLY_RIGHT:
1851 case EL_BD_BUTTERFLY_UP:
1852 case EL_BD_BUTTERFLY_LEFT:
1853 case EL_BD_BUTTERFLY_DOWN:
1855 case EL_BD_FIREFLY_RIGHT:
1856 case EL_BD_FIREFLY_UP:
1857 case EL_BD_FIREFLY_LEFT:
1858 case EL_BD_FIREFLY_DOWN:
1859 case EL_PACMAN_RIGHT:
1861 case EL_PACMAN_LEFT:
1862 case EL_PACMAN_DOWN:
1864 case EL_YAMYAM_LEFT:
1865 case EL_YAMYAM_RIGHT:
1867 case EL_YAMYAM_DOWN:
1868 case EL_DARK_YAMYAM:
1871 case EL_SP_SNIKSNAK:
1872 case EL_SP_ELECTRON:
1878 case EL_SPRING_LEFT:
1879 case EL_SPRING_RIGHT:
1883 case EL_AMOEBA_FULL:
1888 case EL_AMOEBA_DROP:
1889 if (y == lev_fieldy - 1)
1891 Tile[x][y] = EL_AMOEBA_GROWING;
1892 Store[x][y] = EL_AMOEBA_WET;
1896 case EL_DYNAMITE_ACTIVE:
1897 case EL_SP_DISK_RED_ACTIVE:
1898 case EL_DYNABOMB_PLAYER_1_ACTIVE:
1899 case EL_DYNABOMB_PLAYER_2_ACTIVE:
1900 case EL_DYNABOMB_PLAYER_3_ACTIVE:
1901 case EL_DYNABOMB_PLAYER_4_ACTIVE:
1902 MovDelay[x][y] = 96;
1905 case EL_EM_DYNAMITE_ACTIVE:
1906 MovDelay[x][y] = 32;
1910 game.lights_still_needed++;
1914 game.friends_still_needed++;
1919 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
1922 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
1923 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
1924 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
1925 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
1926 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
1927 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
1928 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
1929 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
1930 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
1931 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
1932 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
1933 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
1936 int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
1937 int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
1938 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
1940 if (game.belt_dir_nr[belt_nr] == 3) // initial value
1942 game.belt_dir[belt_nr] = belt_dir;
1943 game.belt_dir_nr[belt_nr] = belt_dir_nr;
1945 else // more than one switch -- set it like the first switch
1947 Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
1952 case EL_LIGHT_SWITCH_ACTIVE:
1954 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
1957 case EL_INVISIBLE_STEELWALL:
1958 case EL_INVISIBLE_WALL:
1959 case EL_INVISIBLE_SAND:
1960 if (game.light_time_left > 0 ||
1961 game.lenses_time_left > 0)
1962 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
1965 case EL_EMC_MAGIC_BALL:
1966 if (game.ball_active)
1967 Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
1970 case EL_EMC_MAGIC_BALL_SWITCH:
1971 if (game.ball_active)
1972 Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
1975 case EL_TRIGGER_PLAYER:
1976 case EL_TRIGGER_ELEMENT:
1977 case EL_TRIGGER_CE_VALUE:
1978 case EL_TRIGGER_CE_SCORE:
1980 case EL_ANY_ELEMENT:
1981 case EL_CURRENT_CE_VALUE:
1982 case EL_CURRENT_CE_SCORE:
1999 // reference elements should not be used on the playfield
2000 Tile[x][y] = EL_EMPTY;
2004 if (IS_CUSTOM_ELEMENT(element))
2006 if (CAN_MOVE(element))
2009 if (!element_info[element].use_last_ce_value || init_game)
2010 CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
2012 else if (IS_GROUP_ELEMENT(element))
2014 Tile[x][y] = GetElementFromGroupElement(element);
2016 InitField(x, y, init_game);
2023 CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
2026 static void InitField_WithBug1(int x, int y, boolean init_game)
2028 InitField(x, y, init_game);
2030 // not needed to call InitMovDir() -- already done by InitField()!
2031 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2032 CAN_MOVE(Tile[x][y]))
2036 static void InitField_WithBug2(int x, int y, boolean init_game)
2038 int old_element = Tile[x][y];
2040 InitField(x, y, init_game);
2042 // not needed to call InitMovDir() -- already done by InitField()!
2043 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2044 CAN_MOVE(old_element) &&
2045 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
2048 /* this case is in fact a combination of not less than three bugs:
2049 first, it calls InitMovDir() for elements that can move, although this is
2050 already done by InitField(); then, it checks the element that was at this
2051 field _before_ the call to InitField() (which can change it); lastly, it
2052 was not called for "mole with direction" elements, which were treated as
2053 "cannot move" due to (fixed) wrong element initialization in "src/init.c"
2057 static int get_key_element_from_nr(int key_nr)
2059 int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS :
2060 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2061 EL_EM_KEY_1 : EL_KEY_1);
2063 return key_base_element + key_nr;
2066 static int get_next_dropped_element(struct PlayerInfo *player)
2068 return (player->inventory_size > 0 ?
2069 player->inventory_element[player->inventory_size - 1] :
2070 player->inventory_infinite_element != EL_UNDEFINED ?
2071 player->inventory_infinite_element :
2072 player->dynabombs_left > 0 ?
2073 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
2077 static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos)
2079 // pos >= 0: get element from bottom of the stack;
2080 // pos < 0: get element from top of the stack
2084 int min_inventory_size = -pos;
2085 int inventory_pos = player->inventory_size - min_inventory_size;
2086 int min_dynabombs_left = min_inventory_size - player->inventory_size;
2088 return (player->inventory_size >= min_inventory_size ?
2089 player->inventory_element[inventory_pos] :
2090 player->inventory_infinite_element != EL_UNDEFINED ?
2091 player->inventory_infinite_element :
2092 player->dynabombs_left >= min_dynabombs_left ?
2093 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2098 int min_dynabombs_left = pos + 1;
2099 int min_inventory_size = pos + 1 - player->dynabombs_left;
2100 int inventory_pos = pos - player->dynabombs_left;
2102 return (player->inventory_infinite_element != EL_UNDEFINED ?
2103 player->inventory_infinite_element :
2104 player->dynabombs_left >= min_dynabombs_left ?
2105 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2106 player->inventory_size >= min_inventory_size ?
2107 player->inventory_element[inventory_pos] :
2112 static int compareGamePanelOrderInfo(const void *object1, const void *object2)
2114 const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1;
2115 const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2;
2118 if (gpo1->sort_priority != gpo2->sort_priority)
2119 compare_result = gpo1->sort_priority - gpo2->sort_priority;
2121 compare_result = gpo1->nr - gpo2->nr;
2123 return compare_result;
2126 int getPlayerInventorySize(int player_nr)
2128 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2129 return game_em.ply[player_nr]->dynamite;
2130 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
2131 return game_sp.red_disk_count;
2133 return stored_player[player_nr].inventory_size;
2136 static void InitGameControlValues(void)
2140 for (i = 0; game_panel_controls[i].nr != -1; i++)
2142 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2143 struct GamePanelOrderInfo *gpo = &game_panel_order[i];
2144 struct TextPosInfo *pos = gpc->pos;
2146 int type = gpc->type;
2150 Error("'game_panel_controls' structure corrupted at %d", i);
2152 Fail("this should not happen -- please debug");
2155 // force update of game controls after initialization
2156 gpc->value = gpc->last_value = -1;
2157 gpc->frame = gpc->last_frame = -1;
2158 gpc->gfx_frame = -1;
2160 // determine panel value width for later calculation of alignment
2161 if (type == TYPE_INTEGER || type == TYPE_STRING)
2163 pos->width = pos->size * getFontWidth(pos->font);
2164 pos->height = getFontHeight(pos->font);
2166 else if (type == TYPE_ELEMENT)
2168 pos->width = pos->size;
2169 pos->height = pos->size;
2172 // fill structure for game panel draw order
2174 gpo->sort_priority = pos->sort_priority;
2177 // sort game panel controls according to sort_priority and control number
2178 qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS,
2179 sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
2182 static void UpdatePlayfieldElementCount(void)
2184 boolean use_element_count = FALSE;
2187 // first check if it is needed at all to calculate playfield element count
2188 for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++)
2189 if (!PANEL_DEACTIVATED(game_panel_controls[i].pos))
2190 use_element_count = TRUE;
2192 if (!use_element_count)
2195 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
2196 element_info[i].element_count = 0;
2198 SCAN_PLAYFIELD(x, y)
2200 element_info[Tile[x][y]].element_count++;
2203 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2204 for (j = 0; j < MAX_NUM_ELEMENTS; j++)
2205 if (IS_IN_GROUP(j, i))
2206 element_info[EL_GROUP_START + i].element_count +=
2207 element_info[j].element_count;
2210 static void UpdateGameControlValues(void)
2213 int time = (game.LevelSolved ?
2214 game.LevelSolved_CountingTime :
2215 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2217 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2218 game_sp.time_played :
2219 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2220 game_mm.energy_left :
2221 game.no_time_limit ? TimePlayed : TimeLeft);
2222 int score = (game.LevelSolved ?
2223 game.LevelSolved_CountingScore :
2224 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2225 game_em.lev->score :
2226 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2228 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2231 int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2232 game_em.lev->gems_needed :
2233 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2234 game_sp.infotrons_still_needed :
2235 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2236 game_mm.kettles_still_needed :
2237 game.gems_still_needed);
2238 int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2239 game_em.lev->gems_needed > 0 :
2240 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2241 game_sp.infotrons_still_needed > 0 :
2242 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2243 game_mm.kettles_still_needed > 0 ||
2244 game_mm.lights_still_needed > 0 :
2245 game.gems_still_needed > 0 ||
2246 game.sokoban_fields_still_needed > 0 ||
2247 game.sokoban_objects_still_needed > 0 ||
2248 game.lights_still_needed > 0);
2249 int health = (game.LevelSolved ?
2250 game.LevelSolved_CountingHealth :
2251 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2252 MM_HEALTH(game_mm.laser_overload_value) :
2254 int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
2256 UpdatePlayfieldElementCount();
2258 // update game panel control values
2260 // used instead of "level_nr" (for network games)
2261 game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
2262 game_panel_controls[GAME_PANEL_GEMS].value = gems;
2264 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
2265 for (i = 0; i < MAX_NUM_KEYS; i++)
2266 game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY;
2267 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY;
2268 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0;
2270 if (game.centered_player_nr == -1)
2272 for (i = 0; i < MAX_PLAYERS; i++)
2274 // only one player in Supaplex game engine
2275 if (level.game_engine_type == GAME_ENGINE_TYPE_SP && i > 0)
2278 for (k = 0; k < MAX_NUM_KEYS; k++)
2280 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2282 if (game_em.ply[i]->keys & (1 << k))
2283 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2284 get_key_element_from_nr(k);
2286 else if (stored_player[i].key[k])
2287 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2288 get_key_element_from_nr(k);
2291 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2292 getPlayerInventorySize(i);
2294 if (stored_player[i].num_white_keys > 0)
2295 game_panel_controls[GAME_PANEL_KEY_WHITE].value =
2298 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2299 stored_player[i].num_white_keys;
2304 int player_nr = game.centered_player_nr;
2306 for (k = 0; k < MAX_NUM_KEYS; k++)
2308 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2310 if (game_em.ply[player_nr]->keys & (1 << k))
2311 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2312 get_key_element_from_nr(k);
2314 else if (stored_player[player_nr].key[k])
2315 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2316 get_key_element_from_nr(k);
2319 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2320 getPlayerInventorySize(player_nr);
2322 if (stored_player[player_nr].num_white_keys > 0)
2323 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
2325 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2326 stored_player[player_nr].num_white_keys;
2329 // re-arrange keys on game panel, if needed or if defined by style settings
2330 for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
2332 int nr = GAME_PANEL_KEY_1 + i;
2333 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2334 struct TextPosInfo *pos = gpc->pos;
2336 // skip check if key is not in the player's inventory
2337 if (gpc->value == EL_EMPTY)
2340 // check if keys should be arranged on panel from left to right
2341 if (pos->style == STYLE_LEFTMOST_POSITION)
2343 // check previous key positions (left from current key)
2344 for (k = 0; k < i; k++)
2346 int nr_new = GAME_PANEL_KEY_1 + k;
2348 if (game_panel_controls[nr_new].value == EL_EMPTY)
2350 game_panel_controls[nr_new].value = gpc->value;
2351 gpc->value = EL_EMPTY;
2358 // check if "undefined" keys can be placed at some other position
2359 if (pos->x == -1 && pos->y == -1)
2361 int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
2363 // 1st try: display key at the same position as normal or EM keys
2364 if (game_panel_controls[nr_new].value == EL_EMPTY)
2366 game_panel_controls[nr_new].value = gpc->value;
2370 // 2nd try: display key at the next free position in the key panel
2371 for (k = 0; k < STD_NUM_KEYS; k++)
2373 nr_new = GAME_PANEL_KEY_1 + k;
2375 if (game_panel_controls[nr_new].value == EL_EMPTY)
2377 game_panel_controls[nr_new].value = gpc->value;
2386 for (i = 0; i < NUM_PANEL_INVENTORY; i++)
2388 game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
2389 get_inventory_element_from_pos(local_player, i);
2390 game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value =
2391 get_inventory_element_from_pos(local_player, -i - 1);
2394 game_panel_controls[GAME_PANEL_SCORE].value = score;
2395 game_panel_controls[GAME_PANEL_HIGHSCORE].value = highscore[0].Score;
2397 game_panel_controls[GAME_PANEL_TIME].value = time;
2399 game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600;
2400 game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
2401 game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
2403 if (level.time == 0)
2404 game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
2406 game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
2408 game_panel_controls[GAME_PANEL_HEALTH].value = health;
2409 game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
2411 game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
2413 game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
2414 (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE :
2416 game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value =
2417 local_player->shield_normal_time_left;
2418 game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value =
2419 (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE :
2421 game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value =
2422 local_player->shield_deadly_time_left;
2424 game_panel_controls[GAME_PANEL_EXIT].value =
2425 (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
2427 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
2428 (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
2429 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
2430 (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
2431 EL_EMC_MAGIC_BALL_SWITCH);
2433 game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
2434 (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH);
2435 game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value =
2436 game.light_time_left;
2438 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value =
2439 (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED);
2440 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value =
2441 game.timegate_time_left;
2443 game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value =
2444 EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2446 game_panel_controls[GAME_PANEL_EMC_LENSES].value =
2447 (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY);
2448 game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value =
2449 game.lenses_time_left;
2451 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value =
2452 (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY);
2453 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value =
2454 game.magnify_time_left;
2456 game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value =
2457 (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT :
2458 game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT :
2459 game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP :
2460 game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN :
2461 EL_BALLOON_SWITCH_NONE);
2463 game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value =
2464 local_player->dynabomb_count;
2465 game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value =
2466 local_player->dynabomb_size;
2467 game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value =
2468 (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
2470 game_panel_controls[GAME_PANEL_PENGUINS].value =
2471 game.friends_still_needed;
2473 game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
2474 game.sokoban_objects_still_needed;
2475 game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
2476 game.sokoban_fields_still_needed;
2478 game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
2479 (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
2481 for (i = 0; i < NUM_BELTS; i++)
2483 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value =
2484 (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE :
2485 EL_CONVEYOR_BELT_1_MIDDLE) + i;
2486 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value =
2487 getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]);
2490 game_panel_controls[GAME_PANEL_MAGIC_WALL].value =
2491 (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL);
2492 game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value =
2493 game.magic_wall_time_left;
2495 game_panel_controls[GAME_PANEL_GRAVITY_STATE].value =
2496 local_player->gravity;
2498 for (i = 0; i < NUM_PANEL_GRAPHICS; i++)
2499 game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i;
2501 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2502 game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value =
2503 (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ?
2504 game.panel.element[i].id : EL_UNDEFINED);
2506 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2507 game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value =
2508 (IS_VALID_ELEMENT(game.panel.element_count[i].id) ?
2509 element_info[game.panel.element_count[i].id].element_count : 0);
2511 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2512 game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value =
2513 (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ?
2514 element_info[game.panel.ce_score[i].id].collect_score : 0);
2516 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2517 game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value =
2518 (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ?
2519 element_info[game.panel.ce_score_element[i].id].collect_score :
2522 game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0;
2523 game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0;
2524 game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0;
2526 // update game panel control frames
2528 for (i = 0; game_panel_controls[i].nr != -1; i++)
2530 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2532 if (gpc->type == TYPE_ELEMENT)
2534 if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY)
2536 int last_anim_random_frame = gfx.anim_random_frame;
2537 int element = gpc->value;
2538 int graphic = el2panelimg(element);
2539 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2540 sync_random_frame : INIT_GFX_RANDOM());
2542 if (gpc->value != gpc->last_value)
2545 gpc->gfx_random = init_gfx_random;
2551 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2552 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2553 gpc->gfx_random = init_gfx_random;
2556 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2557 gfx.anim_random_frame = gpc->gfx_random;
2559 if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
2560 gpc->gfx_frame = element_info[element].collect_score;
2562 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2564 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2565 gfx.anim_random_frame = last_anim_random_frame;
2568 else if (gpc->type == TYPE_GRAPHIC)
2570 if (gpc->graphic != IMG_UNDEFINED)
2572 int last_anim_random_frame = gfx.anim_random_frame;
2573 int graphic = gpc->graphic;
2574 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2575 sync_random_frame : INIT_GFX_RANDOM());
2577 if (gpc->value != gpc->last_value)
2580 gpc->gfx_random = init_gfx_random;
2586 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2587 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2588 gpc->gfx_random = init_gfx_random;
2591 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2592 gfx.anim_random_frame = gpc->gfx_random;
2594 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2596 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2597 gfx.anim_random_frame = last_anim_random_frame;
2603 static void DisplayGameControlValues(void)
2605 boolean redraw_panel = FALSE;
2608 for (i = 0; game_panel_controls[i].nr != -1; i++)
2610 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2612 if (PANEL_DEACTIVATED(gpc->pos))
2615 if (gpc->value == gpc->last_value &&
2616 gpc->frame == gpc->last_frame)
2619 redraw_panel = TRUE;
2625 // copy default game door content to main double buffer
2627 // !!! CHECK AGAIN !!!
2628 SetPanelBackground();
2629 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
2630 DrawBackground(DX, DY, DXSIZE, DYSIZE);
2632 // redraw game control buttons
2633 RedrawGameButtons();
2635 SetGameStatus(GAME_MODE_PSEUDO_PANEL);
2637 for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++)
2639 int nr = game_panel_order[i].nr;
2640 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2641 struct TextPosInfo *pos = gpc->pos;
2642 int type = gpc->type;
2643 int value = gpc->value;
2644 int frame = gpc->frame;
2645 int size = pos->size;
2646 int font = pos->font;
2647 boolean draw_masked = pos->draw_masked;
2648 int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE);
2650 if (PANEL_DEACTIVATED(pos))
2653 if (pos->class == get_hash_from_key("extra_panel_items") &&
2654 !setup.prefer_extra_panel_items)
2657 gpc->last_value = value;
2658 gpc->last_frame = frame;
2660 if (type == TYPE_INTEGER)
2662 if (nr == GAME_PANEL_LEVEL_NUMBER ||
2663 nr == GAME_PANEL_TIME)
2665 boolean use_dynamic_size = (size == -1 ? TRUE : FALSE);
2667 if (use_dynamic_size) // use dynamic number of digits
2669 int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000);
2670 int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3);
2671 int size2 = size1 + 1;
2672 int font1 = pos->font;
2673 int font2 = pos->font_alt;
2675 size = (value < value_change ? size1 : size2);
2676 font = (value < value_change ? font1 : font2);
2680 // correct text size if "digits" is zero or less
2682 size = strlen(int2str(value, size));
2684 // dynamically correct text alignment
2685 pos->width = size * getFontWidth(font);
2687 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2688 int2str(value, size), font, mask_mode);
2690 else if (type == TYPE_ELEMENT)
2692 int element, graphic;
2696 int dst_x = PANEL_XPOS(pos);
2697 int dst_y = PANEL_YPOS(pos);
2699 if (value != EL_UNDEFINED && value != EL_EMPTY)
2702 graphic = el2panelimg(value);
2705 Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
2706 element, EL_NAME(element), size);
2709 if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
2712 getSizedGraphicSource(graphic, frame, size, &src_bitmap,
2715 width = graphic_info[graphic].width * size / TILESIZE;
2716 height = graphic_info[graphic].height * size / TILESIZE;
2719 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2722 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2726 else if (type == TYPE_GRAPHIC)
2728 int graphic = gpc->graphic;
2729 int graphic_active = gpc->graphic_active;
2733 int dst_x = PANEL_XPOS(pos);
2734 int dst_y = PANEL_YPOS(pos);
2735 boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
2736 level.game_engine_type != GAME_ENGINE_TYPE_MM);
2738 if (graphic != IMG_UNDEFINED && !skip)
2740 if (pos->style == STYLE_REVERSE)
2741 value = 100 - value;
2743 getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
2745 if (pos->direction & MV_HORIZONTAL)
2747 width = graphic_info[graphic_active].width * value / 100;
2748 height = graphic_info[graphic_active].height;
2750 if (pos->direction == MV_LEFT)
2752 src_x += graphic_info[graphic_active].width - width;
2753 dst_x += graphic_info[graphic_active].width - width;
2758 width = graphic_info[graphic_active].width;
2759 height = graphic_info[graphic_active].height * value / 100;
2761 if (pos->direction == MV_UP)
2763 src_y += graphic_info[graphic_active].height - height;
2764 dst_y += graphic_info[graphic_active].height - height;
2769 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2772 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2775 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2777 if (pos->direction & MV_HORIZONTAL)
2779 if (pos->direction == MV_RIGHT)
2786 dst_x = PANEL_XPOS(pos);
2789 width = graphic_info[graphic].width - width;
2793 if (pos->direction == MV_DOWN)
2800 dst_y = PANEL_YPOS(pos);
2803 height = graphic_info[graphic].height - height;
2807 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2810 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2814 else if (type == TYPE_STRING)
2816 boolean active = (value != 0);
2817 char *state_normal = "off";
2818 char *state_active = "on";
2819 char *state = (active ? state_active : state_normal);
2820 char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state :
2821 nr == GAME_PANEL_PLAYER_NAME ? setup.player_name :
2822 nr == GAME_PANEL_LEVEL_NAME ? level.name :
2823 nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL);
2825 if (nr == GAME_PANEL_GRAVITY_STATE)
2827 int font1 = pos->font; // (used for normal state)
2828 int font2 = pos->font_alt; // (used for active state)
2830 font = (active ? font2 : font1);
2839 // don't truncate output if "chars" is zero or less
2842 // dynamically correct text alignment
2843 pos->width = size * getFontWidth(font);
2846 s_cut = getStringCopyN(s, size);
2848 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2849 s_cut, font, mask_mode);
2855 redraw_mask |= REDRAW_DOOR_1;
2858 SetGameStatus(GAME_MODE_PLAYING);
2861 void UpdateAndDisplayGameControlValues(void)
2863 if (tape.deactivate_display)
2866 UpdateGameControlValues();
2867 DisplayGameControlValues();
2871 static void UpdateGameDoorValues(void)
2873 UpdateGameControlValues();
2877 void DrawGameDoorValues(void)
2879 DisplayGameControlValues();
2883 // ============================================================================
2885 // ----------------------------------------------------------------------------
2886 // initialize game engine due to level / tape version number
2887 // ============================================================================
2889 static void InitGameEngine(void)
2891 int i, j, k, l, x, y;
2893 // set game engine from tape file when re-playing, else from level file
2894 game.engine_version = (tape.playing ? tape.engine_version :
2895 level.game_version);
2897 // set single or multi-player game mode (needed for re-playing tapes)
2898 game.team_mode = setup.team_mode;
2902 int num_players = 0;
2904 for (i = 0; i < MAX_PLAYERS; i++)
2905 if (tape.player_participates[i])
2908 // multi-player tapes contain input data for more than one player
2909 game.team_mode = (num_players > 1);
2913 Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
2914 level.game_version);
2915 Debug("game:init:level", " tape.file_version == %06d",
2917 Debug("game:init:level", " tape.game_version == %06d",
2919 Debug("game:init:level", " tape.engine_version == %06d",
2920 tape.engine_version);
2921 Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
2922 game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
2925 // --------------------------------------------------------------------------
2926 // set flags for bugs and changes according to active game engine version
2927 // --------------------------------------------------------------------------
2931 Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
2933 Bug was introduced in version:
2936 Bug was fixed in version:
2940 In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
2941 but the property "can fall" was missing, which caused some levels to be
2942 unsolvable. This was fixed in version 4.2.0.0.
2944 Affected levels/tapes:
2945 An example for a tape that was fixed by this bugfix is tape 029 from the
2946 level set "rnd_sam_bateman".
2947 The wrong behaviour will still be used for all levels or tapes that were
2948 created/recorded with it. An example for this is tape 023 from the level
2949 set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
2952 boolean use_amoeba_dropping_cannot_fall_bug =
2953 ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
2954 game.engine_version < VERSION_IDENT(4,2,0,0)) ||
2956 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2957 tape.game_version < VERSION_IDENT(4,2,0,0)));
2960 Summary of bugfix/change:
2961 Fixed move speed of elements entering or leaving magic wall.
2963 Fixed/changed in version:
2967 Before 2.0.1, move speed of elements entering or leaving magic wall was
2968 twice as fast as it is now.
2969 Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
2971 Affected levels/tapes:
2972 The first condition is generally needed for all levels/tapes before version
2973 2.0.1, which might use the old behaviour before it was changed; known tapes
2974 that are affected: Tape 014 from the level set "rnd_conor_mancone".
2975 The second condition is an exception from the above case and is needed for
2976 the special case of tapes recorded with game (not engine!) version 2.0.1 or
2977 above, but before it was known that this change would break tapes like the
2978 above and was fixed in 4.2.0.0, so that the changed behaviour was active
2979 although the engine version while recording maybe was before 2.0.1. There
2980 are a lot of tapes that are affected by this exception, like tape 006 from
2981 the level set "rnd_conor_mancone".
2984 boolean use_old_move_stepsize_for_magic_wall =
2985 (game.engine_version < VERSION_IDENT(2,0,1,0) &&
2987 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2988 tape.game_version < VERSION_IDENT(4,2,0,0)));
2991 Summary of bugfix/change:
2992 Fixed handling for custom elements that change when pushed by the player.
2994 Fixed/changed in version:
2998 Before 3.1.0, custom elements that "change when pushing" changed directly
2999 after the player started pushing them (until then handled in "DigField()").
3000 Since 3.1.0, these custom elements are not changed until the "pushing"
3001 move of the element is finished (now handled in "ContinueMoving()").
3003 Affected levels/tapes:
3004 The first condition is generally needed for all levels/tapes before version
3005 3.1.0, which might use the old behaviour before it was changed; known tapes
3006 that are affected are some tapes from the level set "Walpurgis Gardens" by
3008 The second condition is an exception from the above case and is needed for
3009 the special case of tapes recorded with game (not engine!) version 3.1.0 or
3010 above (including some development versions of 3.1.0), but before it was
3011 known that this change would break tapes like the above and was fixed in
3012 3.1.1, so that the changed behaviour was active although the engine version
3013 while recording maybe was before 3.1.0. There is at least one tape that is
3014 affected by this exception, which is the tape for the one-level set "Bug
3015 Machine" by Juergen Bonhagen.
3018 game.use_change_when_pushing_bug =
3019 (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3021 tape.game_version >= VERSION_IDENT(3,1,0,0) &&
3022 tape.game_version < VERSION_IDENT(3,1,1,0)));
3025 Summary of bugfix/change:
3026 Fixed handling for blocking the field the player leaves when moving.
3028 Fixed/changed in version:
3032 Before 3.1.1, when "block last field when moving" was enabled, the field
3033 the player is leaving when moving was blocked for the time of the move,
3034 and was directly unblocked afterwards. This resulted in the last field
3035 being blocked for exactly one less than the number of frames of one player
3036 move. Additionally, even when blocking was disabled, the last field was
3037 blocked for exactly one frame.
3038 Since 3.1.1, due to changes in player movement handling, the last field
3039 is not blocked at all when blocking is disabled. When blocking is enabled,
3040 the last field is blocked for exactly the number of frames of one player
3041 move. Additionally, if the player is Murphy, the hero of Supaplex, the
3042 last field is blocked for exactly one more than the number of frames of
3045 Affected levels/tapes:
3046 (!!! yet to be determined -- probably many !!!)
3049 game.use_block_last_field_bug =
3050 (game.engine_version < VERSION_IDENT(3,1,1,0));
3052 /* various special flags and settings for native Emerald Mine game engine */
3054 game_em.use_single_button =
3055 (game.engine_version > VERSION_IDENT(4,0,0,2));
3057 game_em.use_snap_key_bug =
3058 (game.engine_version < VERSION_IDENT(4,0,1,0));
3060 game_em.use_random_bug =
3061 (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
3063 boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
3065 game_em.use_old_explosions = use_old_em_engine;
3066 game_em.use_old_android = use_old_em_engine;
3067 game_em.use_old_push_elements = use_old_em_engine;
3068 game_em.use_old_push_into_acid = use_old_em_engine;
3070 game_em.use_wrap_around = !use_old_em_engine;
3072 // --------------------------------------------------------------------------
3074 // set maximal allowed number of custom element changes per game frame
3075 game.max_num_changes_per_frame = 1;
3077 // default scan direction: scan playfield from top/left to bottom/right
3078 InitPlayfieldScanMode(CA_ARG_SCAN_MODE_NORMAL);
3080 // dynamically adjust element properties according to game engine version
3081 InitElementPropertiesEngine(game.engine_version);
3083 // ---------- initialize special element properties -------------------------
3085 // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
3086 if (use_amoeba_dropping_cannot_fall_bug)
3087 SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
3089 // ---------- initialize player's initial move delay ------------------------
3091 // dynamically adjust player properties according to level information
3092 for (i = 0; i < MAX_PLAYERS; i++)
3093 game.initial_move_delay_value[i] =
3094 get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
3096 // dynamically adjust player properties according to game engine version
3097 for (i = 0; i < MAX_PLAYERS; i++)
3098 game.initial_move_delay[i] =
3099 (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
3100 game.initial_move_delay_value[i] : 0);
3102 // ---------- initialize player's initial push delay ------------------------
3104 // dynamically adjust player properties according to game engine version
3105 game.initial_push_delay_value =
3106 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
3108 // ---------- initialize changing elements ----------------------------------
3110 // initialize changing elements information
3111 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3113 struct ElementInfo *ei = &element_info[i];
3115 // this pointer might have been changed in the level editor
3116 ei->change = &ei->change_page[0];
3118 if (!IS_CUSTOM_ELEMENT(i))
3120 ei->change->target_element = EL_EMPTY_SPACE;
3121 ei->change->delay_fixed = 0;
3122 ei->change->delay_random = 0;
3123 ei->change->delay_frames = 1;
3126 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3128 ei->has_change_event[j] = FALSE;
3130 ei->event_page_nr[j] = 0;
3131 ei->event_page[j] = &ei->change_page[0];
3135 // add changing elements from pre-defined list
3136 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
3138 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
3139 struct ElementInfo *ei = &element_info[ch_delay->element];
3141 ei->change->target_element = ch_delay->target_element;
3142 ei->change->delay_fixed = ch_delay->change_delay;
3144 ei->change->pre_change_function = ch_delay->pre_change_function;
3145 ei->change->change_function = ch_delay->change_function;
3146 ei->change->post_change_function = ch_delay->post_change_function;
3148 ei->change->can_change = TRUE;
3149 ei->change->can_change_or_has_action = TRUE;
3151 ei->has_change_event[CE_DELAY] = TRUE;
3153 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
3154 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
3157 // ---------- initialize internal run-time variables ------------------------
3159 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3161 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3163 for (j = 0; j < ei->num_change_pages; j++)
3165 ei->change_page[j].can_change_or_has_action =
3166 (ei->change_page[j].can_change |
3167 ei->change_page[j].has_action);
3171 // add change events from custom element configuration
3172 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3174 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3176 for (j = 0; j < ei->num_change_pages; j++)
3178 if (!ei->change_page[j].can_change_or_has_action)
3181 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3183 // only add event page for the first page found with this event
3184 if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
3186 ei->has_change_event[k] = TRUE;
3188 ei->event_page_nr[k] = j;
3189 ei->event_page[k] = &ei->change_page[j];
3195 // ---------- initialize reference elements in change conditions ------------
3197 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3199 int element = EL_CUSTOM_START + i;
3200 struct ElementInfo *ei = &element_info[element];
3202 for (j = 0; j < ei->num_change_pages; j++)
3204 int trigger_element = ei->change_page[j].initial_trigger_element;
3206 if (trigger_element >= EL_PREV_CE_8 &&
3207 trigger_element <= EL_NEXT_CE_8)
3208 trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element);
3210 ei->change_page[j].trigger_element = trigger_element;
3214 // ---------- initialize run-time trigger player and element ----------------
3216 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3218 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3220 for (j = 0; j < ei->num_change_pages; j++)
3222 ei->change_page[j].actual_trigger_element = EL_EMPTY;
3223 ei->change_page[j].actual_trigger_player = EL_EMPTY;
3224 ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
3225 ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
3226 ei->change_page[j].actual_trigger_ce_value = 0;
3227 ei->change_page[j].actual_trigger_ce_score = 0;
3231 // ---------- initialize trigger events -------------------------------------
3233 // initialize trigger events information
3234 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3235 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3236 trigger_events[i][j] = FALSE;
3238 // add trigger events from element change event properties
3239 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3241 struct ElementInfo *ei = &element_info[i];
3243 for (j = 0; j < ei->num_change_pages; j++)
3245 if (!ei->change_page[j].can_change_or_has_action)
3248 if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
3250 int trigger_element = ei->change_page[j].trigger_element;
3252 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3254 if (ei->change_page[j].has_event[k])
3256 if (IS_GROUP_ELEMENT(trigger_element))
3258 struct ElementGroupInfo *group =
3259 element_info[trigger_element].group;
3261 for (l = 0; l < group->num_elements_resolved; l++)
3262 trigger_events[group->element_resolved[l]][k] = TRUE;
3264 else if (trigger_element == EL_ANY_ELEMENT)
3265 for (l = 0; l < MAX_NUM_ELEMENTS; l++)
3266 trigger_events[l][k] = TRUE;
3268 trigger_events[trigger_element][k] = TRUE;
3275 // ---------- initialize push delay -----------------------------------------
3277 // initialize push delay values to default
3278 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3280 if (!IS_CUSTOM_ELEMENT(i))
3282 // set default push delay values (corrected since version 3.0.7-1)
3283 if (game.engine_version < VERSION_IDENT(3,0,7,1))
3285 element_info[i].push_delay_fixed = 2;
3286 element_info[i].push_delay_random = 8;
3290 element_info[i].push_delay_fixed = 8;
3291 element_info[i].push_delay_random = 8;
3296 // set push delay value for certain elements from pre-defined list
3297 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
3299 int e = push_delay_list[i].element;
3301 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
3302 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
3305 // set push delay value for Supaplex elements for newer engine versions
3306 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
3308 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3310 if (IS_SP_ELEMENT(i))
3312 // set SP push delay to just enough to push under a falling zonk
3313 int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
3315 element_info[i].push_delay_fixed = delay;
3316 element_info[i].push_delay_random = 0;
3321 // ---------- initialize move stepsize --------------------------------------
3323 // initialize move stepsize values to default
3324 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3325 if (!IS_CUSTOM_ELEMENT(i))
3326 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
3328 // set move stepsize value for certain elements from pre-defined list
3329 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
3331 int e = move_stepsize_list[i].element;
3333 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
3335 // set move stepsize value for certain elements for older engine versions
3336 if (use_old_move_stepsize_for_magic_wall)
3338 if (e == EL_MAGIC_WALL_FILLING ||
3339 e == EL_MAGIC_WALL_EMPTYING ||
3340 e == EL_BD_MAGIC_WALL_FILLING ||
3341 e == EL_BD_MAGIC_WALL_EMPTYING)
3342 element_info[e].move_stepsize *= 2;
3346 // ---------- initialize collect score --------------------------------------
3348 // initialize collect score values for custom elements from initial value
3349 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3350 if (IS_CUSTOM_ELEMENT(i))
3351 element_info[i].collect_score = element_info[i].collect_score_initial;
3353 // ---------- initialize collect count --------------------------------------
3355 // initialize collect count values for non-custom elements
3356 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3357 if (!IS_CUSTOM_ELEMENT(i))
3358 element_info[i].collect_count_initial = 0;
3360 // add collect count values for all elements from pre-defined list
3361 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
3362 element_info[collect_count_list[i].element].collect_count_initial =
3363 collect_count_list[i].count;
3365 // ---------- initialize access direction -----------------------------------
3367 // initialize access direction values to default (access from every side)
3368 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3369 if (!IS_CUSTOM_ELEMENT(i))
3370 element_info[i].access_direction = MV_ALL_DIRECTIONS;
3372 // set access direction value for certain elements from pre-defined list
3373 for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
3374 element_info[access_direction_list[i].element].access_direction =
3375 access_direction_list[i].direction;
3377 // ---------- initialize explosion content ----------------------------------
3378 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3380 if (IS_CUSTOM_ELEMENT(i))
3383 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
3385 // (content for EL_YAMYAM set at run-time with game.yamyam_content_nr)
3387 element_info[i].content.e[x][y] =
3388 (i == EL_PLAYER_1 ? EL_EMERALD_YELLOW :
3389 i == EL_PLAYER_2 ? EL_EMERALD_RED :
3390 i == EL_PLAYER_3 ? EL_EMERALD :
3391 i == EL_PLAYER_4 ? EL_EMERALD_PURPLE :
3392 i == EL_MOLE ? EL_EMERALD_RED :
3393 i == EL_PENGUIN ? EL_EMERALD_PURPLE :
3394 i == EL_BUG ? (x == 1 && y == 1 ? EL_DIAMOND : EL_EMERALD) :
3395 i == EL_BD_BUTTERFLY ? EL_BD_DIAMOND :
3396 i == EL_SP_ELECTRON ? EL_SP_INFOTRON :
3397 i == EL_AMOEBA_TO_DIAMOND ? level.amoeba_content :
3398 i == EL_WALL_EMERALD ? EL_EMERALD :
3399 i == EL_WALL_DIAMOND ? EL_DIAMOND :
3400 i == EL_WALL_BD_DIAMOND ? EL_BD_DIAMOND :
3401 i == EL_WALL_EMERALD_YELLOW ? EL_EMERALD_YELLOW :
3402 i == EL_WALL_EMERALD_RED ? EL_EMERALD_RED :
3403 i == EL_WALL_EMERALD_PURPLE ? EL_EMERALD_PURPLE :
3404 i == EL_WALL_PEARL ? EL_PEARL :
3405 i == EL_WALL_CRYSTAL ? EL_CRYSTAL :
3410 // ---------- initialize recursion detection --------------------------------
3411 recursion_loop_depth = 0;
3412 recursion_loop_detected = FALSE;
3413 recursion_loop_element = EL_UNDEFINED;
3415 // ---------- initialize graphics engine ------------------------------------
3416 game.scroll_delay_value =
3417 (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
3418 level.game_engine_type == GAME_ENGINE_TYPE_EM &&
3419 !setup.forced_scroll_delay ? 0 :
3420 setup.scroll_delay ? setup.scroll_delay_value : 0);
3421 game.scroll_delay_value =
3422 MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
3424 // ---------- initialize game engine snapshots ------------------------------
3425 for (i = 0; i < MAX_PLAYERS; i++)
3426 game.snapshot.last_action[i] = 0;
3427 game.snapshot.changed_action = FALSE;
3428 game.snapshot.collected_item = FALSE;
3429 game.snapshot.mode =
3430 (strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
3431 SNAPSHOT_MODE_EVERY_STEP :
3432 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
3433 SNAPSHOT_MODE_EVERY_MOVE :
3434 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
3435 SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
3436 game.snapshot.save_snapshot = FALSE;
3438 // ---------- initialize level time for Supaplex engine ---------------------
3439 // Supaplex levels with time limit currently unsupported -- should be added
3440 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
3443 // ---------- initialize flags for handling game actions --------------------
3445 // set flags for game actions to default values
3446 game.use_key_actions = TRUE;
3447 game.use_mouse_actions = FALSE;
3449 // when using Mirror Magic game engine, handle mouse events only
3450 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
3452 game.use_key_actions = FALSE;
3453 game.use_mouse_actions = TRUE;
3456 // check for custom elements with mouse click events
3457 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
3459 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3461 int element = EL_CUSTOM_START + i;
3463 if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
3464 HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
3465 HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
3466 HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
3467 game.use_mouse_actions = TRUE;
3472 static int get_num_special_action(int element, int action_first,
3475 int num_special_action = 0;
3478 for (i = action_first; i <= action_last; i++)
3480 boolean found = FALSE;
3482 for (j = 0; j < NUM_DIRECTIONS; j++)
3483 if (el_act_dir2img(element, i, j) !=
3484 el_act_dir2img(element, ACTION_DEFAULT, j))
3488 num_special_action++;
3493 return num_special_action;
3497 // ============================================================================
3499 // ----------------------------------------------------------------------------
3500 // initialize and start new game
3501 // ============================================================================
3503 #if DEBUG_INIT_PLAYER
3504 static void DebugPrintPlayerStatus(char *message)
3511 Debug("game:init:player", "%s:", message);
3513 for (i = 0; i < MAX_PLAYERS; i++)
3515 struct PlayerInfo *player = &stored_player[i];
3517 Debug("game:init:player",
3518 "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
3522 player->connected_locally,
3523 player->connected_network,
3525 (local_player == player ? " (local player)" : ""));
3532 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
3533 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
3534 int fade_mask = REDRAW_FIELD;
3536 boolean emulate_bd = TRUE; // unless non-BOULDERDASH elements found
3537 boolean emulate_sb = TRUE; // unless non-SOKOBAN elements found
3538 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3539 int initial_move_dir = MV_DOWN;
3542 // required here to update video display before fading (FIX THIS)
3543 DrawMaskedBorder(REDRAW_DOOR_2);
3545 if (!game.restart_level)
3546 CloseDoor(DOOR_CLOSE_1);
3548 SetGameStatus(GAME_MODE_PLAYING);
3550 if (level_editor_test_game)
3551 FadeSkipNextFadeOut();
3553 FadeSetEnterScreen();
3556 fade_mask = REDRAW_ALL;
3558 FadeLevelSoundsAndMusic();
3560 ExpireSoundLoops(TRUE);
3564 if (level_editor_test_game)
3565 FadeSkipNextFadeIn();
3567 // needed if different viewport properties defined for playing
3568 ChangeViewportPropertiesIfNeeded();
3572 DrawCompleteVideoDisplay();
3574 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3577 InitGameControlValues();
3581 // initialize tape actions from game when recording tape
3582 tape.use_key_actions = game.use_key_actions;
3583 tape.use_mouse_actions = game.use_mouse_actions;
3585 // initialize visible playfield size when recording tape (for team mode)
3586 tape.scr_fieldx = SCR_FIELDX;
3587 tape.scr_fieldy = SCR_FIELDY;
3590 // don't play tapes over network
3591 network_playing = (network.enabled && !tape.playing);
3593 for (i = 0; i < MAX_PLAYERS; i++)
3595 struct PlayerInfo *player = &stored_player[i];
3597 player->index_nr = i;
3598 player->index_bit = (1 << i);
3599 player->element_nr = EL_PLAYER_1 + i;
3601 player->present = FALSE;
3602 player->active = FALSE;
3603 player->mapped = FALSE;
3605 player->killed = FALSE;
3606 player->reanimated = FALSE;
3607 player->buried = FALSE;
3610 player->effective_action = 0;
3611 player->programmed_action = 0;
3612 player->snap_action = 0;
3614 player->mouse_action.lx = 0;
3615 player->mouse_action.ly = 0;
3616 player->mouse_action.button = 0;
3617 player->mouse_action.button_hint = 0;
3619 player->effective_mouse_action.lx = 0;
3620 player->effective_mouse_action.ly = 0;
3621 player->effective_mouse_action.button = 0;
3622 player->effective_mouse_action.button_hint = 0;
3624 for (j = 0; j < MAX_NUM_KEYS; j++)
3625 player->key[j] = FALSE;
3627 player->num_white_keys = 0;
3629 player->dynabomb_count = 0;
3630 player->dynabomb_size = 1;
3631 player->dynabombs_left = 0;
3632 player->dynabomb_xl = FALSE;
3634 player->MovDir = initial_move_dir;
3637 player->GfxDir = initial_move_dir;
3638 player->GfxAction = ACTION_DEFAULT;
3640 player->StepFrame = 0;
3642 player->initial_element = player->element_nr;
3643 player->artwork_element =
3644 (level.use_artwork_element[i] ? level.artwork_element[i] :
3645 player->element_nr);
3646 player->use_murphy = FALSE;
3648 player->block_last_field = FALSE; // initialized in InitPlayerField()
3649 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3651 player->gravity = level.initial_player_gravity[i];
3653 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3655 player->actual_frame_counter = 0;
3657 player->step_counter = 0;
3659 player->last_move_dir = initial_move_dir;
3661 player->is_active = FALSE;
3663 player->is_waiting = FALSE;
3664 player->is_moving = FALSE;
3665 player->is_auto_moving = FALSE;
3666 player->is_digging = FALSE;
3667 player->is_snapping = FALSE;
3668 player->is_collecting = FALSE;
3669 player->is_pushing = FALSE;
3670 player->is_switching = FALSE;
3671 player->is_dropping = FALSE;
3672 player->is_dropping_pressed = FALSE;
3674 player->is_bored = FALSE;
3675 player->is_sleeping = FALSE;
3677 player->was_waiting = TRUE;
3678 player->was_moving = FALSE;
3679 player->was_snapping = FALSE;
3680 player->was_dropping = FALSE;
3682 player->force_dropping = FALSE;
3684 player->frame_counter_bored = -1;
3685 player->frame_counter_sleeping = -1;
3687 player->anim_delay_counter = 0;
3688 player->post_delay_counter = 0;
3690 player->dir_waiting = initial_move_dir;
3691 player->action_waiting = ACTION_DEFAULT;
3692 player->last_action_waiting = ACTION_DEFAULT;
3693 player->special_action_bored = ACTION_DEFAULT;
3694 player->special_action_sleeping = ACTION_DEFAULT;
3696 player->switch_x = -1;
3697 player->switch_y = -1;
3699 player->drop_x = -1;
3700 player->drop_y = -1;
3702 player->show_envelope = 0;
3704 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3706 player->push_delay = -1; // initialized when pushing starts
3707 player->push_delay_value = game.initial_push_delay_value;
3709 player->drop_delay = 0;
3710 player->drop_pressed_delay = 0;
3712 player->last_jx = -1;
3713 player->last_jy = -1;
3717 player->shield_normal_time_left = 0;
3718 player->shield_deadly_time_left = 0;
3720 player->inventory_infinite_element = EL_UNDEFINED;
3721 player->inventory_size = 0;
3723 if (level.use_initial_inventory[i])
3725 for (j = 0; j < level.initial_inventory_size[i]; j++)
3727 int element = level.initial_inventory_content[i][j];
3728 int collect_count = element_info[element].collect_count_initial;
3731 if (!IS_CUSTOM_ELEMENT(element))
3734 if (collect_count == 0)
3735 player->inventory_infinite_element = element;
3737 for (k = 0; k < collect_count; k++)
3738 if (player->inventory_size < MAX_INVENTORY_SIZE)
3739 player->inventory_element[player->inventory_size++] = element;
3743 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3744 SnapField(player, 0, 0);
3746 map_player_action[i] = i;
3749 network_player_action_received = FALSE;
3751 // initial null action
3752 if (network_playing)
3753 SendToServer_MovePlayer(MV_NONE);
3758 TimeLeft = level.time;
3761 ScreenMovDir = MV_NONE;
3765 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3767 game.robot_wheel_x = -1;
3768 game.robot_wheel_y = -1;
3773 game.all_players_gone = FALSE;
3775 game.LevelSolved = FALSE;
3776 game.GameOver = FALSE;
3778 game.GamePlayed = !tape.playing;
3780 game.LevelSolved_GameWon = FALSE;
3781 game.LevelSolved_GameEnd = FALSE;
3782 game.LevelSolved_SaveTape = FALSE;
3783 game.LevelSolved_SaveScore = FALSE;
3785 game.LevelSolved_CountingTime = 0;
3786 game.LevelSolved_CountingScore = 0;
3787 game.LevelSolved_CountingHealth = 0;
3789 game.panel.active = TRUE;
3791 game.no_time_limit = (level.time == 0);
3793 game.yamyam_content_nr = 0;
3794 game.robot_wheel_active = FALSE;
3795 game.magic_wall_active = FALSE;
3796 game.magic_wall_time_left = 0;
3797 game.light_time_left = 0;
3798 game.timegate_time_left = 0;
3799 game.switchgate_pos = 0;
3800 game.wind_direction = level.wind_direction_initial;
3803 game.score_final = 0;
3805 game.health = MAX_HEALTH;
3806 game.health_final = MAX_HEALTH;
3808 game.gems_still_needed = level.gems_needed;
3809 game.sokoban_fields_still_needed = 0;
3810 game.sokoban_objects_still_needed = 0;
3811 game.lights_still_needed = 0;
3812 game.players_still_needed = 0;
3813 game.friends_still_needed = 0;
3815 game.lenses_time_left = 0;
3816 game.magnify_time_left = 0;
3818 game.ball_active = level.ball_active_initial;
3819 game.ball_content_nr = 0;
3821 game.explosions_delayed = TRUE;
3823 game.envelope_active = FALSE;
3825 for (i = 0; i < NUM_BELTS; i++)
3827 game.belt_dir[i] = MV_NONE;
3828 game.belt_dir_nr[i] = 3; // not moving, next moving left
3831 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3832 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3834 #if DEBUG_INIT_PLAYER
3835 DebugPrintPlayerStatus("Player status at level initialization");
3838 SCAN_PLAYFIELD(x, y)
3840 Tile[x][y] = Last[x][y] = level.field[x][y];
3841 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3842 ChangeDelay[x][y] = 0;
3843 ChangePage[x][y] = -1;
3844 CustomValue[x][y] = 0; // initialized in InitField()
3845 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3847 WasJustMoving[x][y] = 0;
3848 WasJustFalling[x][y] = 0;
3849 CheckCollision[x][y] = 0;
3850 CheckImpact[x][y] = 0;
3852 Pushed[x][y] = FALSE;
3854 ChangeCount[x][y] = 0;
3855 ChangeEvent[x][y] = -1;
3857 ExplodePhase[x][y] = 0;
3858 ExplodeDelay[x][y] = 0;
3859 ExplodeField[x][y] = EX_TYPE_NONE;
3861 RunnerVisit[x][y] = 0;
3862 PlayerVisit[x][y] = 0;
3865 GfxRandom[x][y] = INIT_GFX_RANDOM();
3866 GfxElement[x][y] = EL_UNDEFINED;
3867 GfxAction[x][y] = ACTION_DEFAULT;
3868 GfxDir[x][y] = MV_NONE;
3869 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3872 SCAN_PLAYFIELD(x, y)
3874 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3876 if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
3878 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3881 InitField(x, y, TRUE);
3883 ResetGfxAnimation(x, y);
3888 for (i = 0; i < MAX_PLAYERS; i++)
3890 struct PlayerInfo *player = &stored_player[i];
3892 // set number of special actions for bored and sleeping animation
3893 player->num_special_action_bored =
3894 get_num_special_action(player->artwork_element,
3895 ACTION_BORING_1, ACTION_BORING_LAST);
3896 player->num_special_action_sleeping =
3897 get_num_special_action(player->artwork_element,
3898 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3901 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3902 emulate_sb ? EMU_SOKOBAN :
3903 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3905 // initialize type of slippery elements
3906 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3908 if (!IS_CUSTOM_ELEMENT(i))
3910 // default: elements slip down either to the left or right randomly
3911 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3913 // SP style elements prefer to slip down on the left side
3914 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3915 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3917 // BD style elements prefer to slip down on the left side
3918 if (game.emulation == EMU_BOULDERDASH)
3919 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3923 // initialize explosion and ignition delay
3924 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3926 if (!IS_CUSTOM_ELEMENT(i))
3929 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3930 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3931 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3932 int last_phase = (num_phase + 1) * delay;
3933 int half_phase = (num_phase / 2) * delay;
3935 element_info[i].explosion_delay = last_phase - 1;
3936 element_info[i].ignition_delay = half_phase;
3938 if (i == EL_BLACK_ORB)
3939 element_info[i].ignition_delay = 1;
3943 // correct non-moving belts to start moving left
3944 for (i = 0; i < NUM_BELTS; i++)
3945 if (game.belt_dir[i] == MV_NONE)
3946 game.belt_dir_nr[i] = 3; // not moving, next moving left
3948 #if USE_NEW_PLAYER_ASSIGNMENTS
3949 // use preferred player also in local single-player mode
3950 if (!network.enabled && !game.team_mode)
3952 int new_index_nr = setup.network_player_nr;
3954 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3956 for (i = 0; i < MAX_PLAYERS; i++)
3957 stored_player[i].connected_locally = FALSE;
3959 stored_player[new_index_nr].connected_locally = TRUE;
3963 for (i = 0; i < MAX_PLAYERS; i++)
3965 stored_player[i].connected = FALSE;
3967 // in network game mode, the local player might not be the first player
3968 if (stored_player[i].connected_locally)
3969 local_player = &stored_player[i];
3972 if (!network.enabled)
3973 local_player->connected = TRUE;
3977 for (i = 0; i < MAX_PLAYERS; i++)
3978 stored_player[i].connected = tape.player_participates[i];
3980 else if (network.enabled)
3982 // add team mode players connected over the network (needed for correct
3983 // assignment of player figures from level to locally playing players)
3985 for (i = 0; i < MAX_PLAYERS; i++)
3986 if (stored_player[i].connected_network)
3987 stored_player[i].connected = TRUE;
3989 else if (game.team_mode)
3991 // try to guess locally connected team mode players (needed for correct
3992 // assignment of player figures from level to locally playing players)
3994 for (i = 0; i < MAX_PLAYERS; i++)
3995 if (setup.input[i].use_joystick ||
3996 setup.input[i].key.left != KSYM_UNDEFINED)
3997 stored_player[i].connected = TRUE;
4000 #if DEBUG_INIT_PLAYER
4001 DebugPrintPlayerStatus("Player status after level initialization");
4004 #if DEBUG_INIT_PLAYER
4005 Debug("game:init:player", "Reassigning players ...");
4008 // check if any connected player was not found in playfield
4009 for (i = 0; i < MAX_PLAYERS; i++)
4011 struct PlayerInfo *player = &stored_player[i];
4013 if (player->connected && !player->present)
4015 struct PlayerInfo *field_player = NULL;
4017 #if DEBUG_INIT_PLAYER
4018 Debug("game:init:player",
4019 "- looking for field player for player %d ...", i + 1);
4022 // assign first free player found that is present in the playfield
4024 // first try: look for unmapped playfield player that is not connected
4025 for (j = 0; j < MAX_PLAYERS; j++)
4026 if (field_player == NULL &&
4027 stored_player[j].present &&
4028 !stored_player[j].mapped &&
4029 !stored_player[j].connected)
4030 field_player = &stored_player[j];
4032 // second try: look for *any* unmapped playfield player
4033 for (j = 0; j < MAX_PLAYERS; j++)
4034 if (field_player == NULL &&
4035 stored_player[j].present &&
4036 !stored_player[j].mapped)
4037 field_player = &stored_player[j];
4039 if (field_player != NULL)
4041 int jx = field_player->jx, jy = field_player->jy;
4043 #if DEBUG_INIT_PLAYER
4044 Debug("game:init:player", "- found player %d",
4045 field_player->index_nr + 1);
4048 player->present = FALSE;
4049 player->active = FALSE;
4051 field_player->present = TRUE;
4052 field_player->active = TRUE;
4055 player->initial_element = field_player->initial_element;
4056 player->artwork_element = field_player->artwork_element;
4058 player->block_last_field = field_player->block_last_field;
4059 player->block_delay_adjustment = field_player->block_delay_adjustment;
4062 StorePlayer[jx][jy] = field_player->element_nr;
4064 field_player->jx = field_player->last_jx = jx;
4065 field_player->jy = field_player->last_jy = jy;
4067 if (local_player == player)
4068 local_player = field_player;
4070 map_player_action[field_player->index_nr] = i;
4072 field_player->mapped = TRUE;
4074 #if DEBUG_INIT_PLAYER
4075 Debug("game:init:player", "- map_player_action[%d] == %d",
4076 field_player->index_nr + 1, i + 1);
4081 if (player->connected && player->present)
4082 player->mapped = TRUE;
4085 #if DEBUG_INIT_PLAYER
4086 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4091 // check if any connected player was not found in playfield
4092 for (i = 0; i < MAX_PLAYERS; i++)
4094 struct PlayerInfo *player = &stored_player[i];
4096 if (player->connected && !player->present)
4098 for (j = 0; j < MAX_PLAYERS; j++)
4100 struct PlayerInfo *field_player = &stored_player[j];
4101 int jx = field_player->jx, jy = field_player->jy;
4103 // assign first free player found that is present in the playfield
4104 if (field_player->present && !field_player->connected)
4106 player->present = TRUE;
4107 player->active = TRUE;
4109 field_player->present = FALSE;
4110 field_player->active = FALSE;
4112 player->initial_element = field_player->initial_element;
4113 player->artwork_element = field_player->artwork_element;
4115 player->block_last_field = field_player->block_last_field;
4116 player->block_delay_adjustment = field_player->block_delay_adjustment;
4118 StorePlayer[jx][jy] = player->element_nr;
4120 player->jx = player->last_jx = jx;
4121 player->jy = player->last_jy = jy;
4131 Debug("game:init:player", "local_player->present == %d",
4132 local_player->present);
4135 // set focus to local player for network games, else to all players
4136 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4137 game.centered_player_nr_next = game.centered_player_nr;
4138 game.set_centered_player = FALSE;
4139 game.set_centered_player_wrap = FALSE;
4141 if (network_playing && tape.recording)
4143 // store client dependent player focus when recording network games
4144 tape.centered_player_nr_next = game.centered_player_nr_next;
4145 tape.set_centered_player = TRUE;
4150 // when playing a tape, eliminate all players who do not participate
4152 #if USE_NEW_PLAYER_ASSIGNMENTS
4154 if (!game.team_mode)
4156 for (i = 0; i < MAX_PLAYERS; i++)
4158 if (stored_player[i].active &&
4159 !tape.player_participates[map_player_action[i]])
4161 struct PlayerInfo *player = &stored_player[i];
4162 int jx = player->jx, jy = player->jy;
4164 #if DEBUG_INIT_PLAYER
4165 Debug("game:init:player", "Removing player %d at (%d, %d)",
4169 player->active = FALSE;
4170 StorePlayer[jx][jy] = 0;
4171 Tile[jx][jy] = EL_EMPTY;
4178 for (i = 0; i < MAX_PLAYERS; i++)
4180 if (stored_player[i].active &&
4181 !tape.player_participates[i])
4183 struct PlayerInfo *player = &stored_player[i];
4184 int jx = player->jx, jy = player->jy;
4186 player->active = FALSE;
4187 StorePlayer[jx][jy] = 0;
4188 Tile[jx][jy] = EL_EMPTY;
4193 else if (!network.enabled && !game.team_mode) // && !tape.playing
4195 // when in single player mode, eliminate all but the local player
4197 for (i = 0; i < MAX_PLAYERS; i++)
4199 struct PlayerInfo *player = &stored_player[i];
4201 if (player->active && player != local_player)
4203 int jx = player->jx, jy = player->jy;
4205 player->active = FALSE;
4206 player->present = FALSE;
4208 StorePlayer[jx][jy] = 0;
4209 Tile[jx][jy] = EL_EMPTY;
4214 for (i = 0; i < MAX_PLAYERS; i++)
4215 if (stored_player[i].active)
4216 game.players_still_needed++;
4218 if (level.solved_by_one_player)
4219 game.players_still_needed = 1;
4221 // when recording the game, store which players take part in the game
4224 #if USE_NEW_PLAYER_ASSIGNMENTS
4225 for (i = 0; i < MAX_PLAYERS; i++)
4226 if (stored_player[i].connected)
4227 tape.player_participates[i] = TRUE;
4229 for (i = 0; i < MAX_PLAYERS; i++)
4230 if (stored_player[i].active)
4231 tape.player_participates[i] = TRUE;
4235 #if DEBUG_INIT_PLAYER
4236 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4239 if (BorderElement == EL_EMPTY)
4242 SBX_Right = lev_fieldx - SCR_FIELDX;
4244 SBY_Lower = lev_fieldy - SCR_FIELDY;
4249 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4251 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4254 if (full_lev_fieldx <= SCR_FIELDX)
4255 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4256 if (full_lev_fieldy <= SCR_FIELDY)
4257 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4259 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4261 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4264 // if local player not found, look for custom element that might create
4265 // the player (make some assumptions about the right custom element)
4266 if (!local_player->present)
4268 int start_x = 0, start_y = 0;
4269 int found_rating = 0;
4270 int found_element = EL_UNDEFINED;
4271 int player_nr = local_player->index_nr;
4273 SCAN_PLAYFIELD(x, y)
4275 int element = Tile[x][y];
4280 if (level.use_start_element[player_nr] &&
4281 level.start_element[player_nr] == element &&
4288 found_element = element;
4291 if (!IS_CUSTOM_ELEMENT(element))
4294 if (CAN_CHANGE(element))
4296 for (i = 0; i < element_info[element].num_change_pages; i++)
4298 // check for player created from custom element as single target
4299 content = element_info[element].change_page[i].target_element;
4300 is_player = ELEM_IS_PLAYER(content);
4302 if (is_player && (found_rating < 3 ||
4303 (found_rating == 3 && element < found_element)))
4309 found_element = element;
4314 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4316 // check for player created from custom element as explosion content
4317 content = element_info[element].content.e[xx][yy];
4318 is_player = ELEM_IS_PLAYER(content);
4320 if (is_player && (found_rating < 2 ||
4321 (found_rating == 2 && element < found_element)))
4323 start_x = x + xx - 1;
4324 start_y = y + yy - 1;
4327 found_element = element;
4330 if (!CAN_CHANGE(element))
4333 for (i = 0; i < element_info[element].num_change_pages; i++)
4335 // check for player created from custom element as extended target
4337 element_info[element].change_page[i].target_content.e[xx][yy];
4339 is_player = ELEM_IS_PLAYER(content);
4341 if (is_player && (found_rating < 1 ||
4342 (found_rating == 1 && element < found_element)))
4344 start_x = x + xx - 1;
4345 start_y = y + yy - 1;
4348 found_element = element;
4354 scroll_x = SCROLL_POSITION_X(start_x);
4355 scroll_y = SCROLL_POSITION_Y(start_y);
4359 scroll_x = SCROLL_POSITION_X(local_player->jx);
4360 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4363 // !!! FIX THIS (START) !!!
4364 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4366 InitGameEngine_EM();
4368 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4370 InitGameEngine_SP();
4372 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4374 InitGameEngine_MM();
4378 DrawLevel(REDRAW_FIELD);
4381 // after drawing the level, correct some elements
4382 if (game.timegate_time_left == 0)
4383 CloseAllOpenTimegates();
4386 // blit playfield from scroll buffer to normal back buffer for fading in
4387 BlitScreenToBitmap(backbuffer);
4388 // !!! FIX THIS (END) !!!
4390 DrawMaskedBorder(fade_mask);
4395 // full screen redraw is required at this point in the following cases:
4396 // - special editor door undrawn when game was started from level editor
4397 // - drawing area (playfield) was changed and has to be removed completely
4398 redraw_mask = REDRAW_ALL;
4402 if (!game.restart_level)
4404 // copy default game door content to main double buffer
4406 // !!! CHECK AGAIN !!!
4407 SetPanelBackground();
4408 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4409 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4412 SetPanelBackground();
4413 SetDrawBackgroundMask(REDRAW_DOOR_1);
4415 UpdateAndDisplayGameControlValues();
4417 if (!game.restart_level)
4423 CreateGameButtons();
4428 // copy actual game door content to door double buffer for OpenDoor()
4429 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4431 OpenDoor(DOOR_OPEN_ALL);
4433 KeyboardAutoRepeatOffUnlessAutoplay();
4435 #if DEBUG_INIT_PLAYER
4436 DebugPrintPlayerStatus("Player status (final)");
4445 if (!game.restart_level && !tape.playing)
4447 LevelStats_incPlayed(level_nr);
4449 SaveLevelSetup_SeriesInfo();
4452 game.restart_level = FALSE;
4453 game.restart_game_message = NULL;
4455 game.request_active = FALSE;
4456 game.request_active_or_moving = FALSE;
4458 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4459 InitGameActions_MM();
4461 SaveEngineSnapshotToListInitial();
4463 if (!game.restart_level)
4465 PlaySound(SND_GAME_STARTING);
4467 if (setup.sound_music)
4472 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4473 int actual_player_x, int actual_player_y)
4475 // this is used for non-R'n'D game engines to update certain engine values
4477 // needed to determine if sounds are played within the visible screen area
4478 scroll_x = actual_scroll_x;
4479 scroll_y = actual_scroll_y;
4481 // needed to get player position for "follow finger" playing input method
4482 local_player->jx = actual_player_x;
4483 local_player->jy = actual_player_y;
4486 void InitMovDir(int x, int y)
4488 int i, element = Tile[x][y];
4489 static int xy[4][2] =
4496 static int direction[3][4] =
4498 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4499 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4500 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4509 Tile[x][y] = EL_BUG;
4510 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4513 case EL_SPACESHIP_RIGHT:
4514 case EL_SPACESHIP_UP:
4515 case EL_SPACESHIP_LEFT:
4516 case EL_SPACESHIP_DOWN:
4517 Tile[x][y] = EL_SPACESHIP;
4518 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4521 case EL_BD_BUTTERFLY_RIGHT:
4522 case EL_BD_BUTTERFLY_UP:
4523 case EL_BD_BUTTERFLY_LEFT:
4524 case EL_BD_BUTTERFLY_DOWN:
4525 Tile[x][y] = EL_BD_BUTTERFLY;
4526 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4529 case EL_BD_FIREFLY_RIGHT:
4530 case EL_BD_FIREFLY_UP:
4531 case EL_BD_FIREFLY_LEFT:
4532 case EL_BD_FIREFLY_DOWN:
4533 Tile[x][y] = EL_BD_FIREFLY;
4534 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4537 case EL_PACMAN_RIGHT:
4539 case EL_PACMAN_LEFT:
4540 case EL_PACMAN_DOWN:
4541 Tile[x][y] = EL_PACMAN;
4542 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4545 case EL_YAMYAM_LEFT:
4546 case EL_YAMYAM_RIGHT:
4548 case EL_YAMYAM_DOWN:
4549 Tile[x][y] = EL_YAMYAM;
4550 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4553 case EL_SP_SNIKSNAK:
4554 MovDir[x][y] = MV_UP;
4557 case EL_SP_ELECTRON:
4558 MovDir[x][y] = MV_LEFT;
4565 Tile[x][y] = EL_MOLE;
4566 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4569 case EL_SPRING_LEFT:
4570 case EL_SPRING_RIGHT:
4571 Tile[x][y] = EL_SPRING;
4572 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4576 if (IS_CUSTOM_ELEMENT(element))
4578 struct ElementInfo *ei = &element_info[element];
4579 int move_direction_initial = ei->move_direction_initial;
4580 int move_pattern = ei->move_pattern;
4582 if (move_direction_initial == MV_START_PREVIOUS)
4584 if (MovDir[x][y] != MV_NONE)
4587 move_direction_initial = MV_START_AUTOMATIC;
4590 if (move_direction_initial == MV_START_RANDOM)
4591 MovDir[x][y] = 1 << RND(4);
4592 else if (move_direction_initial & MV_ANY_DIRECTION)
4593 MovDir[x][y] = move_direction_initial;
4594 else if (move_pattern == MV_ALL_DIRECTIONS ||
4595 move_pattern == MV_TURNING_LEFT ||
4596 move_pattern == MV_TURNING_RIGHT ||
4597 move_pattern == MV_TURNING_LEFT_RIGHT ||
4598 move_pattern == MV_TURNING_RIGHT_LEFT ||
4599 move_pattern == MV_TURNING_RANDOM)
4600 MovDir[x][y] = 1 << RND(4);
4601 else if (move_pattern == MV_HORIZONTAL)
4602 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4603 else if (move_pattern == MV_VERTICAL)
4604 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4605 else if (move_pattern & MV_ANY_DIRECTION)
4606 MovDir[x][y] = element_info[element].move_pattern;
4607 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4608 move_pattern == MV_ALONG_RIGHT_SIDE)
4610 // use random direction as default start direction
4611 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4612 MovDir[x][y] = 1 << RND(4);
4614 for (i = 0; i < NUM_DIRECTIONS; i++)
4616 int x1 = x + xy[i][0];
4617 int y1 = y + xy[i][1];
4619 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4621 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4622 MovDir[x][y] = direction[0][i];
4624 MovDir[x][y] = direction[1][i];
4633 MovDir[x][y] = 1 << RND(4);
4635 if (element != EL_BUG &&
4636 element != EL_SPACESHIP &&
4637 element != EL_BD_BUTTERFLY &&
4638 element != EL_BD_FIREFLY)
4641 for (i = 0; i < NUM_DIRECTIONS; i++)
4643 int x1 = x + xy[i][0];
4644 int y1 = y + xy[i][1];
4646 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4648 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4650 MovDir[x][y] = direction[0][i];
4653 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4654 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4656 MovDir[x][y] = direction[1][i];
4665 GfxDir[x][y] = MovDir[x][y];
4668 void InitAmoebaNr(int x, int y)
4671 int group_nr = AmoebaNeighbourNr(x, y);
4675 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4677 if (AmoebaCnt[i] == 0)
4685 AmoebaNr[x][y] = group_nr;
4686 AmoebaCnt[group_nr]++;
4687 AmoebaCnt2[group_nr]++;
4690 static void LevelSolved(void)
4692 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4693 game.players_still_needed > 0)
4696 game.LevelSolved = TRUE;
4697 game.GameOver = TRUE;
4699 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4700 game_em.lev->score :
4701 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4704 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4705 MM_HEALTH(game_mm.laser_overload_value) :
4708 game.LevelSolved_CountingTime = (game.no_time_limit ? TimePlayed : TimeLeft);
4709 game.LevelSolved_CountingScore = game.score_final;
4710 game.LevelSolved_CountingHealth = game.health_final;
4715 static int time_count_steps;
4716 static int time, time_final;
4717 static int score, score_final;
4718 static int health, health_final;
4719 static int game_over_delay_1 = 0;
4720 static int game_over_delay_2 = 0;
4721 static int game_over_delay_3 = 0;
4722 int game_over_delay_value_1 = 50;
4723 int game_over_delay_value_2 = 25;
4724 int game_over_delay_value_3 = 50;
4726 if (!game.LevelSolved_GameWon)
4730 // do not start end game actions before the player stops moving (to exit)
4731 if (local_player->active && local_player->MovPos)
4734 game.LevelSolved_GameWon = TRUE;
4735 game.LevelSolved_SaveTape = tape.recording;
4736 game.LevelSolved_SaveScore = !tape.playing;
4740 LevelStats_incSolved(level_nr);
4742 SaveLevelSetup_SeriesInfo();
4745 if (tape.auto_play) // tape might already be stopped here
4746 tape.auto_play_level_solved = TRUE;
4750 game_over_delay_1 = 0;
4751 game_over_delay_2 = 0;
4752 game_over_delay_3 = game_over_delay_value_3;
4754 time = time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4755 score = score_final = game.score_final;
4756 health = health_final = game.health_final;
4758 if (level.score[SC_TIME_BONUS] > 0)
4763 score_final += TimeLeft * level.score[SC_TIME_BONUS];
4765 else if (game.no_time_limit && TimePlayed < 999)
4768 score_final += (999 - TimePlayed) * level.score[SC_TIME_BONUS];
4771 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4773 game_over_delay_1 = game_over_delay_value_1;
4775 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4778 score_final += health * level.score[SC_TIME_BONUS];
4780 game_over_delay_2 = game_over_delay_value_2;
4783 game.score_final = score_final;
4784 game.health_final = health_final;
4787 if (level_editor_test_game)
4790 score = score_final;
4792 game.LevelSolved_CountingTime = time;
4793 game.LevelSolved_CountingScore = score;
4795 game_panel_controls[GAME_PANEL_TIME].value = time;
4796 game_panel_controls[GAME_PANEL_SCORE].value = score;
4798 DisplayGameControlValues();
4801 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4803 // check if last player has left the level
4804 if (game.exit_x >= 0 &&
4807 int x = game.exit_x;
4808 int y = game.exit_y;
4809 int element = Tile[x][y];
4811 // close exit door after last player
4812 if ((game.all_players_gone &&
4813 (element == EL_EXIT_OPEN ||
4814 element == EL_SP_EXIT_OPEN ||
4815 element == EL_STEEL_EXIT_OPEN)) ||
4816 element == EL_EM_EXIT_OPEN ||
4817 element == EL_EM_STEEL_EXIT_OPEN)
4821 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4822 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4823 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4824 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4825 EL_EM_STEEL_EXIT_CLOSING);
4827 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4830 // player disappears
4831 DrawLevelField(x, y);
4834 for (i = 0; i < MAX_PLAYERS; i++)
4836 struct PlayerInfo *player = &stored_player[i];
4838 if (player->present)
4840 RemovePlayer(player);
4842 // player disappears
4843 DrawLevelField(player->jx, player->jy);
4848 PlaySound(SND_GAME_WINNING);
4851 if (game_over_delay_1 > 0)
4853 game_over_delay_1--;
4858 if (time != time_final)
4860 int time_to_go = ABS(time_final - time);
4861 int time_count_dir = (time < time_final ? +1 : -1);
4863 if (time_to_go < time_count_steps)
4864 time_count_steps = 1;
4866 time += time_count_steps * time_count_dir;
4867 score += time_count_steps * level.score[SC_TIME_BONUS];
4869 game.LevelSolved_CountingTime = time;
4870 game.LevelSolved_CountingScore = score;
4872 game_panel_controls[GAME_PANEL_TIME].value = time;
4873 game_panel_controls[GAME_PANEL_SCORE].value = score;
4875 DisplayGameControlValues();
4877 if (time == time_final)
4878 StopSound(SND_GAME_LEVELTIME_BONUS);
4879 else if (setup.sound_loops)
4880 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4882 PlaySound(SND_GAME_LEVELTIME_BONUS);
4887 if (game_over_delay_2 > 0)
4889 game_over_delay_2--;
4894 if (health != health_final)
4896 int health_count_dir = (health < health_final ? +1 : -1);
4898 health += health_count_dir;
4899 score += level.score[SC_TIME_BONUS];
4901 game.LevelSolved_CountingHealth = health;
4902 game.LevelSolved_CountingScore = score;
4904 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4905 game_panel_controls[GAME_PANEL_SCORE].value = score;
4907 DisplayGameControlValues();
4909 if (health == health_final)
4910 StopSound(SND_GAME_LEVELTIME_BONUS);
4911 else if (setup.sound_loops)
4912 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4914 PlaySound(SND_GAME_LEVELTIME_BONUS);
4919 game.panel.active = FALSE;
4921 if (game_over_delay_3 > 0)
4923 game_over_delay_3--;
4933 // used instead of "level_nr" (needed for network games)
4934 int last_level_nr = levelset.level_nr;
4937 game.LevelSolved_GameEnd = TRUE;
4939 if (game.LevelSolved_SaveTape)
4941 // make sure that request dialog to save tape does not open door again
4942 if (!global.use_envelope_request)
4943 CloseDoor(DOOR_CLOSE_1);
4945 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4948 // if no tape is to be saved, close both doors simultaneously
4949 CloseDoor(DOOR_CLOSE_ALL);
4951 if (level_editor_test_game)
4953 SetGameStatus(GAME_MODE_MAIN);
4960 if (!game.LevelSolved_SaveScore)
4962 SetGameStatus(GAME_MODE_MAIN);
4969 if (level_nr == leveldir_current->handicap_level)
4971 leveldir_current->handicap_level++;
4973 SaveLevelSetup_SeriesInfo();
4976 if (setup.increment_levels &&
4977 level_nr < leveldir_current->last_level &&
4980 level_nr++; // advance to next level
4981 TapeErase(); // start with empty tape
4983 if (setup.auto_play_next_level)
4985 LoadLevel(level_nr);
4987 SaveLevelSetup_SeriesInfo();
4991 hi_pos = NewHiScore(last_level_nr);
4993 if (hi_pos >= 0 && !setup.skip_scores_after_game)
4995 SetGameStatus(GAME_MODE_SCORES);
4997 DrawHallOfFame(last_level_nr, hi_pos);
4999 else if (setup.auto_play_next_level && setup.increment_levels &&
5000 last_level_nr < leveldir_current->last_level &&
5003 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5007 SetGameStatus(GAME_MODE_MAIN);
5013 int NewHiScore(int level_nr)
5017 boolean one_score_entry_per_name = !program.many_scores_per_name;
5019 LoadScore(level_nr);
5021 if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) ||
5022 game.score_final < highscore[MAX_SCORE_ENTRIES - 1].Score)
5025 for (k = 0; k < MAX_SCORE_ENTRIES; k++)
5027 if (game.score_final > highscore[k].Score)
5029 // player has made it to the hall of fame
5031 if (k < MAX_SCORE_ENTRIES - 1)
5033 int m = MAX_SCORE_ENTRIES - 1;
5035 if (one_score_entry_per_name)
5037 for (l = k; l < MAX_SCORE_ENTRIES; l++)
5038 if (strEqual(setup.player_name, highscore[l].Name))
5041 if (m == k) // player's new highscore overwrites his old one
5045 for (l = m; l > k; l--)
5047 strcpy(highscore[l].Name, highscore[l - 1].Name);
5048 highscore[l].Score = highscore[l - 1].Score;
5054 strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
5055 highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
5056 highscore[k].Score = game.score_final;
5061 else if (one_score_entry_per_name &&
5062 !strncmp(setup.player_name, highscore[k].Name,
5063 MAX_PLAYER_NAME_LEN))
5064 break; // player already there with a higher score
5068 SaveScore(level_nr);
5073 static int getElementMoveStepsizeExt(int x, int y, int direction)
5075 int element = Tile[x][y];
5076 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5077 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5078 int horiz_move = (dx != 0);
5079 int sign = (horiz_move ? dx : dy);
5080 int step = sign * element_info[element].move_stepsize;
5082 // special values for move stepsize for spring and things on conveyor belt
5085 if (CAN_FALL(element) &&
5086 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5087 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5088 else if (element == EL_SPRING)
5089 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5095 static int getElementMoveStepsize(int x, int y)
5097 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5100 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5102 if (player->GfxAction != action || player->GfxDir != dir)
5104 player->GfxAction = action;
5105 player->GfxDir = dir;
5107 player->StepFrame = 0;
5111 static void ResetGfxFrame(int x, int y)
5113 // profiling showed that "autotest" spends 10~20% of its time in this function
5114 if (DrawingDeactivatedField())
5117 int element = Tile[x][y];
5118 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5120 if (graphic_info[graphic].anim_global_sync)
5121 GfxFrame[x][y] = FrameCounter;
5122 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5123 GfxFrame[x][y] = CustomValue[x][y];
5124 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5125 GfxFrame[x][y] = element_info[element].collect_score;
5126 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5127 GfxFrame[x][y] = ChangeDelay[x][y];
5130 static void ResetGfxAnimation(int x, int y)
5132 GfxAction[x][y] = ACTION_DEFAULT;
5133 GfxDir[x][y] = MovDir[x][y];
5136 ResetGfxFrame(x, y);
5139 static void ResetRandomAnimationValue(int x, int y)
5141 GfxRandom[x][y] = INIT_GFX_RANDOM();
5144 static void InitMovingField(int x, int y, int direction)
5146 int element = Tile[x][y];
5147 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5148 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5151 boolean is_moving_before, is_moving_after;
5153 // check if element was/is moving or being moved before/after mode change
5154 is_moving_before = (WasJustMoving[x][y] != 0);
5155 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5157 // reset animation only for moving elements which change direction of moving
5158 // or which just started or stopped moving
5159 // (else CEs with property "can move" / "not moving" are reset each frame)
5160 if (is_moving_before != is_moving_after ||
5161 direction != MovDir[x][y])
5162 ResetGfxAnimation(x, y);
5164 MovDir[x][y] = direction;
5165 GfxDir[x][y] = direction;
5167 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5168 direction == MV_DOWN && CAN_FALL(element) ?
5169 ACTION_FALLING : ACTION_MOVING);
5171 // this is needed for CEs with property "can move" / "not moving"
5173 if (is_moving_after)
5175 if (Tile[newx][newy] == EL_EMPTY)
5176 Tile[newx][newy] = EL_BLOCKED;
5178 MovDir[newx][newy] = MovDir[x][y];
5180 CustomValue[newx][newy] = CustomValue[x][y];
5182 GfxFrame[newx][newy] = GfxFrame[x][y];
5183 GfxRandom[newx][newy] = GfxRandom[x][y];
5184 GfxAction[newx][newy] = GfxAction[x][y];
5185 GfxDir[newx][newy] = GfxDir[x][y];
5189 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5191 int direction = MovDir[x][y];
5192 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5193 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5199 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5201 int oldx = x, oldy = y;
5202 int direction = MovDir[x][y];
5204 if (direction == MV_LEFT)
5206 else if (direction == MV_RIGHT)
5208 else if (direction == MV_UP)
5210 else if (direction == MV_DOWN)
5213 *comes_from_x = oldx;
5214 *comes_from_y = oldy;
5217 static int MovingOrBlocked2Element(int x, int y)
5219 int element = Tile[x][y];
5221 if (element == EL_BLOCKED)
5225 Blocked2Moving(x, y, &oldx, &oldy);
5226 return Tile[oldx][oldy];
5232 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5234 // like MovingOrBlocked2Element(), but if element is moving
5235 // and (x,y) is the field the moving element is just leaving,
5236 // return EL_BLOCKED instead of the element value
5237 int element = Tile[x][y];
5239 if (IS_MOVING(x, y))
5241 if (element == EL_BLOCKED)
5245 Blocked2Moving(x, y, &oldx, &oldy);
5246 return Tile[oldx][oldy];
5255 static void RemoveField(int x, int y)
5257 Tile[x][y] = EL_EMPTY;
5263 CustomValue[x][y] = 0;
5266 ChangeDelay[x][y] = 0;
5267 ChangePage[x][y] = -1;
5268 Pushed[x][y] = FALSE;
5270 GfxElement[x][y] = EL_UNDEFINED;
5271 GfxAction[x][y] = ACTION_DEFAULT;
5272 GfxDir[x][y] = MV_NONE;
5275 static void RemoveMovingField(int x, int y)
5277 int oldx = x, oldy = y, newx = x, newy = y;
5278 int element = Tile[x][y];
5279 int next_element = EL_UNDEFINED;
5281 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5284 if (IS_MOVING(x, y))
5286 Moving2Blocked(x, y, &newx, &newy);
5288 if (Tile[newx][newy] != EL_BLOCKED)
5290 // element is moving, but target field is not free (blocked), but
5291 // already occupied by something different (example: acid pool);
5292 // in this case, only remove the moving field, but not the target
5294 RemoveField(oldx, oldy);
5296 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5298 TEST_DrawLevelField(oldx, oldy);
5303 else if (element == EL_BLOCKED)
5305 Blocked2Moving(x, y, &oldx, &oldy);
5306 if (!IS_MOVING(oldx, oldy))
5310 if (element == EL_BLOCKED &&
5311 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5312 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5313 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5314 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5315 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5316 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5317 next_element = get_next_element(Tile[oldx][oldy]);
5319 RemoveField(oldx, oldy);
5320 RemoveField(newx, newy);
5322 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5324 if (next_element != EL_UNDEFINED)
5325 Tile[oldx][oldy] = next_element;
5327 TEST_DrawLevelField(oldx, oldy);
5328 TEST_DrawLevelField(newx, newy);
5331 void DrawDynamite(int x, int y)
5333 int sx = SCREENX(x), sy = SCREENY(y);
5334 int graphic = el2img(Tile[x][y]);
5337 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5340 if (IS_WALKABLE_INSIDE(Back[x][y]))
5344 DrawGraphic(sx, sy, el2img(Back[x][y]), 0);
5345 else if (Store[x][y])
5346 DrawGraphic(sx, sy, el2img(Store[x][y]), 0);
5348 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5350 if (Back[x][y] || Store[x][y])
5351 DrawGraphicThruMask(sx, sy, graphic, frame);
5353 DrawGraphic(sx, sy, graphic, frame);
5356 static void CheckDynamite(int x, int y)
5358 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5362 if (MovDelay[x][y] != 0)
5365 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5371 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5376 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5378 boolean num_checked_players = 0;
5381 for (i = 0; i < MAX_PLAYERS; i++)
5383 if (stored_player[i].active)
5385 int sx = stored_player[i].jx;
5386 int sy = stored_player[i].jy;
5388 if (num_checked_players == 0)
5395 *sx1 = MIN(*sx1, sx);
5396 *sy1 = MIN(*sy1, sy);
5397 *sx2 = MAX(*sx2, sx);
5398 *sy2 = MAX(*sy2, sy);
5401 num_checked_players++;
5406 static boolean checkIfAllPlayersFitToScreen_RND(void)
5408 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5410 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5412 return (sx2 - sx1 < SCR_FIELDX &&
5413 sy2 - sy1 < SCR_FIELDY);
5416 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5418 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5420 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5422 *sx = (sx1 + sx2) / 2;
5423 *sy = (sy1 + sy2) / 2;
5426 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5427 boolean center_screen, boolean quick_relocation)
5429 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5430 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5431 boolean no_delay = (tape.warp_forward);
5432 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5433 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5434 int new_scroll_x, new_scroll_y;
5436 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5438 // case 1: quick relocation inside visible screen (without scrolling)
5445 if (!level.shifted_relocation || center_screen)
5447 // relocation _with_ centering of screen
5449 new_scroll_x = SCROLL_POSITION_X(x);
5450 new_scroll_y = SCROLL_POSITION_Y(y);
5454 // relocation _without_ centering of screen
5456 int center_scroll_x = SCROLL_POSITION_X(old_x);
5457 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5458 int offset_x = x + (scroll_x - center_scroll_x);
5459 int offset_y = y + (scroll_y - center_scroll_y);
5461 // for new screen position, apply previous offset to center position
5462 new_scroll_x = SCROLL_POSITION_X(offset_x);
5463 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5466 if (quick_relocation)
5468 // case 2: quick relocation (redraw without visible scrolling)
5470 scroll_x = new_scroll_x;
5471 scroll_y = new_scroll_y;
5478 // case 3: visible relocation (with scrolling to new position)
5480 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5482 SetVideoFrameDelay(wait_delay_value);
5484 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5486 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5487 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5489 if (dx == 0 && dy == 0) // no scrolling needed at all
5495 // set values for horizontal/vertical screen scrolling (half tile size)
5496 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5497 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5498 int pos_x = dx * TILEX / 2;
5499 int pos_y = dy * TILEY / 2;
5500 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5501 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5503 ScrollLevel(dx, dy);
5506 // scroll in two steps of half tile size to make things smoother
5507 BlitScreenToBitmapExt_RND(window, fx, fy);
5509 // scroll second step to align at full tile size
5510 BlitScreenToBitmap(window);
5516 SetVideoFrameDelay(frame_delay_value_old);
5519 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5521 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5522 int player_nr = GET_PLAYER_NR(el_player);
5523 struct PlayerInfo *player = &stored_player[player_nr];
5524 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5525 boolean no_delay = (tape.warp_forward);
5526 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5527 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5528 int old_jx = player->jx;
5529 int old_jy = player->jy;
5530 int old_element = Tile[old_jx][old_jy];
5531 int element = Tile[jx][jy];
5532 boolean player_relocated = (old_jx != jx || old_jy != jy);
5534 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5535 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5536 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5537 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5538 int leave_side_horiz = move_dir_horiz;
5539 int leave_side_vert = move_dir_vert;
5540 int enter_side = enter_side_horiz | enter_side_vert;
5541 int leave_side = leave_side_horiz | leave_side_vert;
5543 if (player->buried) // do not reanimate dead player
5546 if (!player_relocated) // no need to relocate the player
5549 if (IS_PLAYER(jx, jy)) // player already placed at new position
5551 RemoveField(jx, jy); // temporarily remove newly placed player
5552 DrawLevelField(jx, jy);
5555 if (player->present)
5557 while (player->MovPos)
5559 ScrollPlayer(player, SCROLL_GO_ON);
5560 ScrollScreen(NULL, SCROLL_GO_ON);
5562 AdvanceFrameAndPlayerCounters(player->index_nr);
5566 BackToFront_WithFrameDelay(wait_delay_value);
5569 DrawPlayer(player); // needed here only to cleanup last field
5570 DrawLevelField(player->jx, player->jy); // remove player graphic
5572 player->is_moving = FALSE;
5575 if (IS_CUSTOM_ELEMENT(old_element))
5576 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5578 player->index_bit, leave_side);
5580 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5582 player->index_bit, leave_side);
5584 Tile[jx][jy] = el_player;
5585 InitPlayerField(jx, jy, el_player, TRUE);
5587 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5588 possible that the relocation target field did not contain a player element,
5589 but a walkable element, to which the new player was relocated -- in this
5590 case, restore that (already initialized!) element on the player field */
5591 if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
5593 Tile[jx][jy] = element; // restore previously existing element
5596 // only visually relocate centered player
5597 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5598 FALSE, level.instant_relocation);
5600 TestIfPlayerTouchesBadThing(jx, jy);
5601 TestIfPlayerTouchesCustomElement(jx, jy);
5603 if (IS_CUSTOM_ELEMENT(element))
5604 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5605 player->index_bit, enter_side);
5607 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5608 player->index_bit, enter_side);
5610 if (player->is_switching)
5612 /* ensure that relocation while still switching an element does not cause
5613 a new element to be treated as also switched directly after relocation
5614 (this is important for teleporter switches that teleport the player to
5615 a place where another teleporter switch is in the same direction, which
5616 would then incorrectly be treated as immediately switched before the
5617 direction key that caused the switch was released) */
5619 player->switch_x += jx - old_jx;
5620 player->switch_y += jy - old_jy;
5624 static void Explode(int ex, int ey, int phase, int mode)
5630 // !!! eliminate this variable !!!
5631 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5633 if (game.explosions_delayed)
5635 ExplodeField[ex][ey] = mode;
5639 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5641 int center_element = Tile[ex][ey];
5642 int artwork_element, explosion_element; // set these values later
5644 // remove things displayed in background while burning dynamite
5645 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5648 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5650 // put moving element to center field (and let it explode there)
5651 center_element = MovingOrBlocked2Element(ex, ey);
5652 RemoveMovingField(ex, ey);
5653 Tile[ex][ey] = center_element;
5656 // now "center_element" is finally determined -- set related values now
5657 artwork_element = center_element; // for custom player artwork
5658 explosion_element = center_element; // for custom player artwork
5660 if (IS_PLAYER(ex, ey))
5662 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5664 artwork_element = stored_player[player_nr].artwork_element;
5666 if (level.use_explosion_element[player_nr])
5668 explosion_element = level.explosion_element[player_nr];
5669 artwork_element = explosion_element;
5673 if (mode == EX_TYPE_NORMAL ||
5674 mode == EX_TYPE_CENTER ||
5675 mode == EX_TYPE_CROSS)
5676 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5678 last_phase = element_info[explosion_element].explosion_delay + 1;
5680 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5682 int xx = x - ex + 1;
5683 int yy = y - ey + 1;
5686 if (!IN_LEV_FIELD(x, y) ||
5687 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5688 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5691 element = Tile[x][y];
5693 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5695 element = MovingOrBlocked2Element(x, y);
5697 if (!IS_EXPLOSION_PROOF(element))
5698 RemoveMovingField(x, y);
5701 // indestructible elements can only explode in center (but not flames)
5702 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5703 mode == EX_TYPE_BORDER)) ||
5704 element == EL_FLAMES)
5707 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5708 behaviour, for example when touching a yamyam that explodes to rocks
5709 with active deadly shield, a rock is created under the player !!! */
5710 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5712 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5713 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5714 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5716 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5719 if (IS_ACTIVE_BOMB(element))
5721 // re-activate things under the bomb like gate or penguin
5722 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5729 // save walkable background elements while explosion on same tile
5730 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5731 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5732 Back[x][y] = element;
5734 // ignite explodable elements reached by other explosion
5735 if (element == EL_EXPLOSION)
5736 element = Store2[x][y];
5738 if (AmoebaNr[x][y] &&
5739 (element == EL_AMOEBA_FULL ||
5740 element == EL_BD_AMOEBA ||
5741 element == EL_AMOEBA_GROWING))
5743 AmoebaCnt[AmoebaNr[x][y]]--;
5744 AmoebaCnt2[AmoebaNr[x][y]]--;
5749 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5751 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5753 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5755 if (PLAYERINFO(ex, ey)->use_murphy)
5756 Store[x][y] = EL_EMPTY;
5759 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5760 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5761 else if (ELEM_IS_PLAYER(center_element))
5762 Store[x][y] = EL_EMPTY;
5763 else if (center_element == EL_YAMYAM)
5764 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5765 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5766 Store[x][y] = element_info[center_element].content.e[xx][yy];
5768 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5769 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5770 // otherwise) -- FIX THIS !!!
5771 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5772 Store[x][y] = element_info[element].content.e[1][1];
5774 else if (!CAN_EXPLODE(element))
5775 Store[x][y] = element_info[element].content.e[1][1];
5778 Store[x][y] = EL_EMPTY;
5780 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5781 center_element == EL_AMOEBA_TO_DIAMOND)
5782 Store2[x][y] = element;
5784 Tile[x][y] = EL_EXPLOSION;
5785 GfxElement[x][y] = artwork_element;
5787 ExplodePhase[x][y] = 1;
5788 ExplodeDelay[x][y] = last_phase;
5793 if (center_element == EL_YAMYAM)
5794 game.yamyam_content_nr =
5795 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5807 GfxFrame[x][y] = 0; // restart explosion animation
5809 last_phase = ExplodeDelay[x][y];
5811 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5813 // this can happen if the player leaves an explosion just in time
5814 if (GfxElement[x][y] == EL_UNDEFINED)
5815 GfxElement[x][y] = EL_EMPTY;
5817 border_element = Store2[x][y];
5818 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5819 border_element = StorePlayer[x][y];
5821 if (phase == element_info[border_element].ignition_delay ||
5822 phase == last_phase)
5824 boolean border_explosion = FALSE;
5826 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5827 !PLAYER_EXPLOSION_PROTECTED(x, y))
5829 KillPlayerUnlessExplosionProtected(x, y);
5830 border_explosion = TRUE;
5832 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5834 Tile[x][y] = Store2[x][y];
5837 border_explosion = TRUE;
5839 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5841 AmoebaToDiamond(x, y);
5843 border_explosion = TRUE;
5846 // if an element just explodes due to another explosion (chain-reaction),
5847 // do not immediately end the new explosion when it was the last frame of
5848 // the explosion (as it would be done in the following "if"-statement!)
5849 if (border_explosion && phase == last_phase)
5853 if (phase == last_phase)
5857 element = Tile[x][y] = Store[x][y];
5858 Store[x][y] = Store2[x][y] = 0;
5859 GfxElement[x][y] = EL_UNDEFINED;
5861 // player can escape from explosions and might therefore be still alive
5862 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5863 element <= EL_PLAYER_IS_EXPLODING_4)
5865 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5866 int explosion_element = EL_PLAYER_1 + player_nr;
5867 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5868 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5870 if (level.use_explosion_element[player_nr])
5871 explosion_element = level.explosion_element[player_nr];
5873 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5874 element_info[explosion_element].content.e[xx][yy]);
5877 // restore probably existing indestructible background element
5878 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5879 element = Tile[x][y] = Back[x][y];
5882 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5883 GfxDir[x][y] = MV_NONE;
5884 ChangeDelay[x][y] = 0;
5885 ChangePage[x][y] = -1;
5887 CustomValue[x][y] = 0;
5889 InitField_WithBug2(x, y, FALSE);
5891 TEST_DrawLevelField(x, y);
5893 TestIfElementTouchesCustomElement(x, y);
5895 if (GFX_CRUMBLED(element))
5896 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5898 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5899 StorePlayer[x][y] = 0;
5901 if (ELEM_IS_PLAYER(element))
5902 RelocatePlayer(x, y, element);
5904 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5906 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
5907 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5910 TEST_DrawLevelFieldCrumbled(x, y);
5912 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
5914 DrawLevelElement(x, y, Back[x][y]);
5915 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
5917 else if (IS_WALKABLE_UNDER(Back[x][y]))
5919 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5920 DrawLevelElementThruMask(x, y, Back[x][y]);
5922 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
5923 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5927 static void DynaExplode(int ex, int ey)
5930 int dynabomb_element = Tile[ex][ey];
5931 int dynabomb_size = 1;
5932 boolean dynabomb_xl = FALSE;
5933 struct PlayerInfo *player;
5934 static int xy[4][2] =
5942 if (IS_ACTIVE_BOMB(dynabomb_element))
5944 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
5945 dynabomb_size = player->dynabomb_size;
5946 dynabomb_xl = player->dynabomb_xl;
5947 player->dynabombs_left++;
5950 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
5952 for (i = 0; i < NUM_DIRECTIONS; i++)
5954 for (j = 1; j <= dynabomb_size; j++)
5956 int x = ex + j * xy[i][0];
5957 int y = ey + j * xy[i][1];
5960 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
5963 element = Tile[x][y];
5965 // do not restart explosions of fields with active bombs
5966 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
5969 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
5971 if (element != EL_EMPTY && element != EL_EXPLOSION &&
5972 !IS_DIGGABLE(element) && !dynabomb_xl)
5978 void Bang(int x, int y)
5980 int element = MovingOrBlocked2Element(x, y);
5981 int explosion_type = EX_TYPE_NORMAL;
5983 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5985 struct PlayerInfo *player = PLAYERINFO(x, y);
5987 element = Tile[x][y] = player->initial_element;
5989 if (level.use_explosion_element[player->index_nr])
5991 int explosion_element = level.explosion_element[player->index_nr];
5993 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
5994 explosion_type = EX_TYPE_CROSS;
5995 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
5996 explosion_type = EX_TYPE_CENTER;
6004 case EL_BD_BUTTERFLY:
6007 case EL_DARK_YAMYAM:
6011 RaiseScoreElement(element);
6014 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6015 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6016 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6017 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6018 case EL_DYNABOMB_INCREASE_NUMBER:
6019 case EL_DYNABOMB_INCREASE_SIZE:
6020 case EL_DYNABOMB_INCREASE_POWER:
6021 explosion_type = EX_TYPE_DYNA;
6024 case EL_DC_LANDMINE:
6025 explosion_type = EX_TYPE_CENTER;
6030 case EL_LAMP_ACTIVE:
6031 case EL_AMOEBA_TO_DIAMOND:
6032 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6033 explosion_type = EX_TYPE_CENTER;
6037 if (element_info[element].explosion_type == EXPLODES_CROSS)
6038 explosion_type = EX_TYPE_CROSS;
6039 else if (element_info[element].explosion_type == EXPLODES_1X1)
6040 explosion_type = EX_TYPE_CENTER;
6044 if (explosion_type == EX_TYPE_DYNA)
6047 Explode(x, y, EX_PHASE_START, explosion_type);
6049 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6052 static void SplashAcid(int x, int y)
6054 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6055 (!IN_LEV_FIELD(x - 1, y - 2) ||
6056 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6057 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6059 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6060 (!IN_LEV_FIELD(x + 1, y - 2) ||
6061 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6062 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6064 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6067 static void InitBeltMovement(void)
6069 static int belt_base_element[4] =
6071 EL_CONVEYOR_BELT_1_LEFT,
6072 EL_CONVEYOR_BELT_2_LEFT,
6073 EL_CONVEYOR_BELT_3_LEFT,
6074 EL_CONVEYOR_BELT_4_LEFT
6076 static int belt_base_active_element[4] =
6078 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6079 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6080 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6081 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6086 // set frame order for belt animation graphic according to belt direction
6087 for (i = 0; i < NUM_BELTS; i++)
6091 for (j = 0; j < NUM_BELT_PARTS; j++)
6093 int element = belt_base_active_element[belt_nr] + j;
6094 int graphic_1 = el2img(element);
6095 int graphic_2 = el2panelimg(element);
6097 if (game.belt_dir[i] == MV_LEFT)
6099 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6100 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6104 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6105 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6110 SCAN_PLAYFIELD(x, y)
6112 int element = Tile[x][y];
6114 for (i = 0; i < NUM_BELTS; i++)
6116 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6118 int e_belt_nr = getBeltNrFromBeltElement(element);
6121 if (e_belt_nr == belt_nr)
6123 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6125 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6132 static void ToggleBeltSwitch(int x, int y)
6134 static int belt_base_element[4] =
6136 EL_CONVEYOR_BELT_1_LEFT,
6137 EL_CONVEYOR_BELT_2_LEFT,
6138 EL_CONVEYOR_BELT_3_LEFT,
6139 EL_CONVEYOR_BELT_4_LEFT
6141 static int belt_base_active_element[4] =
6143 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6144 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6145 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6146 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6148 static int belt_base_switch_element[4] =
6150 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6151 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6152 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6153 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6155 static int belt_move_dir[4] =
6163 int element = Tile[x][y];
6164 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6165 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6166 int belt_dir = belt_move_dir[belt_dir_nr];
6169 if (!IS_BELT_SWITCH(element))
6172 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6173 game.belt_dir[belt_nr] = belt_dir;
6175 if (belt_dir_nr == 3)
6178 // set frame order for belt animation graphic according to belt direction
6179 for (i = 0; i < NUM_BELT_PARTS; i++)
6181 int element = belt_base_active_element[belt_nr] + i;
6182 int graphic_1 = el2img(element);
6183 int graphic_2 = el2panelimg(element);
6185 if (belt_dir == MV_LEFT)
6187 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6188 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6192 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6193 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6197 SCAN_PLAYFIELD(xx, yy)
6199 int element = Tile[xx][yy];
6201 if (IS_BELT_SWITCH(element))
6203 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6205 if (e_belt_nr == belt_nr)
6207 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6208 TEST_DrawLevelField(xx, yy);
6211 else if (IS_BELT(element) && belt_dir != MV_NONE)
6213 int e_belt_nr = getBeltNrFromBeltElement(element);
6215 if (e_belt_nr == belt_nr)
6217 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6219 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6220 TEST_DrawLevelField(xx, yy);
6223 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6225 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6227 if (e_belt_nr == belt_nr)
6229 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6231 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6232 TEST_DrawLevelField(xx, yy);
6238 static void ToggleSwitchgateSwitch(int x, int y)
6242 game.switchgate_pos = !game.switchgate_pos;
6244 SCAN_PLAYFIELD(xx, yy)
6246 int element = Tile[xx][yy];
6248 if (element == EL_SWITCHGATE_SWITCH_UP)
6250 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6251 TEST_DrawLevelField(xx, yy);
6253 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6255 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6256 TEST_DrawLevelField(xx, yy);
6258 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6260 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6261 TEST_DrawLevelField(xx, yy);
6263 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6265 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6266 TEST_DrawLevelField(xx, yy);
6268 else if (element == EL_SWITCHGATE_OPEN ||
6269 element == EL_SWITCHGATE_OPENING)
6271 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6273 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6275 else if (element == EL_SWITCHGATE_CLOSED ||
6276 element == EL_SWITCHGATE_CLOSING)
6278 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6280 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6285 static int getInvisibleActiveFromInvisibleElement(int element)
6287 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6288 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6289 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6293 static int getInvisibleFromInvisibleActiveElement(int element)
6295 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6296 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6297 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6301 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6305 SCAN_PLAYFIELD(x, y)
6307 int element = Tile[x][y];
6309 if (element == EL_LIGHT_SWITCH &&
6310 game.light_time_left > 0)
6312 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6313 TEST_DrawLevelField(x, y);
6315 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6316 game.light_time_left == 0)
6318 Tile[x][y] = EL_LIGHT_SWITCH;
6319 TEST_DrawLevelField(x, y);
6321 else if (element == EL_EMC_DRIPPER &&
6322 game.light_time_left > 0)
6324 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6325 TEST_DrawLevelField(x, y);
6327 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6328 game.light_time_left == 0)
6330 Tile[x][y] = EL_EMC_DRIPPER;
6331 TEST_DrawLevelField(x, y);
6333 else if (element == EL_INVISIBLE_STEELWALL ||
6334 element == EL_INVISIBLE_WALL ||
6335 element == EL_INVISIBLE_SAND)
6337 if (game.light_time_left > 0)
6338 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6340 TEST_DrawLevelField(x, y);
6342 // uncrumble neighbour fields, if needed
6343 if (element == EL_INVISIBLE_SAND)
6344 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6346 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6347 element == EL_INVISIBLE_WALL_ACTIVE ||
6348 element == EL_INVISIBLE_SAND_ACTIVE)
6350 if (game.light_time_left == 0)
6351 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6353 TEST_DrawLevelField(x, y);
6355 // re-crumble neighbour fields, if needed
6356 if (element == EL_INVISIBLE_SAND)
6357 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6362 static void RedrawAllInvisibleElementsForLenses(void)
6366 SCAN_PLAYFIELD(x, y)
6368 int element = Tile[x][y];
6370 if (element == EL_EMC_DRIPPER &&
6371 game.lenses_time_left > 0)
6373 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6374 TEST_DrawLevelField(x, y);
6376 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6377 game.lenses_time_left == 0)
6379 Tile[x][y] = EL_EMC_DRIPPER;
6380 TEST_DrawLevelField(x, y);
6382 else if (element == EL_INVISIBLE_STEELWALL ||
6383 element == EL_INVISIBLE_WALL ||
6384 element == EL_INVISIBLE_SAND)
6386 if (game.lenses_time_left > 0)
6387 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6389 TEST_DrawLevelField(x, y);
6391 // uncrumble neighbour fields, if needed
6392 if (element == EL_INVISIBLE_SAND)
6393 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6395 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6396 element == EL_INVISIBLE_WALL_ACTIVE ||
6397 element == EL_INVISIBLE_SAND_ACTIVE)
6399 if (game.lenses_time_left == 0)
6400 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6402 TEST_DrawLevelField(x, y);
6404 // re-crumble neighbour fields, if needed
6405 if (element == EL_INVISIBLE_SAND)
6406 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6411 static void RedrawAllInvisibleElementsForMagnifier(void)
6415 SCAN_PLAYFIELD(x, y)
6417 int element = Tile[x][y];
6419 if (element == EL_EMC_FAKE_GRASS &&
6420 game.magnify_time_left > 0)
6422 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6423 TEST_DrawLevelField(x, y);
6425 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6426 game.magnify_time_left == 0)
6428 Tile[x][y] = EL_EMC_FAKE_GRASS;
6429 TEST_DrawLevelField(x, y);
6431 else if (IS_GATE_GRAY(element) &&
6432 game.magnify_time_left > 0)
6434 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6435 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6436 IS_EM_GATE_GRAY(element) ?
6437 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6438 IS_EMC_GATE_GRAY(element) ?
6439 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6440 IS_DC_GATE_GRAY(element) ?
6441 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6443 TEST_DrawLevelField(x, y);
6445 else if (IS_GATE_GRAY_ACTIVE(element) &&
6446 game.magnify_time_left == 0)
6448 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6449 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6450 IS_EM_GATE_GRAY_ACTIVE(element) ?
6451 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6452 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6453 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6454 IS_DC_GATE_GRAY_ACTIVE(element) ?
6455 EL_DC_GATE_WHITE_GRAY :
6457 TEST_DrawLevelField(x, y);
6462 static void ToggleLightSwitch(int x, int y)
6464 int element = Tile[x][y];
6466 game.light_time_left =
6467 (element == EL_LIGHT_SWITCH ?
6468 level.time_light * FRAMES_PER_SECOND : 0);
6470 RedrawAllLightSwitchesAndInvisibleElements();
6473 static void ActivateTimegateSwitch(int x, int y)
6477 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6479 SCAN_PLAYFIELD(xx, yy)
6481 int element = Tile[xx][yy];
6483 if (element == EL_TIMEGATE_CLOSED ||
6484 element == EL_TIMEGATE_CLOSING)
6486 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6487 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6491 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6493 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6494 TEST_DrawLevelField(xx, yy);
6500 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6501 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6504 static void Impact(int x, int y)
6506 boolean last_line = (y == lev_fieldy - 1);
6507 boolean object_hit = FALSE;
6508 boolean impact = (last_line || object_hit);
6509 int element = Tile[x][y];
6510 int smashed = EL_STEELWALL;
6512 if (!last_line) // check if element below was hit
6514 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6517 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6518 MovDir[x][y + 1] != MV_DOWN ||
6519 MovPos[x][y + 1] <= TILEY / 2));
6521 // do not smash moving elements that left the smashed field in time
6522 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6523 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6526 #if USE_QUICKSAND_IMPACT_BUGFIX
6527 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6529 RemoveMovingField(x, y + 1);
6530 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6531 Tile[x][y + 2] = EL_ROCK;
6532 TEST_DrawLevelField(x, y + 2);
6537 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6539 RemoveMovingField(x, y + 1);
6540 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6541 Tile[x][y + 2] = EL_ROCK;
6542 TEST_DrawLevelField(x, y + 2);
6549 smashed = MovingOrBlocked2Element(x, y + 1);
6551 impact = (last_line || object_hit);
6554 if (!last_line && smashed == EL_ACID) // element falls into acid
6556 SplashAcid(x, y + 1);
6560 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6561 // only reset graphic animation if graphic really changes after impact
6563 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6565 ResetGfxAnimation(x, y);
6566 TEST_DrawLevelField(x, y);
6569 if (impact && CAN_EXPLODE_IMPACT(element))
6574 else if (impact && element == EL_PEARL &&
6575 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6577 ResetGfxAnimation(x, y);
6579 Tile[x][y] = EL_PEARL_BREAKING;
6580 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6583 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6585 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6590 if (impact && element == EL_AMOEBA_DROP)
6592 if (object_hit && IS_PLAYER(x, y + 1))
6593 KillPlayerUnlessEnemyProtected(x, y + 1);
6594 else if (object_hit && smashed == EL_PENGUIN)
6598 Tile[x][y] = EL_AMOEBA_GROWING;
6599 Store[x][y] = EL_AMOEBA_WET;
6601 ResetRandomAnimationValue(x, y);
6606 if (object_hit) // check which object was hit
6608 if ((CAN_PASS_MAGIC_WALL(element) &&
6609 (smashed == EL_MAGIC_WALL ||
6610 smashed == EL_BD_MAGIC_WALL)) ||
6611 (CAN_PASS_DC_MAGIC_WALL(element) &&
6612 smashed == EL_DC_MAGIC_WALL))
6615 int activated_magic_wall =
6616 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6617 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6618 EL_DC_MAGIC_WALL_ACTIVE);
6620 // activate magic wall / mill
6621 SCAN_PLAYFIELD(xx, yy)
6623 if (Tile[xx][yy] == smashed)
6624 Tile[xx][yy] = activated_magic_wall;
6627 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6628 game.magic_wall_active = TRUE;
6630 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6631 SND_MAGIC_WALL_ACTIVATING :
6632 smashed == EL_BD_MAGIC_WALL ?
6633 SND_BD_MAGIC_WALL_ACTIVATING :
6634 SND_DC_MAGIC_WALL_ACTIVATING));
6637 if (IS_PLAYER(x, y + 1))
6639 if (CAN_SMASH_PLAYER(element))
6641 KillPlayerUnlessEnemyProtected(x, y + 1);
6645 else if (smashed == EL_PENGUIN)
6647 if (CAN_SMASH_PLAYER(element))
6653 else if (element == EL_BD_DIAMOND)
6655 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6661 else if (((element == EL_SP_INFOTRON ||
6662 element == EL_SP_ZONK) &&
6663 (smashed == EL_SP_SNIKSNAK ||
6664 smashed == EL_SP_ELECTRON ||
6665 smashed == EL_SP_DISK_ORANGE)) ||
6666 (element == EL_SP_INFOTRON &&
6667 smashed == EL_SP_DISK_YELLOW))
6672 else if (CAN_SMASH_EVERYTHING(element))
6674 if (IS_CLASSIC_ENEMY(smashed) ||
6675 CAN_EXPLODE_SMASHED(smashed))
6680 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6682 if (smashed == EL_LAMP ||
6683 smashed == EL_LAMP_ACTIVE)
6688 else if (smashed == EL_NUT)
6690 Tile[x][y + 1] = EL_NUT_BREAKING;
6691 PlayLevelSound(x, y, SND_NUT_BREAKING);
6692 RaiseScoreElement(EL_NUT);
6695 else if (smashed == EL_PEARL)
6697 ResetGfxAnimation(x, y);
6699 Tile[x][y + 1] = EL_PEARL_BREAKING;
6700 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6703 else if (smashed == EL_DIAMOND)
6705 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6706 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6709 else if (IS_BELT_SWITCH(smashed))
6711 ToggleBeltSwitch(x, y + 1);
6713 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6714 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6715 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6716 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6718 ToggleSwitchgateSwitch(x, y + 1);
6720 else if (smashed == EL_LIGHT_SWITCH ||
6721 smashed == EL_LIGHT_SWITCH_ACTIVE)
6723 ToggleLightSwitch(x, y + 1);
6727 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6729 CheckElementChangeBySide(x, y + 1, smashed, element,
6730 CE_SWITCHED, CH_SIDE_TOP);
6731 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6737 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6742 // play sound of magic wall / mill
6744 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6745 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6746 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6748 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6749 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6750 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6751 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6752 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6753 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6758 // play sound of object that hits the ground
6759 if (last_line || object_hit)
6760 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6763 static void TurnRoundExt(int x, int y)
6775 { 0, 0 }, { 0, 0 }, { 0, 0 },
6780 int left, right, back;
6784 { MV_DOWN, MV_UP, MV_RIGHT },
6785 { MV_UP, MV_DOWN, MV_LEFT },
6787 { MV_LEFT, MV_RIGHT, MV_DOWN },
6791 { MV_RIGHT, MV_LEFT, MV_UP }
6794 int element = Tile[x][y];
6795 int move_pattern = element_info[element].move_pattern;
6797 int old_move_dir = MovDir[x][y];
6798 int left_dir = turn[old_move_dir].left;
6799 int right_dir = turn[old_move_dir].right;
6800 int back_dir = turn[old_move_dir].back;
6802 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6803 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6804 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6805 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6807 int left_x = x + left_dx, left_y = y + left_dy;
6808 int right_x = x + right_dx, right_y = y + right_dy;
6809 int move_x = x + move_dx, move_y = y + move_dy;
6813 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6815 TestIfBadThingTouchesOtherBadThing(x, y);
6817 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6818 MovDir[x][y] = right_dir;
6819 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6820 MovDir[x][y] = left_dir;
6822 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6824 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6827 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6829 TestIfBadThingTouchesOtherBadThing(x, y);
6831 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6832 MovDir[x][y] = left_dir;
6833 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6834 MovDir[x][y] = right_dir;
6836 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6838 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6841 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6843 TestIfBadThingTouchesOtherBadThing(x, y);
6845 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6846 MovDir[x][y] = left_dir;
6847 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6848 MovDir[x][y] = right_dir;
6850 if (MovDir[x][y] != old_move_dir)
6853 else if (element == EL_YAMYAM)
6855 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6856 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6858 if (can_turn_left && can_turn_right)
6859 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6860 else if (can_turn_left)
6861 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6862 else if (can_turn_right)
6863 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6865 MovDir[x][y] = back_dir;
6867 MovDelay[x][y] = 16 + 16 * RND(3);
6869 else if (element == EL_DARK_YAMYAM)
6871 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6873 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6876 if (can_turn_left && can_turn_right)
6877 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6878 else if (can_turn_left)
6879 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6880 else if (can_turn_right)
6881 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6883 MovDir[x][y] = back_dir;
6885 MovDelay[x][y] = 16 + 16 * RND(3);
6887 else if (element == EL_PACMAN)
6889 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6890 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6892 if (can_turn_left && can_turn_right)
6893 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6894 else if (can_turn_left)
6895 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6896 else if (can_turn_right)
6897 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6899 MovDir[x][y] = back_dir;
6901 MovDelay[x][y] = 6 + RND(40);
6903 else if (element == EL_PIG)
6905 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
6906 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
6907 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
6908 boolean should_turn_left, should_turn_right, should_move_on;
6910 int rnd = RND(rnd_value);
6912 should_turn_left = (can_turn_left &&
6914 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
6915 y + back_dy + left_dy)));
6916 should_turn_right = (can_turn_right &&
6918 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
6919 y + back_dy + right_dy)));
6920 should_move_on = (can_move_on &&
6923 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
6924 y + move_dy + left_dy) ||
6925 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
6926 y + move_dy + right_dy)));
6928 if (should_turn_left || should_turn_right || should_move_on)
6930 if (should_turn_left && should_turn_right && should_move_on)
6931 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
6932 rnd < 2 * rnd_value / 3 ? right_dir :
6934 else if (should_turn_left && should_turn_right)
6935 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6936 else if (should_turn_left && should_move_on)
6937 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
6938 else if (should_turn_right && should_move_on)
6939 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
6940 else if (should_turn_left)
6941 MovDir[x][y] = left_dir;
6942 else if (should_turn_right)
6943 MovDir[x][y] = right_dir;
6944 else if (should_move_on)
6945 MovDir[x][y] = old_move_dir;
6947 else if (can_move_on && rnd > rnd_value / 8)
6948 MovDir[x][y] = old_move_dir;
6949 else if (can_turn_left && can_turn_right)
6950 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6951 else if (can_turn_left && rnd > rnd_value / 8)
6952 MovDir[x][y] = left_dir;
6953 else if (can_turn_right && rnd > rnd_value/8)
6954 MovDir[x][y] = right_dir;
6956 MovDir[x][y] = back_dir;
6958 xx = x + move_xy[MovDir[x][y]].dx;
6959 yy = y + move_xy[MovDir[x][y]].dy;
6961 if (!IN_LEV_FIELD(xx, yy) ||
6962 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
6963 MovDir[x][y] = old_move_dir;
6967 else if (element == EL_DRAGON)
6969 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
6970 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
6971 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
6973 int rnd = RND(rnd_value);
6975 if (can_move_on && rnd > rnd_value / 8)
6976 MovDir[x][y] = old_move_dir;
6977 else if (can_turn_left && can_turn_right)
6978 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6979 else if (can_turn_left && rnd > rnd_value / 8)
6980 MovDir[x][y] = left_dir;
6981 else if (can_turn_right && rnd > rnd_value / 8)
6982 MovDir[x][y] = right_dir;
6984 MovDir[x][y] = back_dir;
6986 xx = x + move_xy[MovDir[x][y]].dx;
6987 yy = y + move_xy[MovDir[x][y]].dy;
6989 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
6990 MovDir[x][y] = old_move_dir;
6994 else if (element == EL_MOLE)
6996 boolean can_move_on =
6997 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
6998 IS_AMOEBOID(Tile[move_x][move_y]) ||
6999 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7002 boolean can_turn_left =
7003 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7004 IS_AMOEBOID(Tile[left_x][left_y])));
7006 boolean can_turn_right =
7007 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7008 IS_AMOEBOID(Tile[right_x][right_y])));
7010 if (can_turn_left && can_turn_right)
7011 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7012 else if (can_turn_left)
7013 MovDir[x][y] = left_dir;
7015 MovDir[x][y] = right_dir;
7018 if (MovDir[x][y] != old_move_dir)
7021 else if (element == EL_BALLOON)
7023 MovDir[x][y] = game.wind_direction;
7026 else if (element == EL_SPRING)
7028 if (MovDir[x][y] & MV_HORIZONTAL)
7030 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7031 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7033 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7034 ResetGfxAnimation(move_x, move_y);
7035 TEST_DrawLevelField(move_x, move_y);
7037 MovDir[x][y] = back_dir;
7039 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7040 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7041 MovDir[x][y] = MV_NONE;
7046 else if (element == EL_ROBOT ||
7047 element == EL_SATELLITE ||
7048 element == EL_PENGUIN ||
7049 element == EL_EMC_ANDROID)
7051 int attr_x = -1, attr_y = -1;
7053 if (game.all_players_gone)
7055 attr_x = game.exit_x;
7056 attr_y = game.exit_y;
7062 for (i = 0; i < MAX_PLAYERS; i++)
7064 struct PlayerInfo *player = &stored_player[i];
7065 int jx = player->jx, jy = player->jy;
7067 if (!player->active)
7071 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7079 if (element == EL_ROBOT &&
7080 game.robot_wheel_x >= 0 &&
7081 game.robot_wheel_y >= 0 &&
7082 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7083 game.engine_version < VERSION_IDENT(3,1,0,0)))
7085 attr_x = game.robot_wheel_x;
7086 attr_y = game.robot_wheel_y;
7089 if (element == EL_PENGUIN)
7092 static int xy[4][2] =
7100 for (i = 0; i < NUM_DIRECTIONS; i++)
7102 int ex = x + xy[i][0];
7103 int ey = y + xy[i][1];
7105 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7106 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7107 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7108 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7117 MovDir[x][y] = MV_NONE;
7119 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7120 else if (attr_x > x)
7121 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7123 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7124 else if (attr_y > y)
7125 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7127 if (element == EL_ROBOT)
7131 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7132 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7133 Moving2Blocked(x, y, &newx, &newy);
7135 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7136 MovDelay[x][y] = 8 + 8 * !RND(3);
7138 MovDelay[x][y] = 16;
7140 else if (element == EL_PENGUIN)
7146 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7148 boolean first_horiz = RND(2);
7149 int new_move_dir = MovDir[x][y];
7152 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7153 Moving2Blocked(x, y, &newx, &newy);
7155 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7159 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7160 Moving2Blocked(x, y, &newx, &newy);
7162 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7165 MovDir[x][y] = old_move_dir;
7169 else if (element == EL_SATELLITE)
7175 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7177 boolean first_horiz = RND(2);
7178 int new_move_dir = MovDir[x][y];
7181 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7182 Moving2Blocked(x, y, &newx, &newy);
7184 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7188 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7189 Moving2Blocked(x, y, &newx, &newy);
7191 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7194 MovDir[x][y] = old_move_dir;
7198 else if (element == EL_EMC_ANDROID)
7200 static int check_pos[16] =
7202 -1, // 0 => (invalid)
7205 -1, // 3 => (invalid)
7207 0, // 5 => MV_LEFT | MV_UP
7208 2, // 6 => MV_RIGHT | MV_UP
7209 -1, // 7 => (invalid)
7211 6, // 9 => MV_LEFT | MV_DOWN
7212 4, // 10 => MV_RIGHT | MV_DOWN
7213 -1, // 11 => (invalid)
7214 -1, // 12 => (invalid)
7215 -1, // 13 => (invalid)
7216 -1, // 14 => (invalid)
7217 -1, // 15 => (invalid)
7225 { -1, -1, MV_LEFT | MV_UP },
7227 { +1, -1, MV_RIGHT | MV_UP },
7228 { +1, 0, MV_RIGHT },
7229 { +1, +1, MV_RIGHT | MV_DOWN },
7231 { -1, +1, MV_LEFT | MV_DOWN },
7234 int start_pos, check_order;
7235 boolean can_clone = FALSE;
7238 // check if there is any free field around current position
7239 for (i = 0; i < 8; i++)
7241 int newx = x + check_xy[i].dx;
7242 int newy = y + check_xy[i].dy;
7244 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7252 if (can_clone) // randomly find an element to clone
7256 start_pos = check_pos[RND(8)];
7257 check_order = (RND(2) ? -1 : +1);
7259 for (i = 0; i < 8; i++)
7261 int pos_raw = start_pos + i * check_order;
7262 int pos = (pos_raw + 8) % 8;
7263 int newx = x + check_xy[pos].dx;
7264 int newy = y + check_xy[pos].dy;
7266 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7268 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7269 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7271 Store[x][y] = Tile[newx][newy];
7280 if (can_clone) // randomly find a direction to move
7284 start_pos = check_pos[RND(8)];
7285 check_order = (RND(2) ? -1 : +1);
7287 for (i = 0; i < 8; i++)
7289 int pos_raw = start_pos + i * check_order;
7290 int pos = (pos_raw + 8) % 8;
7291 int newx = x + check_xy[pos].dx;
7292 int newy = y + check_xy[pos].dy;
7293 int new_move_dir = check_xy[pos].dir;
7295 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7297 MovDir[x][y] = new_move_dir;
7298 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7307 if (can_clone) // cloning and moving successful
7310 // cannot clone -- try to move towards player
7312 start_pos = check_pos[MovDir[x][y] & 0x0f];
7313 check_order = (RND(2) ? -1 : +1);
7315 for (i = 0; i < 3; i++)
7317 // first check start_pos, then previous/next or (next/previous) pos
7318 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7319 int pos = (pos_raw + 8) % 8;
7320 int newx = x + check_xy[pos].dx;
7321 int newy = y + check_xy[pos].dy;
7322 int new_move_dir = check_xy[pos].dir;
7324 if (IS_PLAYER(newx, newy))
7327 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7329 MovDir[x][y] = new_move_dir;
7330 MovDelay[x][y] = level.android_move_time * 8 + 1;
7337 else if (move_pattern == MV_TURNING_LEFT ||
7338 move_pattern == MV_TURNING_RIGHT ||
7339 move_pattern == MV_TURNING_LEFT_RIGHT ||
7340 move_pattern == MV_TURNING_RIGHT_LEFT ||
7341 move_pattern == MV_TURNING_RANDOM ||
7342 move_pattern == MV_ALL_DIRECTIONS)
7344 boolean can_turn_left =
7345 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7346 boolean can_turn_right =
7347 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7349 if (element_info[element].move_stepsize == 0) // "not moving"
7352 if (move_pattern == MV_TURNING_LEFT)
7353 MovDir[x][y] = left_dir;
7354 else if (move_pattern == MV_TURNING_RIGHT)
7355 MovDir[x][y] = right_dir;
7356 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7357 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7358 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7359 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7360 else if (move_pattern == MV_TURNING_RANDOM)
7361 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7362 can_turn_right && !can_turn_left ? right_dir :
7363 RND(2) ? left_dir : right_dir);
7364 else if (can_turn_left && can_turn_right)
7365 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7366 else if (can_turn_left)
7367 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7368 else if (can_turn_right)
7369 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7371 MovDir[x][y] = back_dir;
7373 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7375 else if (move_pattern == MV_HORIZONTAL ||
7376 move_pattern == MV_VERTICAL)
7378 if (move_pattern & old_move_dir)
7379 MovDir[x][y] = back_dir;
7380 else if (move_pattern == MV_HORIZONTAL)
7381 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7382 else if (move_pattern == MV_VERTICAL)
7383 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7385 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7387 else if (move_pattern & MV_ANY_DIRECTION)
7389 MovDir[x][y] = move_pattern;
7390 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7392 else if (move_pattern & MV_WIND_DIRECTION)
7394 MovDir[x][y] = game.wind_direction;
7395 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7397 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7399 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7400 MovDir[x][y] = left_dir;
7401 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7402 MovDir[x][y] = right_dir;
7404 if (MovDir[x][y] != old_move_dir)
7405 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7407 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7409 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7410 MovDir[x][y] = right_dir;
7411 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7412 MovDir[x][y] = left_dir;
7414 if (MovDir[x][y] != old_move_dir)
7415 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7417 else if (move_pattern == MV_TOWARDS_PLAYER ||
7418 move_pattern == MV_AWAY_FROM_PLAYER)
7420 int attr_x = -1, attr_y = -1;
7422 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7424 if (game.all_players_gone)
7426 attr_x = game.exit_x;
7427 attr_y = game.exit_y;
7433 for (i = 0; i < MAX_PLAYERS; i++)
7435 struct PlayerInfo *player = &stored_player[i];
7436 int jx = player->jx, jy = player->jy;
7438 if (!player->active)
7442 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7450 MovDir[x][y] = MV_NONE;
7452 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7453 else if (attr_x > x)
7454 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7456 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7457 else if (attr_y > y)
7458 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7460 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7462 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7464 boolean first_horiz = RND(2);
7465 int new_move_dir = MovDir[x][y];
7467 if (element_info[element].move_stepsize == 0) // "not moving"
7469 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7470 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7476 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7477 Moving2Blocked(x, y, &newx, &newy);
7479 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7483 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7484 Moving2Blocked(x, y, &newx, &newy);
7486 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7489 MovDir[x][y] = old_move_dir;
7492 else if (move_pattern == MV_WHEN_PUSHED ||
7493 move_pattern == MV_WHEN_DROPPED)
7495 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7496 MovDir[x][y] = MV_NONE;
7500 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7502 static int test_xy[7][2] =
7512 static int test_dir[7] =
7522 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7523 int move_preference = -1000000; // start with very low preference
7524 int new_move_dir = MV_NONE;
7525 int start_test = RND(4);
7528 for (i = 0; i < NUM_DIRECTIONS; i++)
7530 int move_dir = test_dir[start_test + i];
7531 int move_dir_preference;
7533 xx = x + test_xy[start_test + i][0];
7534 yy = y + test_xy[start_test + i][1];
7536 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7537 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7539 new_move_dir = move_dir;
7544 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7547 move_dir_preference = -1 * RunnerVisit[xx][yy];
7548 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7549 move_dir_preference = PlayerVisit[xx][yy];
7551 if (move_dir_preference > move_preference)
7553 // prefer field that has not been visited for the longest time
7554 move_preference = move_dir_preference;
7555 new_move_dir = move_dir;
7557 else if (move_dir_preference == move_preference &&
7558 move_dir == old_move_dir)
7560 // prefer last direction when all directions are preferred equally
7561 move_preference = move_dir_preference;
7562 new_move_dir = move_dir;
7566 MovDir[x][y] = new_move_dir;
7567 if (old_move_dir != new_move_dir)
7568 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7572 static void TurnRound(int x, int y)
7574 int direction = MovDir[x][y];
7578 GfxDir[x][y] = MovDir[x][y];
7580 if (direction != MovDir[x][y])
7584 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7586 ResetGfxFrame(x, y);
7589 static boolean JustBeingPushed(int x, int y)
7593 for (i = 0; i < MAX_PLAYERS; i++)
7595 struct PlayerInfo *player = &stored_player[i];
7597 if (player->active && player->is_pushing && player->MovPos)
7599 int next_jx = player->jx + (player->jx - player->last_jx);
7600 int next_jy = player->jy + (player->jy - player->last_jy);
7602 if (x == next_jx && y == next_jy)
7610 static void StartMoving(int x, int y)
7612 boolean started_moving = FALSE; // some elements can fall _and_ move
7613 int element = Tile[x][y];
7618 if (MovDelay[x][y] == 0)
7619 GfxAction[x][y] = ACTION_DEFAULT;
7621 if (CAN_FALL(element) && y < lev_fieldy - 1)
7623 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7624 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7625 if (JustBeingPushed(x, y))
7628 if (element == EL_QUICKSAND_FULL)
7630 if (IS_FREE(x, y + 1))
7632 InitMovingField(x, y, MV_DOWN);
7633 started_moving = TRUE;
7635 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7636 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7637 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7638 Store[x][y] = EL_ROCK;
7640 Store[x][y] = EL_ROCK;
7643 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7645 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7647 if (!MovDelay[x][y])
7649 MovDelay[x][y] = TILEY + 1;
7651 ResetGfxAnimation(x, y);
7652 ResetGfxAnimation(x, y + 1);
7657 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7658 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7665 Tile[x][y] = EL_QUICKSAND_EMPTY;
7666 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7667 Store[x][y + 1] = Store[x][y];
7670 PlayLevelSoundAction(x, y, ACTION_FILLING);
7672 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7674 if (!MovDelay[x][y])
7676 MovDelay[x][y] = TILEY + 1;
7678 ResetGfxAnimation(x, y);
7679 ResetGfxAnimation(x, y + 1);
7684 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7685 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7692 Tile[x][y] = EL_QUICKSAND_EMPTY;
7693 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7694 Store[x][y + 1] = Store[x][y];
7697 PlayLevelSoundAction(x, y, ACTION_FILLING);
7700 else if (element == EL_QUICKSAND_FAST_FULL)
7702 if (IS_FREE(x, y + 1))
7704 InitMovingField(x, y, MV_DOWN);
7705 started_moving = TRUE;
7707 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7708 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7709 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7710 Store[x][y] = EL_ROCK;
7712 Store[x][y] = EL_ROCK;
7715 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7717 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7719 if (!MovDelay[x][y])
7721 MovDelay[x][y] = TILEY + 1;
7723 ResetGfxAnimation(x, y);
7724 ResetGfxAnimation(x, y + 1);
7729 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7730 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7737 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7738 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7739 Store[x][y + 1] = Store[x][y];
7742 PlayLevelSoundAction(x, y, ACTION_FILLING);
7744 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7746 if (!MovDelay[x][y])
7748 MovDelay[x][y] = TILEY + 1;
7750 ResetGfxAnimation(x, y);
7751 ResetGfxAnimation(x, y + 1);
7756 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7757 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7764 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7765 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7766 Store[x][y + 1] = Store[x][y];
7769 PlayLevelSoundAction(x, y, ACTION_FILLING);
7772 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7773 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7775 InitMovingField(x, y, MV_DOWN);
7776 started_moving = TRUE;
7778 Tile[x][y] = EL_QUICKSAND_FILLING;
7779 Store[x][y] = element;
7781 PlayLevelSoundAction(x, y, ACTION_FILLING);
7783 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7784 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7786 InitMovingField(x, y, MV_DOWN);
7787 started_moving = TRUE;
7789 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7790 Store[x][y] = element;
7792 PlayLevelSoundAction(x, y, ACTION_FILLING);
7794 else if (element == EL_MAGIC_WALL_FULL)
7796 if (IS_FREE(x, y + 1))
7798 InitMovingField(x, y, MV_DOWN);
7799 started_moving = TRUE;
7801 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7802 Store[x][y] = EL_CHANGED(Store[x][y]);
7804 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7806 if (!MovDelay[x][y])
7807 MovDelay[x][y] = TILEY / 4 + 1;
7816 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7817 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7818 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7822 else if (element == EL_BD_MAGIC_WALL_FULL)
7824 if (IS_FREE(x, y + 1))
7826 InitMovingField(x, y, MV_DOWN);
7827 started_moving = TRUE;
7829 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7830 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7832 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7834 if (!MovDelay[x][y])
7835 MovDelay[x][y] = TILEY / 4 + 1;
7844 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7845 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7846 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7850 else if (element == EL_DC_MAGIC_WALL_FULL)
7852 if (IS_FREE(x, y + 1))
7854 InitMovingField(x, y, MV_DOWN);
7855 started_moving = TRUE;
7857 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7858 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7860 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7862 if (!MovDelay[x][y])
7863 MovDelay[x][y] = TILEY / 4 + 1;
7872 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7873 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7874 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7878 else if ((CAN_PASS_MAGIC_WALL(element) &&
7879 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7880 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7881 (CAN_PASS_DC_MAGIC_WALL(element) &&
7882 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7885 InitMovingField(x, y, MV_DOWN);
7886 started_moving = TRUE;
7889 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7890 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7891 EL_DC_MAGIC_WALL_FILLING);
7892 Store[x][y] = element;
7894 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7896 SplashAcid(x, y + 1);
7898 InitMovingField(x, y, MV_DOWN);
7899 started_moving = TRUE;
7901 Store[x][y] = EL_ACID;
7904 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
7905 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
7906 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
7907 CAN_FALL(element) && WasJustFalling[x][y] &&
7908 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
7910 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
7911 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
7912 (Tile[x][y + 1] == EL_BLOCKED)))
7914 /* this is needed for a special case not covered by calling "Impact()"
7915 from "ContinueMoving()": if an element moves to a tile directly below
7916 another element which was just falling on that tile (which was empty
7917 in the previous frame), the falling element above would just stop
7918 instead of smashing the element below (in previous version, the above
7919 element was just checked for "moving" instead of "falling", resulting
7920 in incorrect smashes caused by horizontal movement of the above
7921 element; also, the case of the player being the element to smash was
7922 simply not covered here... :-/ ) */
7924 CheckCollision[x][y] = 0;
7925 CheckImpact[x][y] = 0;
7929 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
7931 if (MovDir[x][y] == MV_NONE)
7933 InitMovingField(x, y, MV_DOWN);
7934 started_moving = TRUE;
7937 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
7939 if (WasJustFalling[x][y]) // prevent animation from being restarted
7940 MovDir[x][y] = MV_DOWN;
7942 InitMovingField(x, y, MV_DOWN);
7943 started_moving = TRUE;
7945 else if (element == EL_AMOEBA_DROP)
7947 Tile[x][y] = EL_AMOEBA_GROWING;
7948 Store[x][y] = EL_AMOEBA_WET;
7950 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
7951 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
7952 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
7953 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
7955 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
7956 (IS_FREE(x - 1, y + 1) ||
7957 Tile[x - 1][y + 1] == EL_ACID));
7958 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
7959 (IS_FREE(x + 1, y + 1) ||
7960 Tile[x + 1][y + 1] == EL_ACID));
7961 boolean can_fall_any = (can_fall_left || can_fall_right);
7962 boolean can_fall_both = (can_fall_left && can_fall_right);
7963 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
7965 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
7967 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
7968 can_fall_right = FALSE;
7969 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
7970 can_fall_left = FALSE;
7971 else if (slippery_type == SLIPPERY_ONLY_LEFT)
7972 can_fall_right = FALSE;
7973 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
7974 can_fall_left = FALSE;
7976 can_fall_any = (can_fall_left || can_fall_right);
7977 can_fall_both = FALSE;
7982 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
7983 can_fall_right = FALSE; // slip down on left side
7985 can_fall_left = !(can_fall_right = RND(2));
7987 can_fall_both = FALSE;
7992 // if not determined otherwise, prefer left side for slipping down
7993 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
7994 started_moving = TRUE;
7997 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
7999 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8000 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8001 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8002 int belt_dir = game.belt_dir[belt_nr];
8004 if ((belt_dir == MV_LEFT && left_is_free) ||
8005 (belt_dir == MV_RIGHT && right_is_free))
8007 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8009 InitMovingField(x, y, belt_dir);
8010 started_moving = TRUE;
8012 Pushed[x][y] = TRUE;
8013 Pushed[nextx][y] = TRUE;
8015 GfxAction[x][y] = ACTION_DEFAULT;
8019 MovDir[x][y] = 0; // if element was moving, stop it
8024 // not "else if" because of elements that can fall and move (EL_SPRING)
8025 if (CAN_MOVE(element) && !started_moving)
8027 int move_pattern = element_info[element].move_pattern;
8030 Moving2Blocked(x, y, &newx, &newy);
8032 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8035 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8036 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8038 WasJustMoving[x][y] = 0;
8039 CheckCollision[x][y] = 0;
8041 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8043 if (Tile[x][y] != element) // element has changed
8047 if (!MovDelay[x][y]) // start new movement phase
8049 // all objects that can change their move direction after each step
8050 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8052 if (element != EL_YAMYAM &&
8053 element != EL_DARK_YAMYAM &&
8054 element != EL_PACMAN &&
8055 !(move_pattern & MV_ANY_DIRECTION) &&
8056 move_pattern != MV_TURNING_LEFT &&
8057 move_pattern != MV_TURNING_RIGHT &&
8058 move_pattern != MV_TURNING_LEFT_RIGHT &&
8059 move_pattern != MV_TURNING_RIGHT_LEFT &&
8060 move_pattern != MV_TURNING_RANDOM)
8064 if (MovDelay[x][y] && (element == EL_BUG ||
8065 element == EL_SPACESHIP ||
8066 element == EL_SP_SNIKSNAK ||
8067 element == EL_SP_ELECTRON ||
8068 element == EL_MOLE))
8069 TEST_DrawLevelField(x, y);
8073 if (MovDelay[x][y]) // wait some time before next movement
8077 if (element == EL_ROBOT ||
8078 element == EL_YAMYAM ||
8079 element == EL_DARK_YAMYAM)
8081 DrawLevelElementAnimationIfNeeded(x, y, element);
8082 PlayLevelSoundAction(x, y, ACTION_WAITING);
8084 else if (element == EL_SP_ELECTRON)
8085 DrawLevelElementAnimationIfNeeded(x, y, element);
8086 else if (element == EL_DRAGON)
8089 int dir = MovDir[x][y];
8090 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8091 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8092 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8093 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8094 dir == MV_UP ? IMG_FLAMES_1_UP :
8095 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8096 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8098 GfxAction[x][y] = ACTION_ATTACKING;
8100 if (IS_PLAYER(x, y))
8101 DrawPlayerField(x, y);
8103 TEST_DrawLevelField(x, y);
8105 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8107 for (i = 1; i <= 3; i++)
8109 int xx = x + i * dx;
8110 int yy = y + i * dy;
8111 int sx = SCREENX(xx);
8112 int sy = SCREENY(yy);
8113 int flame_graphic = graphic + (i - 1);
8115 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8120 int flamed = MovingOrBlocked2Element(xx, yy);
8122 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8125 RemoveMovingField(xx, yy);
8127 ChangeDelay[xx][yy] = 0;
8129 Tile[xx][yy] = EL_FLAMES;
8131 if (IN_SCR_FIELD(sx, sy))
8133 TEST_DrawLevelFieldCrumbled(xx, yy);
8134 DrawGraphic(sx, sy, flame_graphic, frame);
8139 if (Tile[xx][yy] == EL_FLAMES)
8140 Tile[xx][yy] = EL_EMPTY;
8141 TEST_DrawLevelField(xx, yy);
8146 if (MovDelay[x][y]) // element still has to wait some time
8148 PlayLevelSoundAction(x, y, ACTION_WAITING);
8154 // now make next step
8156 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8158 if (DONT_COLLIDE_WITH(element) &&
8159 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8160 !PLAYER_ENEMY_PROTECTED(newx, newy))
8162 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8167 else if (CAN_MOVE_INTO_ACID(element) &&
8168 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8169 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8170 (MovDir[x][y] == MV_DOWN ||
8171 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8173 SplashAcid(newx, newy);
8174 Store[x][y] = EL_ACID;
8176 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8178 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8179 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8180 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8181 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8184 TEST_DrawLevelField(x, y);
8186 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8187 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8188 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8190 game.friends_still_needed--;
8191 if (!game.friends_still_needed &&
8193 game.all_players_gone)
8198 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8200 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8201 TEST_DrawLevelField(newx, newy);
8203 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8205 else if (!IS_FREE(newx, newy))
8207 GfxAction[x][y] = ACTION_WAITING;
8209 if (IS_PLAYER(x, y))
8210 DrawPlayerField(x, y);
8212 TEST_DrawLevelField(x, y);
8217 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8219 if (IS_FOOD_PIG(Tile[newx][newy]))
8221 if (IS_MOVING(newx, newy))
8222 RemoveMovingField(newx, newy);
8225 Tile[newx][newy] = EL_EMPTY;
8226 TEST_DrawLevelField(newx, newy);
8229 PlayLevelSound(x, y, SND_PIG_DIGGING);
8231 else if (!IS_FREE(newx, newy))
8233 if (IS_PLAYER(x, y))
8234 DrawPlayerField(x, y);
8236 TEST_DrawLevelField(x, y);
8241 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8243 if (Store[x][y] != EL_EMPTY)
8245 boolean can_clone = FALSE;
8248 // check if element to clone is still there
8249 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8251 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8259 // cannot clone or target field not free anymore -- do not clone
8260 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8261 Store[x][y] = EL_EMPTY;
8264 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8266 if (IS_MV_DIAGONAL(MovDir[x][y]))
8268 int diagonal_move_dir = MovDir[x][y];
8269 int stored = Store[x][y];
8270 int change_delay = 8;
8273 // android is moving diagonally
8275 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8277 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8278 GfxElement[x][y] = EL_EMC_ANDROID;
8279 GfxAction[x][y] = ACTION_SHRINKING;
8280 GfxDir[x][y] = diagonal_move_dir;
8281 ChangeDelay[x][y] = change_delay;
8283 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8286 DrawLevelGraphicAnimation(x, y, graphic);
8287 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8289 if (Tile[newx][newy] == EL_ACID)
8291 SplashAcid(newx, newy);
8296 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8298 Store[newx][newy] = EL_EMC_ANDROID;
8299 GfxElement[newx][newy] = EL_EMC_ANDROID;
8300 GfxAction[newx][newy] = ACTION_GROWING;
8301 GfxDir[newx][newy] = diagonal_move_dir;
8302 ChangeDelay[newx][newy] = change_delay;
8304 graphic = el_act_dir2img(GfxElement[newx][newy],
8305 GfxAction[newx][newy], GfxDir[newx][newy]);
8307 DrawLevelGraphicAnimation(newx, newy, graphic);
8308 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8314 Tile[newx][newy] = EL_EMPTY;
8315 TEST_DrawLevelField(newx, newy);
8317 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8320 else if (!IS_FREE(newx, newy))
8325 else if (IS_CUSTOM_ELEMENT(element) &&
8326 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8328 if (!DigFieldByCE(newx, newy, element))
8331 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8333 RunnerVisit[x][y] = FrameCounter;
8334 PlayerVisit[x][y] /= 8; // expire player visit path
8337 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8339 if (!IS_FREE(newx, newy))
8341 if (IS_PLAYER(x, y))
8342 DrawPlayerField(x, y);
8344 TEST_DrawLevelField(x, y);
8350 boolean wanna_flame = !RND(10);
8351 int dx = newx - x, dy = newy - y;
8352 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8353 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8354 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8355 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8356 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8357 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8360 IS_CLASSIC_ENEMY(element1) ||
8361 IS_CLASSIC_ENEMY(element2)) &&
8362 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8363 element1 != EL_FLAMES && element2 != EL_FLAMES)
8365 ResetGfxAnimation(x, y);
8366 GfxAction[x][y] = ACTION_ATTACKING;
8368 if (IS_PLAYER(x, y))
8369 DrawPlayerField(x, y);
8371 TEST_DrawLevelField(x, y);
8373 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8375 MovDelay[x][y] = 50;
8377 Tile[newx][newy] = EL_FLAMES;
8378 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8379 Tile[newx1][newy1] = EL_FLAMES;
8380 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8381 Tile[newx2][newy2] = EL_FLAMES;
8387 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8388 Tile[newx][newy] == EL_DIAMOND)
8390 if (IS_MOVING(newx, newy))
8391 RemoveMovingField(newx, newy);
8394 Tile[newx][newy] = EL_EMPTY;
8395 TEST_DrawLevelField(newx, newy);
8398 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8400 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8401 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8403 if (AmoebaNr[newx][newy])
8405 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8406 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8407 Tile[newx][newy] == EL_BD_AMOEBA)
8408 AmoebaCnt[AmoebaNr[newx][newy]]--;
8411 if (IS_MOVING(newx, newy))
8413 RemoveMovingField(newx, newy);
8417 Tile[newx][newy] = EL_EMPTY;
8418 TEST_DrawLevelField(newx, newy);
8421 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8423 else if ((element == EL_PACMAN || element == EL_MOLE)
8424 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8426 if (AmoebaNr[newx][newy])
8428 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8429 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8430 Tile[newx][newy] == EL_BD_AMOEBA)
8431 AmoebaCnt[AmoebaNr[newx][newy]]--;
8434 if (element == EL_MOLE)
8436 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8437 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8439 ResetGfxAnimation(x, y);
8440 GfxAction[x][y] = ACTION_DIGGING;
8441 TEST_DrawLevelField(x, y);
8443 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8445 return; // wait for shrinking amoeba
8447 else // element == EL_PACMAN
8449 Tile[newx][newy] = EL_EMPTY;
8450 TEST_DrawLevelField(newx, newy);
8451 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8454 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8455 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8456 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8458 // wait for shrinking amoeba to completely disappear
8461 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8463 // object was running against a wall
8467 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8468 DrawLevelElementAnimation(x, y, element);
8470 if (DONT_TOUCH(element))
8471 TestIfBadThingTouchesPlayer(x, y);
8476 InitMovingField(x, y, MovDir[x][y]);
8478 PlayLevelSoundAction(x, y, ACTION_MOVING);
8482 ContinueMoving(x, y);
8485 void ContinueMoving(int x, int y)
8487 int element = Tile[x][y];
8488 struct ElementInfo *ei = &element_info[element];
8489 int direction = MovDir[x][y];
8490 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8491 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8492 int newx = x + dx, newy = y + dy;
8493 int stored = Store[x][y];
8494 int stored_new = Store[newx][newy];
8495 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8496 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8497 boolean last_line = (newy == lev_fieldy - 1);
8499 MovPos[x][y] += getElementMoveStepsize(x, y);
8501 if (pushed_by_player) // special case: moving object pushed by player
8502 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8504 if (ABS(MovPos[x][y]) < TILEX)
8506 TEST_DrawLevelField(x, y);
8508 return; // element is still moving
8511 // element reached destination field
8513 Tile[x][y] = EL_EMPTY;
8514 Tile[newx][newy] = element;
8515 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8517 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8519 element = Tile[newx][newy] = EL_ACID;
8521 else if (element == EL_MOLE)
8523 Tile[x][y] = EL_SAND;
8525 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8527 else if (element == EL_QUICKSAND_FILLING)
8529 element = Tile[newx][newy] = get_next_element(element);
8530 Store[newx][newy] = Store[x][y];
8532 else if (element == EL_QUICKSAND_EMPTYING)
8534 Tile[x][y] = get_next_element(element);
8535 element = Tile[newx][newy] = Store[x][y];
8537 else if (element == EL_QUICKSAND_FAST_FILLING)
8539 element = Tile[newx][newy] = get_next_element(element);
8540 Store[newx][newy] = Store[x][y];
8542 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8544 Tile[x][y] = get_next_element(element);
8545 element = Tile[newx][newy] = Store[x][y];
8547 else if (element == EL_MAGIC_WALL_FILLING)
8549 element = Tile[newx][newy] = get_next_element(element);
8550 if (!game.magic_wall_active)
8551 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8552 Store[newx][newy] = Store[x][y];
8554 else if (element == EL_MAGIC_WALL_EMPTYING)
8556 Tile[x][y] = get_next_element(element);
8557 if (!game.magic_wall_active)
8558 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8559 element = Tile[newx][newy] = Store[x][y];
8561 InitField(newx, newy, FALSE);
8563 else if (element == EL_BD_MAGIC_WALL_FILLING)
8565 element = Tile[newx][newy] = get_next_element(element);
8566 if (!game.magic_wall_active)
8567 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8568 Store[newx][newy] = Store[x][y];
8570 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8572 Tile[x][y] = get_next_element(element);
8573 if (!game.magic_wall_active)
8574 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8575 element = Tile[newx][newy] = Store[x][y];
8577 InitField(newx, newy, FALSE);
8579 else if (element == EL_DC_MAGIC_WALL_FILLING)
8581 element = Tile[newx][newy] = get_next_element(element);
8582 if (!game.magic_wall_active)
8583 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8584 Store[newx][newy] = Store[x][y];
8586 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8588 Tile[x][y] = get_next_element(element);
8589 if (!game.magic_wall_active)
8590 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8591 element = Tile[newx][newy] = Store[x][y];
8593 InitField(newx, newy, FALSE);
8595 else if (element == EL_AMOEBA_DROPPING)
8597 Tile[x][y] = get_next_element(element);
8598 element = Tile[newx][newy] = Store[x][y];
8600 else if (element == EL_SOKOBAN_OBJECT)
8603 Tile[x][y] = Back[x][y];
8605 if (Back[newx][newy])
8606 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8608 Back[x][y] = Back[newx][newy] = 0;
8611 Store[x][y] = EL_EMPTY;
8616 MovDelay[newx][newy] = 0;
8618 if (CAN_CHANGE_OR_HAS_ACTION(element))
8620 // copy element change control values to new field
8621 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8622 ChangePage[newx][newy] = ChangePage[x][y];
8623 ChangeCount[newx][newy] = ChangeCount[x][y];
8624 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8627 CustomValue[newx][newy] = CustomValue[x][y];
8629 ChangeDelay[x][y] = 0;
8630 ChangePage[x][y] = -1;
8631 ChangeCount[x][y] = 0;
8632 ChangeEvent[x][y] = -1;
8634 CustomValue[x][y] = 0;
8636 // copy animation control values to new field
8637 GfxFrame[newx][newy] = GfxFrame[x][y];
8638 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8639 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8640 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8642 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8644 // some elements can leave other elements behind after moving
8645 if (ei->move_leave_element != EL_EMPTY &&
8646 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8647 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8649 int move_leave_element = ei->move_leave_element;
8651 // this makes it possible to leave the removed element again
8652 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8653 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8655 Tile[x][y] = move_leave_element;
8657 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8658 MovDir[x][y] = direction;
8660 InitField(x, y, FALSE);
8662 if (GFX_CRUMBLED(Tile[x][y]))
8663 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8665 if (ELEM_IS_PLAYER(move_leave_element))
8666 RelocatePlayer(x, y, move_leave_element);
8669 // do this after checking for left-behind element
8670 ResetGfxAnimation(x, y); // reset animation values for old field
8672 if (!CAN_MOVE(element) ||
8673 (CAN_FALL(element) && direction == MV_DOWN &&
8674 (element == EL_SPRING ||
8675 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8676 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8677 GfxDir[x][y] = MovDir[newx][newy] = 0;
8679 TEST_DrawLevelField(x, y);
8680 TEST_DrawLevelField(newx, newy);
8682 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8684 // prevent pushed element from moving on in pushed direction
8685 if (pushed_by_player && CAN_MOVE(element) &&
8686 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8687 !(element_info[element].move_pattern & direction))
8688 TurnRound(newx, newy);
8690 // prevent elements on conveyor belt from moving on in last direction
8691 if (pushed_by_conveyor && CAN_FALL(element) &&
8692 direction & MV_HORIZONTAL)
8693 MovDir[newx][newy] = 0;
8695 if (!pushed_by_player)
8697 int nextx = newx + dx, nexty = newy + dy;
8698 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8700 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8702 if (CAN_FALL(element) && direction == MV_DOWN)
8703 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8705 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8706 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8708 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8709 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8712 if (DONT_TOUCH(element)) // object may be nasty to player or others
8714 TestIfBadThingTouchesPlayer(newx, newy);
8715 TestIfBadThingTouchesFriend(newx, newy);
8717 if (!IS_CUSTOM_ELEMENT(element))
8718 TestIfBadThingTouchesOtherBadThing(newx, newy);
8720 else if (element == EL_PENGUIN)
8721 TestIfFriendTouchesBadThing(newx, newy);
8723 if (DONT_GET_HIT_BY(element))
8725 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8728 // give the player one last chance (one more frame) to move away
8729 if (CAN_FALL(element) && direction == MV_DOWN &&
8730 (last_line || (!IS_FREE(x, newy + 1) &&
8731 (!IS_PLAYER(x, newy + 1) ||
8732 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8735 if (pushed_by_player && !game.use_change_when_pushing_bug)
8737 int push_side = MV_DIR_OPPOSITE(direction);
8738 struct PlayerInfo *player = PLAYERINFO(x, y);
8740 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8741 player->index_bit, push_side);
8742 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8743 player->index_bit, push_side);
8746 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8747 MovDelay[newx][newy] = 1;
8749 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8751 TestIfElementTouchesCustomElement(x, y); // empty or new element
8752 TestIfElementHitsCustomElement(newx, newy, direction);
8753 TestIfPlayerTouchesCustomElement(newx, newy);
8754 TestIfElementTouchesCustomElement(newx, newy);
8756 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8757 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8758 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8759 MV_DIR_OPPOSITE(direction));
8762 int AmoebaNeighbourNr(int ax, int ay)
8765 int element = Tile[ax][ay];
8767 static int xy[4][2] =
8775 for (i = 0; i < NUM_DIRECTIONS; i++)
8777 int x = ax + xy[i][0];
8778 int y = ay + xy[i][1];
8780 if (!IN_LEV_FIELD(x, y))
8783 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8784 group_nr = AmoebaNr[x][y];
8790 static void AmoebaMerge(int ax, int ay)
8792 int i, x, y, xx, yy;
8793 int new_group_nr = AmoebaNr[ax][ay];
8794 static int xy[4][2] =
8802 if (new_group_nr == 0)
8805 for (i = 0; i < NUM_DIRECTIONS; i++)
8810 if (!IN_LEV_FIELD(x, y))
8813 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8814 Tile[x][y] == EL_BD_AMOEBA ||
8815 Tile[x][y] == EL_AMOEBA_DEAD) &&
8816 AmoebaNr[x][y] != new_group_nr)
8818 int old_group_nr = AmoebaNr[x][y];
8820 if (old_group_nr == 0)
8823 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8824 AmoebaCnt[old_group_nr] = 0;
8825 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8826 AmoebaCnt2[old_group_nr] = 0;
8828 SCAN_PLAYFIELD(xx, yy)
8830 if (AmoebaNr[xx][yy] == old_group_nr)
8831 AmoebaNr[xx][yy] = new_group_nr;
8837 void AmoebaToDiamond(int ax, int ay)
8841 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8843 int group_nr = AmoebaNr[ax][ay];
8848 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8849 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8855 SCAN_PLAYFIELD(x, y)
8857 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8860 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8864 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8865 SND_AMOEBA_TURNING_TO_GEM :
8866 SND_AMOEBA_TURNING_TO_ROCK));
8871 static int xy[4][2] =
8879 for (i = 0; i < NUM_DIRECTIONS; i++)
8884 if (!IN_LEV_FIELD(x, y))
8887 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
8889 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
8890 SND_AMOEBA_TURNING_TO_GEM :
8891 SND_AMOEBA_TURNING_TO_ROCK));
8898 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
8901 int group_nr = AmoebaNr[ax][ay];
8902 boolean done = FALSE;
8907 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
8908 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
8914 SCAN_PLAYFIELD(x, y)
8916 if (AmoebaNr[x][y] == group_nr &&
8917 (Tile[x][y] == EL_AMOEBA_DEAD ||
8918 Tile[x][y] == EL_BD_AMOEBA ||
8919 Tile[x][y] == EL_AMOEBA_GROWING))
8922 Tile[x][y] = new_element;
8923 InitField(x, y, FALSE);
8924 TEST_DrawLevelField(x, y);
8930 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
8931 SND_BD_AMOEBA_TURNING_TO_ROCK :
8932 SND_BD_AMOEBA_TURNING_TO_GEM));
8935 static void AmoebaGrowing(int x, int y)
8937 static unsigned int sound_delay = 0;
8938 static unsigned int sound_delay_value = 0;
8940 if (!MovDelay[x][y]) // start new growing cycle
8944 if (DelayReached(&sound_delay, sound_delay_value))
8946 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
8947 sound_delay_value = 30;
8951 if (MovDelay[x][y]) // wait some time before growing bigger
8954 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
8956 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
8957 6 - MovDelay[x][y]);
8959 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
8962 if (!MovDelay[x][y])
8964 Tile[x][y] = Store[x][y];
8966 TEST_DrawLevelField(x, y);
8971 static void AmoebaShrinking(int x, int y)
8973 static unsigned int sound_delay = 0;
8974 static unsigned int sound_delay_value = 0;
8976 if (!MovDelay[x][y]) // start new shrinking cycle
8980 if (DelayReached(&sound_delay, sound_delay_value))
8981 sound_delay_value = 30;
8984 if (MovDelay[x][y]) // wait some time before shrinking
8987 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
8989 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
8990 6 - MovDelay[x][y]);
8992 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
8995 if (!MovDelay[x][y])
8997 Tile[x][y] = EL_EMPTY;
8998 TEST_DrawLevelField(x, y);
9000 // don't let mole enter this field in this cycle;
9001 // (give priority to objects falling to this field from above)
9007 static void AmoebaReproduce(int ax, int ay)
9010 int element = Tile[ax][ay];
9011 int graphic = el2img(element);
9012 int newax = ax, neway = ay;
9013 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9014 static int xy[4][2] =
9022 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9024 Tile[ax][ay] = EL_AMOEBA_DEAD;
9025 TEST_DrawLevelField(ax, ay);
9029 if (IS_ANIMATED(graphic))
9030 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9032 if (!MovDelay[ax][ay]) // start making new amoeba field
9033 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9035 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9038 if (MovDelay[ax][ay])
9042 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9045 int x = ax + xy[start][0];
9046 int y = ay + xy[start][1];
9048 if (!IN_LEV_FIELD(x, y))
9051 if (IS_FREE(x, y) ||
9052 CAN_GROW_INTO(Tile[x][y]) ||
9053 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9054 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9060 if (newax == ax && neway == ay)
9063 else // normal or "filled" (BD style) amoeba
9066 boolean waiting_for_player = FALSE;
9068 for (i = 0; i < NUM_DIRECTIONS; i++)
9070 int j = (start + i) % 4;
9071 int x = ax + xy[j][0];
9072 int y = ay + xy[j][1];
9074 if (!IN_LEV_FIELD(x, y))
9077 if (IS_FREE(x, y) ||
9078 CAN_GROW_INTO(Tile[x][y]) ||
9079 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9080 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9086 else if (IS_PLAYER(x, y))
9087 waiting_for_player = TRUE;
9090 if (newax == ax && neway == ay) // amoeba cannot grow
9092 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9094 Tile[ax][ay] = EL_AMOEBA_DEAD;
9095 TEST_DrawLevelField(ax, ay);
9096 AmoebaCnt[AmoebaNr[ax][ay]]--;
9098 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9100 if (element == EL_AMOEBA_FULL)
9101 AmoebaToDiamond(ax, ay);
9102 else if (element == EL_BD_AMOEBA)
9103 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9108 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9110 // amoeba gets larger by growing in some direction
9112 int new_group_nr = AmoebaNr[ax][ay];
9115 if (new_group_nr == 0)
9117 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9119 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9125 AmoebaNr[newax][neway] = new_group_nr;
9126 AmoebaCnt[new_group_nr]++;
9127 AmoebaCnt2[new_group_nr]++;
9129 // if amoeba touches other amoeba(s) after growing, unify them
9130 AmoebaMerge(newax, neway);
9132 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9134 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9140 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9141 (neway == lev_fieldy - 1 && newax != ax))
9143 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9144 Store[newax][neway] = element;
9146 else if (neway == ay || element == EL_EMC_DRIPPER)
9148 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9150 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9154 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9155 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9156 Store[ax][ay] = EL_AMOEBA_DROP;
9157 ContinueMoving(ax, ay);
9161 TEST_DrawLevelField(newax, neway);
9164 static void Life(int ax, int ay)
9168 int element = Tile[ax][ay];
9169 int graphic = el2img(element);
9170 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9172 boolean changed = FALSE;
9174 if (IS_ANIMATED(graphic))
9175 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9180 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9181 MovDelay[ax][ay] = life_time;
9183 if (MovDelay[ax][ay]) // wait some time before next cycle
9186 if (MovDelay[ax][ay])
9190 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9192 int xx = ax+x1, yy = ay+y1;
9193 int old_element = Tile[xx][yy];
9194 int num_neighbours = 0;
9196 if (!IN_LEV_FIELD(xx, yy))
9199 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9201 int x = xx+x2, y = yy+y2;
9203 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9206 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9207 boolean is_neighbour = FALSE;
9209 if (level.use_life_bugs)
9211 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9212 (IS_FREE(x, y) && Stop[x][y]));
9215 (Last[x][y] == element || is_player_cell);
9221 boolean is_free = FALSE;
9223 if (level.use_life_bugs)
9224 is_free = (IS_FREE(xx, yy));
9226 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9228 if (xx == ax && yy == ay) // field in the middle
9230 if (num_neighbours < life_parameter[0] ||
9231 num_neighbours > life_parameter[1])
9233 Tile[xx][yy] = EL_EMPTY;
9234 if (Tile[xx][yy] != old_element)
9235 TEST_DrawLevelField(xx, yy);
9236 Stop[xx][yy] = TRUE;
9240 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9241 { // free border field
9242 if (num_neighbours >= life_parameter[2] &&
9243 num_neighbours <= life_parameter[3])
9245 Tile[xx][yy] = element;
9246 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9247 if (Tile[xx][yy] != old_element)
9248 TEST_DrawLevelField(xx, yy);
9249 Stop[xx][yy] = TRUE;
9256 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9257 SND_GAME_OF_LIFE_GROWING);
9260 static void InitRobotWheel(int x, int y)
9262 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9265 static void RunRobotWheel(int x, int y)
9267 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9270 static void StopRobotWheel(int x, int y)
9272 if (game.robot_wheel_x == x &&
9273 game.robot_wheel_y == y)
9275 game.robot_wheel_x = -1;
9276 game.robot_wheel_y = -1;
9277 game.robot_wheel_active = FALSE;
9281 static void InitTimegateWheel(int x, int y)
9283 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9286 static void RunTimegateWheel(int x, int y)
9288 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9291 static void InitMagicBallDelay(int x, int y)
9293 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9296 static void ActivateMagicBall(int bx, int by)
9300 if (level.ball_random)
9302 int pos_border = RND(8); // select one of the eight border elements
9303 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9304 int xx = pos_content % 3;
9305 int yy = pos_content / 3;
9310 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9311 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9315 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9317 int xx = x - bx + 1;
9318 int yy = y - by + 1;
9320 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9321 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9325 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9328 static void CheckExit(int x, int y)
9330 if (game.gems_still_needed > 0 ||
9331 game.sokoban_fields_still_needed > 0 ||
9332 game.sokoban_objects_still_needed > 0 ||
9333 game.lights_still_needed > 0)
9335 int element = Tile[x][y];
9336 int graphic = el2img(element);
9338 if (IS_ANIMATED(graphic))
9339 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9344 // do not re-open exit door closed after last player
9345 if (game.all_players_gone)
9348 Tile[x][y] = EL_EXIT_OPENING;
9350 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9353 static void CheckExitEM(int x, int y)
9355 if (game.gems_still_needed > 0 ||
9356 game.sokoban_fields_still_needed > 0 ||
9357 game.sokoban_objects_still_needed > 0 ||
9358 game.lights_still_needed > 0)
9360 int element = Tile[x][y];
9361 int graphic = el2img(element);
9363 if (IS_ANIMATED(graphic))
9364 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9369 // do not re-open exit door closed after last player
9370 if (game.all_players_gone)
9373 Tile[x][y] = EL_EM_EXIT_OPENING;
9375 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9378 static void CheckExitSteel(int x, int y)
9380 if (game.gems_still_needed > 0 ||
9381 game.sokoban_fields_still_needed > 0 ||
9382 game.sokoban_objects_still_needed > 0 ||
9383 game.lights_still_needed > 0)
9385 int element = Tile[x][y];
9386 int graphic = el2img(element);
9388 if (IS_ANIMATED(graphic))
9389 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9394 // do not re-open exit door closed after last player
9395 if (game.all_players_gone)
9398 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9400 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9403 static void CheckExitSteelEM(int x, int y)
9405 if (game.gems_still_needed > 0 ||
9406 game.sokoban_fields_still_needed > 0 ||
9407 game.sokoban_objects_still_needed > 0 ||
9408 game.lights_still_needed > 0)
9410 int element = Tile[x][y];
9411 int graphic = el2img(element);
9413 if (IS_ANIMATED(graphic))
9414 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9419 // do not re-open exit door closed after last player
9420 if (game.all_players_gone)
9423 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9425 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9428 static void CheckExitSP(int x, int y)
9430 if (game.gems_still_needed > 0)
9432 int element = Tile[x][y];
9433 int graphic = el2img(element);
9435 if (IS_ANIMATED(graphic))
9436 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9441 // do not re-open exit door closed after last player
9442 if (game.all_players_gone)
9445 Tile[x][y] = EL_SP_EXIT_OPENING;
9447 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9450 static void CloseAllOpenTimegates(void)
9454 SCAN_PLAYFIELD(x, y)
9456 int element = Tile[x][y];
9458 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9460 Tile[x][y] = EL_TIMEGATE_CLOSING;
9462 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9467 static void DrawTwinkleOnField(int x, int y)
9469 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9472 if (Tile[x][y] == EL_BD_DIAMOND)
9475 if (MovDelay[x][y] == 0) // next animation frame
9476 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9478 if (MovDelay[x][y] != 0) // wait some time before next frame
9482 DrawLevelElementAnimation(x, y, Tile[x][y]);
9484 if (MovDelay[x][y] != 0)
9486 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9487 10 - MovDelay[x][y]);
9489 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9494 static void MauerWaechst(int x, int y)
9498 if (!MovDelay[x][y]) // next animation frame
9499 MovDelay[x][y] = 3 * delay;
9501 if (MovDelay[x][y]) // wait some time before next frame
9505 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9507 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9508 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9510 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9513 if (!MovDelay[x][y])
9515 if (MovDir[x][y] == MV_LEFT)
9517 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9518 TEST_DrawLevelField(x - 1, y);
9520 else if (MovDir[x][y] == MV_RIGHT)
9522 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9523 TEST_DrawLevelField(x + 1, y);
9525 else if (MovDir[x][y] == MV_UP)
9527 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9528 TEST_DrawLevelField(x, y - 1);
9532 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9533 TEST_DrawLevelField(x, y + 1);
9536 Tile[x][y] = Store[x][y];
9538 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9539 TEST_DrawLevelField(x, y);
9544 static void MauerAbleger(int ax, int ay)
9546 int element = Tile[ax][ay];
9547 int graphic = el2img(element);
9548 boolean oben_frei = FALSE, unten_frei = FALSE;
9549 boolean links_frei = FALSE, rechts_frei = FALSE;
9550 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9551 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9552 boolean new_wall = FALSE;
9554 if (IS_ANIMATED(graphic))
9555 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9557 if (!MovDelay[ax][ay]) // start building new wall
9558 MovDelay[ax][ay] = 6;
9560 if (MovDelay[ax][ay]) // wait some time before building new wall
9563 if (MovDelay[ax][ay])
9567 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9569 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9571 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9573 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9576 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9577 element == EL_EXPANDABLE_WALL_ANY)
9581 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9582 Store[ax][ay-1] = element;
9583 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9584 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9585 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9586 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9591 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9592 Store[ax][ay+1] = element;
9593 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9594 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9595 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9596 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9601 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9602 element == EL_EXPANDABLE_WALL_ANY ||
9603 element == EL_EXPANDABLE_WALL ||
9604 element == EL_BD_EXPANDABLE_WALL)
9608 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9609 Store[ax-1][ay] = element;
9610 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9611 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9612 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9613 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9619 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9620 Store[ax+1][ay] = element;
9621 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9622 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9623 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9624 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9629 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9630 TEST_DrawLevelField(ax, ay);
9632 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9634 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9635 unten_massiv = TRUE;
9636 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9637 links_massiv = TRUE;
9638 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9639 rechts_massiv = TRUE;
9641 if (((oben_massiv && unten_massiv) ||
9642 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9643 element == EL_EXPANDABLE_WALL) &&
9644 ((links_massiv && rechts_massiv) ||
9645 element == EL_EXPANDABLE_WALL_VERTICAL))
9646 Tile[ax][ay] = EL_WALL;
9649 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9652 static void MauerAblegerStahl(int ax, int ay)
9654 int element = Tile[ax][ay];
9655 int graphic = el2img(element);
9656 boolean oben_frei = FALSE, unten_frei = FALSE;
9657 boolean links_frei = FALSE, rechts_frei = FALSE;
9658 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9659 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9660 boolean new_wall = FALSE;
9662 if (IS_ANIMATED(graphic))
9663 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9665 if (!MovDelay[ax][ay]) // start building new wall
9666 MovDelay[ax][ay] = 6;
9668 if (MovDelay[ax][ay]) // wait some time before building new wall
9671 if (MovDelay[ax][ay])
9675 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9677 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9679 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9681 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9684 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9685 element == EL_EXPANDABLE_STEELWALL_ANY)
9689 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9690 Store[ax][ay-1] = element;
9691 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9692 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9693 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9694 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9699 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9700 Store[ax][ay+1] = element;
9701 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9702 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9703 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9704 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9709 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9710 element == EL_EXPANDABLE_STEELWALL_ANY)
9714 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9715 Store[ax-1][ay] = element;
9716 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9717 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9718 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9719 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9725 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9726 Store[ax+1][ay] = element;
9727 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9728 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9729 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9730 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9735 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9737 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9738 unten_massiv = TRUE;
9739 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9740 links_massiv = TRUE;
9741 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9742 rechts_massiv = TRUE;
9744 if (((oben_massiv && unten_massiv) ||
9745 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9746 ((links_massiv && rechts_massiv) ||
9747 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9748 Tile[ax][ay] = EL_STEELWALL;
9751 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9754 static void CheckForDragon(int x, int y)
9757 boolean dragon_found = FALSE;
9758 static int xy[4][2] =
9766 for (i = 0; i < NUM_DIRECTIONS; i++)
9768 for (j = 0; j < 4; j++)
9770 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9772 if (IN_LEV_FIELD(xx, yy) &&
9773 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9775 if (Tile[xx][yy] == EL_DRAGON)
9776 dragon_found = TRUE;
9785 for (i = 0; i < NUM_DIRECTIONS; i++)
9787 for (j = 0; j < 3; j++)
9789 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9791 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9793 Tile[xx][yy] = EL_EMPTY;
9794 TEST_DrawLevelField(xx, yy);
9803 static void InitBuggyBase(int x, int y)
9805 int element = Tile[x][y];
9806 int activating_delay = FRAMES_PER_SECOND / 4;
9809 (element == EL_SP_BUGGY_BASE ?
9810 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9811 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9813 element == EL_SP_BUGGY_BASE_ACTIVE ?
9814 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9817 static void WarnBuggyBase(int x, int y)
9820 static int xy[4][2] =
9828 for (i = 0; i < NUM_DIRECTIONS; i++)
9830 int xx = x + xy[i][0];
9831 int yy = y + xy[i][1];
9833 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9835 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9842 static void InitTrap(int x, int y)
9844 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9847 static void ActivateTrap(int x, int y)
9849 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9852 static void ChangeActiveTrap(int x, int y)
9854 int graphic = IMG_TRAP_ACTIVE;
9856 // if new animation frame was drawn, correct crumbled sand border
9857 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9858 TEST_DrawLevelFieldCrumbled(x, y);
9861 static int getSpecialActionElement(int element, int number, int base_element)
9863 return (element != EL_EMPTY ? element :
9864 number != -1 ? base_element + number - 1 :
9868 static int getModifiedActionNumber(int value_old, int operator, int operand,
9869 int value_min, int value_max)
9871 int value_new = (operator == CA_MODE_SET ? operand :
9872 operator == CA_MODE_ADD ? value_old + operand :
9873 operator == CA_MODE_SUBTRACT ? value_old - operand :
9874 operator == CA_MODE_MULTIPLY ? value_old * operand :
9875 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9876 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
9879 return (value_new < value_min ? value_min :
9880 value_new > value_max ? value_max :
9884 static void ExecuteCustomElementAction(int x, int y, int element, int page)
9886 struct ElementInfo *ei = &element_info[element];
9887 struct ElementChangeInfo *change = &ei->change_page[page];
9888 int target_element = change->target_element;
9889 int action_type = change->action_type;
9890 int action_mode = change->action_mode;
9891 int action_arg = change->action_arg;
9892 int action_element = change->action_element;
9895 if (!change->has_action)
9898 // ---------- determine action paramater values -----------------------------
9900 int level_time_value =
9901 (level.time > 0 ? TimeLeft :
9904 int action_arg_element_raw =
9905 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
9906 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
9907 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
9908 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
9909 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
9910 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
9911 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
9913 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
9915 int action_arg_direction =
9916 (action_arg >= CA_ARG_DIRECTION_LEFT &&
9917 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
9918 action_arg == CA_ARG_DIRECTION_TRIGGER ?
9919 change->actual_trigger_side :
9920 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
9921 MV_DIR_OPPOSITE(change->actual_trigger_side) :
9924 int action_arg_number_min =
9925 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
9928 int action_arg_number_max =
9929 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
9930 action_type == CA_SET_LEVEL_GEMS ? 999 :
9931 action_type == CA_SET_LEVEL_TIME ? 9999 :
9932 action_type == CA_SET_LEVEL_SCORE ? 99999 :
9933 action_type == CA_SET_CE_VALUE ? 9999 :
9934 action_type == CA_SET_CE_SCORE ? 9999 :
9937 int action_arg_number_reset =
9938 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
9939 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
9940 action_type == CA_SET_LEVEL_TIME ? level.time :
9941 action_type == CA_SET_LEVEL_SCORE ? 0 :
9942 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
9943 action_type == CA_SET_CE_SCORE ? 0 :
9946 int action_arg_number =
9947 (action_arg <= CA_ARG_MAX ? action_arg :
9948 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
9949 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
9950 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
9951 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
9952 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
9953 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
9954 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
9955 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
9956 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
9957 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
9958 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
9959 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
9960 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
9961 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
9962 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
9963 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
9964 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
9965 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
9966 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
9967 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
9968 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
9971 int action_arg_number_old =
9972 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
9973 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
9974 action_type == CA_SET_LEVEL_SCORE ? game.score :
9975 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
9976 action_type == CA_SET_CE_SCORE ? ei->collect_score :
9979 int action_arg_number_new =
9980 getModifiedActionNumber(action_arg_number_old,
9981 action_mode, action_arg_number,
9982 action_arg_number_min, action_arg_number_max);
9984 int trigger_player_bits =
9985 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
9986 change->actual_trigger_player_bits : change->trigger_player);
9988 int action_arg_player_bits =
9989 (action_arg >= CA_ARG_PLAYER_1 &&
9990 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
9991 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
9992 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
9995 // ---------- execute action -----------------------------------------------
9997 switch (action_type)
10004 // ---------- level actions ----------------------------------------------
10006 case CA_RESTART_LEVEL:
10008 game.restart_level = TRUE;
10013 case CA_SHOW_ENVELOPE:
10015 int element = getSpecialActionElement(action_arg_element,
10016 action_arg_number, EL_ENVELOPE_1);
10018 if (IS_ENVELOPE(element))
10019 local_player->show_envelope = element;
10024 case CA_SET_LEVEL_TIME:
10026 if (level.time > 0) // only modify limited time value
10028 TimeLeft = action_arg_number_new;
10030 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10032 DisplayGameControlValues();
10034 if (!TimeLeft && setup.time_limit)
10035 for (i = 0; i < MAX_PLAYERS; i++)
10036 KillPlayer(&stored_player[i]);
10042 case CA_SET_LEVEL_SCORE:
10044 game.score = action_arg_number_new;
10046 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10048 DisplayGameControlValues();
10053 case CA_SET_LEVEL_GEMS:
10055 game.gems_still_needed = action_arg_number_new;
10057 game.snapshot.collected_item = TRUE;
10059 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10061 DisplayGameControlValues();
10066 case CA_SET_LEVEL_WIND:
10068 game.wind_direction = action_arg_direction;
10073 case CA_SET_LEVEL_RANDOM_SEED:
10075 // ensure that setting a new random seed while playing is predictable
10076 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10081 // ---------- player actions ---------------------------------------------
10083 case CA_MOVE_PLAYER:
10084 case CA_MOVE_PLAYER_NEW:
10086 // automatically move to the next field in specified direction
10087 for (i = 0; i < MAX_PLAYERS; i++)
10088 if (trigger_player_bits & (1 << i))
10089 if (action_type == CA_MOVE_PLAYER ||
10090 stored_player[i].MovPos == 0)
10091 stored_player[i].programmed_action = action_arg_direction;
10096 case CA_EXIT_PLAYER:
10098 for (i = 0; i < MAX_PLAYERS; i++)
10099 if (action_arg_player_bits & (1 << i))
10100 ExitPlayer(&stored_player[i]);
10102 if (game.players_still_needed == 0)
10108 case CA_KILL_PLAYER:
10110 for (i = 0; i < MAX_PLAYERS; i++)
10111 if (action_arg_player_bits & (1 << i))
10112 KillPlayer(&stored_player[i]);
10117 case CA_SET_PLAYER_KEYS:
10119 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10120 int element = getSpecialActionElement(action_arg_element,
10121 action_arg_number, EL_KEY_1);
10123 if (IS_KEY(element))
10125 for (i = 0; i < MAX_PLAYERS; i++)
10127 if (trigger_player_bits & (1 << i))
10129 stored_player[i].key[KEY_NR(element)] = key_state;
10131 DrawGameDoorValues();
10139 case CA_SET_PLAYER_SPEED:
10141 for (i = 0; i < MAX_PLAYERS; i++)
10143 if (trigger_player_bits & (1 << i))
10145 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10147 if (action_arg == CA_ARG_SPEED_FASTER &&
10148 stored_player[i].cannot_move)
10150 action_arg_number = STEPSIZE_VERY_SLOW;
10152 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10153 action_arg == CA_ARG_SPEED_FASTER)
10155 action_arg_number = 2;
10156 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10159 else if (action_arg == CA_ARG_NUMBER_RESET)
10161 action_arg_number = level.initial_player_stepsize[i];
10165 getModifiedActionNumber(move_stepsize,
10168 action_arg_number_min,
10169 action_arg_number_max);
10171 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10178 case CA_SET_PLAYER_SHIELD:
10180 for (i = 0; i < MAX_PLAYERS; i++)
10182 if (trigger_player_bits & (1 << i))
10184 if (action_arg == CA_ARG_SHIELD_OFF)
10186 stored_player[i].shield_normal_time_left = 0;
10187 stored_player[i].shield_deadly_time_left = 0;
10189 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10191 stored_player[i].shield_normal_time_left = 999999;
10193 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10195 stored_player[i].shield_normal_time_left = 999999;
10196 stored_player[i].shield_deadly_time_left = 999999;
10204 case CA_SET_PLAYER_GRAVITY:
10206 for (i = 0; i < MAX_PLAYERS; i++)
10208 if (trigger_player_bits & (1 << i))
10210 stored_player[i].gravity =
10211 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10212 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10213 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10214 stored_player[i].gravity);
10221 case CA_SET_PLAYER_ARTWORK:
10223 for (i = 0; i < MAX_PLAYERS; i++)
10225 if (trigger_player_bits & (1 << i))
10227 int artwork_element = action_arg_element;
10229 if (action_arg == CA_ARG_ELEMENT_RESET)
10231 (level.use_artwork_element[i] ? level.artwork_element[i] :
10232 stored_player[i].element_nr);
10234 if (stored_player[i].artwork_element != artwork_element)
10235 stored_player[i].Frame = 0;
10237 stored_player[i].artwork_element = artwork_element;
10239 SetPlayerWaiting(&stored_player[i], FALSE);
10241 // set number of special actions for bored and sleeping animation
10242 stored_player[i].num_special_action_bored =
10243 get_num_special_action(artwork_element,
10244 ACTION_BORING_1, ACTION_BORING_LAST);
10245 stored_player[i].num_special_action_sleeping =
10246 get_num_special_action(artwork_element,
10247 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10254 case CA_SET_PLAYER_INVENTORY:
10256 for (i = 0; i < MAX_PLAYERS; i++)
10258 struct PlayerInfo *player = &stored_player[i];
10261 if (trigger_player_bits & (1 << i))
10263 int inventory_element = action_arg_element;
10265 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10266 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10267 action_arg == CA_ARG_ELEMENT_ACTION)
10269 int element = inventory_element;
10270 int collect_count = element_info[element].collect_count_initial;
10272 if (!IS_CUSTOM_ELEMENT(element))
10275 if (collect_count == 0)
10276 player->inventory_infinite_element = element;
10278 for (k = 0; k < collect_count; k++)
10279 if (player->inventory_size < MAX_INVENTORY_SIZE)
10280 player->inventory_element[player->inventory_size++] =
10283 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10284 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10285 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10287 if (player->inventory_infinite_element != EL_UNDEFINED &&
10288 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10289 action_arg_element_raw))
10290 player->inventory_infinite_element = EL_UNDEFINED;
10292 for (k = 0, j = 0; j < player->inventory_size; j++)
10294 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10295 action_arg_element_raw))
10296 player->inventory_element[k++] = player->inventory_element[j];
10299 player->inventory_size = k;
10301 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10303 if (player->inventory_size > 0)
10305 for (j = 0; j < player->inventory_size - 1; j++)
10306 player->inventory_element[j] = player->inventory_element[j + 1];
10308 player->inventory_size--;
10311 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10313 if (player->inventory_size > 0)
10314 player->inventory_size--;
10316 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10318 player->inventory_infinite_element = EL_UNDEFINED;
10319 player->inventory_size = 0;
10321 else if (action_arg == CA_ARG_INVENTORY_RESET)
10323 player->inventory_infinite_element = EL_UNDEFINED;
10324 player->inventory_size = 0;
10326 if (level.use_initial_inventory[i])
10328 for (j = 0; j < level.initial_inventory_size[i]; j++)
10330 int element = level.initial_inventory_content[i][j];
10331 int collect_count = element_info[element].collect_count_initial;
10333 if (!IS_CUSTOM_ELEMENT(element))
10336 if (collect_count == 0)
10337 player->inventory_infinite_element = element;
10339 for (k = 0; k < collect_count; k++)
10340 if (player->inventory_size < MAX_INVENTORY_SIZE)
10341 player->inventory_element[player->inventory_size++] =
10352 // ---------- CE actions -------------------------------------------------
10354 case CA_SET_CE_VALUE:
10356 int last_ce_value = CustomValue[x][y];
10358 CustomValue[x][y] = action_arg_number_new;
10360 if (CustomValue[x][y] != last_ce_value)
10362 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10363 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10365 if (CustomValue[x][y] == 0)
10367 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10368 ChangeCount[x][y] = 0; // allow at least one more change
10370 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10371 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10378 case CA_SET_CE_SCORE:
10380 int last_ce_score = ei->collect_score;
10382 ei->collect_score = action_arg_number_new;
10384 if (ei->collect_score != last_ce_score)
10386 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10387 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10389 if (ei->collect_score == 0)
10393 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10394 ChangeCount[x][y] = 0; // allow at least one more change
10396 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10397 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10400 This is a very special case that seems to be a mixture between
10401 CheckElementChange() and CheckTriggeredElementChange(): while
10402 the first one only affects single elements that are triggered
10403 directly, the second one affects multiple elements in the playfield
10404 that are triggered indirectly by another element. This is a third
10405 case: Changing the CE score always affects multiple identical CEs,
10406 so every affected CE must be checked, not only the single CE for
10407 which the CE score was changed in the first place (as every instance
10408 of that CE shares the same CE score, and therefore also can change)!
10410 SCAN_PLAYFIELD(xx, yy)
10412 if (Tile[xx][yy] == element)
10413 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10414 CE_SCORE_GETS_ZERO);
10422 case CA_SET_CE_ARTWORK:
10424 int artwork_element = action_arg_element;
10425 boolean reset_frame = FALSE;
10428 if (action_arg == CA_ARG_ELEMENT_RESET)
10429 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10432 if (ei->gfx_element != artwork_element)
10433 reset_frame = TRUE;
10435 ei->gfx_element = artwork_element;
10437 SCAN_PLAYFIELD(xx, yy)
10439 if (Tile[xx][yy] == element)
10443 ResetGfxAnimation(xx, yy);
10444 ResetRandomAnimationValue(xx, yy);
10447 TEST_DrawLevelField(xx, yy);
10454 // ---------- engine actions ---------------------------------------------
10456 case CA_SET_ENGINE_SCAN_MODE:
10458 InitPlayfieldScanMode(action_arg);
10468 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10470 int old_element = Tile[x][y];
10471 int new_element = GetElementFromGroupElement(element);
10472 int previous_move_direction = MovDir[x][y];
10473 int last_ce_value = CustomValue[x][y];
10474 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10475 boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
10476 boolean add_player_onto_element = (new_element_is_player &&
10477 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10478 IS_WALKABLE(old_element));
10480 if (!add_player_onto_element)
10482 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10483 RemoveMovingField(x, y);
10487 Tile[x][y] = new_element;
10489 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10490 MovDir[x][y] = previous_move_direction;
10492 if (element_info[new_element].use_last_ce_value)
10493 CustomValue[x][y] = last_ce_value;
10495 InitField_WithBug1(x, y, FALSE);
10497 new_element = Tile[x][y]; // element may have changed
10499 ResetGfxAnimation(x, y);
10500 ResetRandomAnimationValue(x, y);
10502 TEST_DrawLevelField(x, y);
10504 if (GFX_CRUMBLED(new_element))
10505 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10508 // check if element under the player changes from accessible to unaccessible
10509 // (needed for special case of dropping element which then changes)
10510 // (must be checked after creating new element for walkable group elements)
10511 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10512 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10519 // "ChangeCount" not set yet to allow "entered by player" change one time
10520 if (new_element_is_player)
10521 RelocatePlayer(x, y, new_element);
10524 ChangeCount[x][y]++; // count number of changes in the same frame
10526 TestIfBadThingTouchesPlayer(x, y);
10527 TestIfPlayerTouchesCustomElement(x, y);
10528 TestIfElementTouchesCustomElement(x, y);
10531 static void CreateField(int x, int y, int element)
10533 CreateFieldExt(x, y, element, FALSE);
10536 static void CreateElementFromChange(int x, int y, int element)
10538 element = GET_VALID_RUNTIME_ELEMENT(element);
10540 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10542 int old_element = Tile[x][y];
10544 // prevent changed element from moving in same engine frame
10545 // unless both old and new element can either fall or move
10546 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10547 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10551 CreateFieldExt(x, y, element, TRUE);
10554 static boolean ChangeElement(int x, int y, int element, int page)
10556 struct ElementInfo *ei = &element_info[element];
10557 struct ElementChangeInfo *change = &ei->change_page[page];
10558 int ce_value = CustomValue[x][y];
10559 int ce_score = ei->collect_score;
10560 int target_element;
10561 int old_element = Tile[x][y];
10563 // always use default change event to prevent running into a loop
10564 if (ChangeEvent[x][y] == -1)
10565 ChangeEvent[x][y] = CE_DELAY;
10567 if (ChangeEvent[x][y] == CE_DELAY)
10569 // reset actual trigger element, trigger player and action element
10570 change->actual_trigger_element = EL_EMPTY;
10571 change->actual_trigger_player = EL_EMPTY;
10572 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10573 change->actual_trigger_side = CH_SIDE_NONE;
10574 change->actual_trigger_ce_value = 0;
10575 change->actual_trigger_ce_score = 0;
10578 // do not change elements more than a specified maximum number of changes
10579 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10582 ChangeCount[x][y]++; // count number of changes in the same frame
10584 if (change->explode)
10591 if (change->use_target_content)
10593 boolean complete_replace = TRUE;
10594 boolean can_replace[3][3];
10597 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10600 boolean is_walkable;
10601 boolean is_diggable;
10602 boolean is_collectible;
10603 boolean is_removable;
10604 boolean is_destructible;
10605 int ex = x + xx - 1;
10606 int ey = y + yy - 1;
10607 int content_element = change->target_content.e[xx][yy];
10610 can_replace[xx][yy] = TRUE;
10612 if (ex == x && ey == y) // do not check changing element itself
10615 if (content_element == EL_EMPTY_SPACE)
10617 can_replace[xx][yy] = FALSE; // do not replace border with space
10622 if (!IN_LEV_FIELD(ex, ey))
10624 can_replace[xx][yy] = FALSE;
10625 complete_replace = FALSE;
10632 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10633 e = MovingOrBlocked2Element(ex, ey);
10635 is_empty = (IS_FREE(ex, ey) ||
10636 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10638 is_walkable = (is_empty || IS_WALKABLE(e));
10639 is_diggable = (is_empty || IS_DIGGABLE(e));
10640 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10641 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10642 is_removable = (is_diggable || is_collectible);
10644 can_replace[xx][yy] =
10645 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10646 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10647 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10648 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10649 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10650 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10651 !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
10653 if (!can_replace[xx][yy])
10654 complete_replace = FALSE;
10657 if (!change->only_if_complete || complete_replace)
10659 boolean something_has_changed = FALSE;
10661 if (change->only_if_complete && change->use_random_replace &&
10662 RND(100) < change->random_percentage)
10665 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10667 int ex = x + xx - 1;
10668 int ey = y + yy - 1;
10669 int content_element;
10671 if (can_replace[xx][yy] && (!change->use_random_replace ||
10672 RND(100) < change->random_percentage))
10674 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10675 RemoveMovingField(ex, ey);
10677 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10679 content_element = change->target_content.e[xx][yy];
10680 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10681 ce_value, ce_score);
10683 CreateElementFromChange(ex, ey, target_element);
10685 something_has_changed = TRUE;
10687 // for symmetry reasons, freeze newly created border elements
10688 if (ex != x || ey != y)
10689 Stop[ex][ey] = TRUE; // no more moving in this frame
10693 if (something_has_changed)
10695 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10696 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10702 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10703 ce_value, ce_score);
10705 if (element == EL_DIAGONAL_GROWING ||
10706 element == EL_DIAGONAL_SHRINKING)
10708 target_element = Store[x][y];
10710 Store[x][y] = EL_EMPTY;
10713 CreateElementFromChange(x, y, target_element);
10715 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10716 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10719 // this uses direct change before indirect change
10720 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10725 static void HandleElementChange(int x, int y, int page)
10727 int element = MovingOrBlocked2Element(x, y);
10728 struct ElementInfo *ei = &element_info[element];
10729 struct ElementChangeInfo *change = &ei->change_page[page];
10730 boolean handle_action_before_change = FALSE;
10733 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10734 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10736 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10737 x, y, element, element_info[element].token_name);
10738 Debug("game:playing:HandleElementChange", "This should never happen!");
10742 // this can happen with classic bombs on walkable, changing elements
10743 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10748 if (ChangeDelay[x][y] == 0) // initialize element change
10750 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10752 if (change->can_change)
10754 // !!! not clear why graphic animation should be reset at all here !!!
10755 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10756 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10759 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10761 When using an animation frame delay of 1 (this only happens with
10762 "sp_zonk.moving.left/right" in the classic graphics), the default
10763 (non-moving) animation shows wrong animation frames (while the
10764 moving animation, like "sp_zonk.moving.left/right", is correct,
10765 so this graphical bug never shows up with the classic graphics).
10766 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10767 be drawn instead of the correct frames 0,1,2,3. This is caused by
10768 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10769 an element change: First when the change delay ("ChangeDelay[][]")
10770 counter has reached zero after decrementing, then a second time in
10771 the next frame (after "GfxFrame[][]" was already incremented) when
10772 "ChangeDelay[][]" is reset to the initial delay value again.
10774 This causes frame 0 to be drawn twice, while the last frame won't
10775 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10777 As some animations may already be cleverly designed around this bug
10778 (at least the "Snake Bite" snake tail animation does this), it cannot
10779 simply be fixed here without breaking such existing animations.
10780 Unfortunately, it cannot easily be detected if a graphics set was
10781 designed "before" or "after" the bug was fixed. As a workaround,
10782 a new graphics set option "game.graphics_engine_version" was added
10783 to be able to specify the game's major release version for which the
10784 graphics set was designed, which can then be used to decide if the
10785 bugfix should be used (version 4 and above) or not (version 3 or
10786 below, or if no version was specified at all, as with old sets).
10788 (The wrong/fixed animation frames can be tested with the test level set
10789 "test_gfxframe" and level "000", which contains a specially prepared
10790 custom element at level position (x/y) == (11/9) which uses the zonk
10791 animation mentioned above. Using "game.graphics_engine_version: 4"
10792 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10793 This can also be seen from the debug output for this test element.)
10796 // when a custom element is about to change (for example by change delay),
10797 // do not reset graphic animation when the custom element is moving
10798 if (game.graphics_engine_version < 4 &&
10801 ResetGfxAnimation(x, y);
10802 ResetRandomAnimationValue(x, y);
10805 if (change->pre_change_function)
10806 change->pre_change_function(x, y);
10810 ChangeDelay[x][y]--;
10812 if (ChangeDelay[x][y] != 0) // continue element change
10814 if (change->can_change)
10816 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10818 if (IS_ANIMATED(graphic))
10819 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10821 if (change->change_function)
10822 change->change_function(x, y);
10825 else // finish element change
10827 if (ChangePage[x][y] != -1) // remember page from delayed change
10829 page = ChangePage[x][y];
10830 ChangePage[x][y] = -1;
10832 change = &ei->change_page[page];
10835 if (IS_MOVING(x, y)) // never change a running system ;-)
10837 ChangeDelay[x][y] = 1; // try change after next move step
10838 ChangePage[x][y] = page; // remember page to use for change
10843 // special case: set new level random seed before changing element
10844 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10845 handle_action_before_change = TRUE;
10847 if (change->has_action && handle_action_before_change)
10848 ExecuteCustomElementAction(x, y, element, page);
10850 if (change->can_change)
10852 if (ChangeElement(x, y, element, page))
10854 if (change->post_change_function)
10855 change->post_change_function(x, y);
10859 if (change->has_action && !handle_action_before_change)
10860 ExecuteCustomElementAction(x, y, element, page);
10864 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10865 int trigger_element,
10867 int trigger_player,
10871 boolean change_done_any = FALSE;
10872 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
10875 if (!(trigger_events[trigger_element][trigger_event]))
10878 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10880 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10882 int element = EL_CUSTOM_START + i;
10883 boolean change_done = FALSE;
10886 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10887 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10890 for (p = 0; p < element_info[element].num_change_pages; p++)
10892 struct ElementChangeInfo *change = &element_info[element].change_page[p];
10894 if (change->can_change_or_has_action &&
10895 change->has_event[trigger_event] &&
10896 change->trigger_side & trigger_side &&
10897 change->trigger_player & trigger_player &&
10898 change->trigger_page & trigger_page_bits &&
10899 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
10901 change->actual_trigger_element = trigger_element;
10902 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
10903 change->actual_trigger_player_bits = trigger_player;
10904 change->actual_trigger_side = trigger_side;
10905 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
10906 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
10908 if ((change->can_change && !change_done) || change->has_action)
10912 SCAN_PLAYFIELD(x, y)
10914 if (Tile[x][y] == element)
10916 if (change->can_change && !change_done)
10918 // if element already changed in this frame, not only prevent
10919 // another element change (checked in ChangeElement()), but
10920 // also prevent additional element actions for this element
10922 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
10923 !level.use_action_after_change_bug)
10926 ChangeDelay[x][y] = 1;
10927 ChangeEvent[x][y] = trigger_event;
10929 HandleElementChange(x, y, p);
10931 else if (change->has_action)
10933 // if element already changed in this frame, not only prevent
10934 // another element change (checked in ChangeElement()), but
10935 // also prevent additional element actions for this element
10937 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
10938 !level.use_action_after_change_bug)
10941 ExecuteCustomElementAction(x, y, element, p);
10942 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
10947 if (change->can_change)
10949 change_done = TRUE;
10950 change_done_any = TRUE;
10957 RECURSION_LOOP_DETECTION_END();
10959 return change_done_any;
10962 static boolean CheckElementChangeExt(int x, int y,
10964 int trigger_element,
10966 int trigger_player,
10969 boolean change_done = FALSE;
10972 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10973 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10976 if (Tile[x][y] == EL_BLOCKED)
10978 Blocked2Moving(x, y, &x, &y);
10979 element = Tile[x][y];
10982 // check if element has already changed or is about to change after moving
10983 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
10984 Tile[x][y] != element) ||
10986 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
10987 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
10988 ChangePage[x][y] != -1)))
10991 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10993 for (p = 0; p < element_info[element].num_change_pages; p++)
10995 struct ElementChangeInfo *change = &element_info[element].change_page[p];
10997 /* check trigger element for all events where the element that is checked
10998 for changing interacts with a directly adjacent element -- this is
10999 different to element changes that affect other elements to change on the
11000 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11001 boolean check_trigger_element =
11002 (trigger_event == CE_TOUCHING_X ||
11003 trigger_event == CE_HITTING_X ||
11004 trigger_event == CE_HIT_BY_X ||
11005 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11007 if (change->can_change_or_has_action &&
11008 change->has_event[trigger_event] &&
11009 change->trigger_side & trigger_side &&
11010 change->trigger_player & trigger_player &&
11011 (!check_trigger_element ||
11012 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11014 change->actual_trigger_element = trigger_element;
11015 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11016 change->actual_trigger_player_bits = trigger_player;
11017 change->actual_trigger_side = trigger_side;
11018 change->actual_trigger_ce_value = CustomValue[x][y];
11019 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11021 // special case: trigger element not at (x,y) position for some events
11022 if (check_trigger_element)
11034 { 0, 0 }, { 0, 0 }, { 0, 0 },
11038 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11039 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11041 change->actual_trigger_ce_value = CustomValue[xx][yy];
11042 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11045 if (change->can_change && !change_done)
11047 ChangeDelay[x][y] = 1;
11048 ChangeEvent[x][y] = trigger_event;
11050 HandleElementChange(x, y, p);
11052 change_done = TRUE;
11054 else if (change->has_action)
11056 ExecuteCustomElementAction(x, y, element, p);
11057 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11062 RECURSION_LOOP_DETECTION_END();
11064 return change_done;
11067 static void PlayPlayerSound(struct PlayerInfo *player)
11069 int jx = player->jx, jy = player->jy;
11070 int sound_element = player->artwork_element;
11071 int last_action = player->last_action_waiting;
11072 int action = player->action_waiting;
11074 if (player->is_waiting)
11076 if (action != last_action)
11077 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11079 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11083 if (action != last_action)
11084 StopSound(element_info[sound_element].sound[last_action]);
11086 if (last_action == ACTION_SLEEPING)
11087 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11091 static void PlayAllPlayersSound(void)
11095 for (i = 0; i < MAX_PLAYERS; i++)
11096 if (stored_player[i].active)
11097 PlayPlayerSound(&stored_player[i]);
11100 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11102 boolean last_waiting = player->is_waiting;
11103 int move_dir = player->MovDir;
11105 player->dir_waiting = move_dir;
11106 player->last_action_waiting = player->action_waiting;
11110 if (!last_waiting) // not waiting -> waiting
11112 player->is_waiting = TRUE;
11114 player->frame_counter_bored =
11116 game.player_boring_delay_fixed +
11117 GetSimpleRandom(game.player_boring_delay_random);
11118 player->frame_counter_sleeping =
11120 game.player_sleeping_delay_fixed +
11121 GetSimpleRandom(game.player_sleeping_delay_random);
11123 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11126 if (game.player_sleeping_delay_fixed +
11127 game.player_sleeping_delay_random > 0 &&
11128 player->anim_delay_counter == 0 &&
11129 player->post_delay_counter == 0 &&
11130 FrameCounter >= player->frame_counter_sleeping)
11131 player->is_sleeping = TRUE;
11132 else if (game.player_boring_delay_fixed +
11133 game.player_boring_delay_random > 0 &&
11134 FrameCounter >= player->frame_counter_bored)
11135 player->is_bored = TRUE;
11137 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11138 player->is_bored ? ACTION_BORING :
11141 if (player->is_sleeping && player->use_murphy)
11143 // special case for sleeping Murphy when leaning against non-free tile
11145 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11146 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11147 !IS_MOVING(player->jx - 1, player->jy)))
11148 move_dir = MV_LEFT;
11149 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11150 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11151 !IS_MOVING(player->jx + 1, player->jy)))
11152 move_dir = MV_RIGHT;
11154 player->is_sleeping = FALSE;
11156 player->dir_waiting = move_dir;
11159 if (player->is_sleeping)
11161 if (player->num_special_action_sleeping > 0)
11163 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11165 int last_special_action = player->special_action_sleeping;
11166 int num_special_action = player->num_special_action_sleeping;
11167 int special_action =
11168 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11169 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11170 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11171 last_special_action + 1 : ACTION_SLEEPING);
11172 int special_graphic =
11173 el_act_dir2img(player->artwork_element, special_action, move_dir);
11175 player->anim_delay_counter =
11176 graphic_info[special_graphic].anim_delay_fixed +
11177 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11178 player->post_delay_counter =
11179 graphic_info[special_graphic].post_delay_fixed +
11180 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11182 player->special_action_sleeping = special_action;
11185 if (player->anim_delay_counter > 0)
11187 player->action_waiting = player->special_action_sleeping;
11188 player->anim_delay_counter--;
11190 else if (player->post_delay_counter > 0)
11192 player->post_delay_counter--;
11196 else if (player->is_bored)
11198 if (player->num_special_action_bored > 0)
11200 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11202 int special_action =
11203 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11204 int special_graphic =
11205 el_act_dir2img(player->artwork_element, special_action, move_dir);
11207 player->anim_delay_counter =
11208 graphic_info[special_graphic].anim_delay_fixed +
11209 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11210 player->post_delay_counter =
11211 graphic_info[special_graphic].post_delay_fixed +
11212 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11214 player->special_action_bored = special_action;
11217 if (player->anim_delay_counter > 0)
11219 player->action_waiting = player->special_action_bored;
11220 player->anim_delay_counter--;
11222 else if (player->post_delay_counter > 0)
11224 player->post_delay_counter--;
11229 else if (last_waiting) // waiting -> not waiting
11231 player->is_waiting = FALSE;
11232 player->is_bored = FALSE;
11233 player->is_sleeping = FALSE;
11235 player->frame_counter_bored = -1;
11236 player->frame_counter_sleeping = -1;
11238 player->anim_delay_counter = 0;
11239 player->post_delay_counter = 0;
11241 player->dir_waiting = player->MovDir;
11242 player->action_waiting = ACTION_DEFAULT;
11244 player->special_action_bored = ACTION_DEFAULT;
11245 player->special_action_sleeping = ACTION_DEFAULT;
11249 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11251 if ((!player->is_moving && player->was_moving) ||
11252 (player->MovPos == 0 && player->was_moving) ||
11253 (player->is_snapping && !player->was_snapping) ||
11254 (player->is_dropping && !player->was_dropping))
11256 if (!CheckSaveEngineSnapshotToList())
11259 player->was_moving = FALSE;
11260 player->was_snapping = TRUE;
11261 player->was_dropping = TRUE;
11265 if (player->is_moving)
11266 player->was_moving = TRUE;
11268 if (!player->is_snapping)
11269 player->was_snapping = FALSE;
11271 if (!player->is_dropping)
11272 player->was_dropping = FALSE;
11275 static struct MouseActionInfo mouse_action_last = { 0 };
11276 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11277 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11280 CheckSaveEngineSnapshotToList();
11282 mouse_action_last = mouse_action;
11285 static void CheckSingleStepMode(struct PlayerInfo *player)
11287 if (tape.single_step && tape.recording && !tape.pausing)
11289 // as it is called "single step mode", just return to pause mode when the
11290 // player stopped moving after one tile (or never starts moving at all)
11291 // (reverse logic needed here in case single step mode used in team mode)
11292 if (player->is_moving ||
11293 player->is_pushing ||
11294 player->is_dropping_pressed ||
11295 player->effective_mouse_action.button)
11296 game.enter_single_step_mode = FALSE;
11299 CheckSaveEngineSnapshot(player);
11302 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11304 int left = player_action & JOY_LEFT;
11305 int right = player_action & JOY_RIGHT;
11306 int up = player_action & JOY_UP;
11307 int down = player_action & JOY_DOWN;
11308 int button1 = player_action & JOY_BUTTON_1;
11309 int button2 = player_action & JOY_BUTTON_2;
11310 int dx = (left ? -1 : right ? 1 : 0);
11311 int dy = (up ? -1 : down ? 1 : 0);
11313 if (!player->active || tape.pausing)
11319 SnapField(player, dx, dy);
11323 DropElement(player);
11325 MovePlayer(player, dx, dy);
11328 CheckSingleStepMode(player);
11330 SetPlayerWaiting(player, FALSE);
11332 return player_action;
11336 // no actions for this player (no input at player's configured device)
11338 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11339 SnapField(player, 0, 0);
11340 CheckGravityMovementWhenNotMoving(player);
11342 if (player->MovPos == 0)
11343 SetPlayerWaiting(player, TRUE);
11345 if (player->MovPos == 0) // needed for tape.playing
11346 player->is_moving = FALSE;
11348 player->is_dropping = FALSE;
11349 player->is_dropping_pressed = FALSE;
11350 player->drop_pressed_delay = 0;
11352 CheckSingleStepMode(player);
11358 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11361 if (!tape.use_mouse_actions)
11364 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11365 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11366 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11369 static void SetTapeActionFromMouseAction(byte *tape_action,
11370 struct MouseActionInfo *mouse_action)
11372 if (!tape.use_mouse_actions)
11375 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11376 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11377 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11380 static void CheckLevelSolved(void)
11382 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11384 if (game_em.level_solved &&
11385 !game_em.game_over) // game won
11389 game_em.game_over = TRUE;
11391 game.all_players_gone = TRUE;
11394 if (game_em.game_over) // game lost
11395 game.all_players_gone = TRUE;
11397 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11399 if (game_sp.level_solved &&
11400 !game_sp.game_over) // game won
11404 game_sp.game_over = TRUE;
11406 game.all_players_gone = TRUE;
11409 if (game_sp.game_over) // game lost
11410 game.all_players_gone = TRUE;
11412 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11414 if (game_mm.level_solved &&
11415 !game_mm.game_over) // game won
11419 game_mm.game_over = TRUE;
11421 game.all_players_gone = TRUE;
11424 if (game_mm.game_over) // game lost
11425 game.all_players_gone = TRUE;
11429 static void CheckLevelTime(void)
11433 if (TimeFrames >= FRAMES_PER_SECOND)
11438 for (i = 0; i < MAX_PLAYERS; i++)
11440 struct PlayerInfo *player = &stored_player[i];
11442 if (SHIELD_ON(player))
11444 player->shield_normal_time_left--;
11446 if (player->shield_deadly_time_left > 0)
11447 player->shield_deadly_time_left--;
11451 if (!game.LevelSolved && !level.use_step_counter)
11459 if (TimeLeft <= 10 && setup.time_limit)
11460 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11462 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11463 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11465 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11467 if (!TimeLeft && setup.time_limit)
11469 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11470 game_em.lev->killed_out_of_time = TRUE;
11472 for (i = 0; i < MAX_PLAYERS; i++)
11473 KillPlayer(&stored_player[i]);
11476 else if (game.no_time_limit && !game.all_players_gone)
11478 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11481 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11484 if (tape.recording || tape.playing)
11485 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11488 if (tape.recording || tape.playing)
11489 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11491 UpdateAndDisplayGameControlValues();
11494 void AdvanceFrameAndPlayerCounters(int player_nr)
11498 // advance frame counters (global frame counter and time frame counter)
11502 // advance player counters (counters for move delay, move animation etc.)
11503 for (i = 0; i < MAX_PLAYERS; i++)
11505 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11506 int move_delay_value = stored_player[i].move_delay_value;
11507 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11509 if (!advance_player_counters) // not all players may be affected
11512 if (move_frames == 0) // less than one move per game frame
11514 int stepsize = TILEX / move_delay_value;
11515 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11516 int count = (stored_player[i].is_moving ?
11517 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11519 if (count % delay == 0)
11523 stored_player[i].Frame += move_frames;
11525 if (stored_player[i].MovPos != 0)
11526 stored_player[i].StepFrame += move_frames;
11528 if (stored_player[i].move_delay > 0)
11529 stored_player[i].move_delay--;
11531 // due to bugs in previous versions, counter must count up, not down
11532 if (stored_player[i].push_delay != -1)
11533 stored_player[i].push_delay++;
11535 if (stored_player[i].drop_delay > 0)
11536 stored_player[i].drop_delay--;
11538 if (stored_player[i].is_dropping_pressed)
11539 stored_player[i].drop_pressed_delay++;
11543 void StartGameActions(boolean init_network_game, boolean record_tape,
11546 unsigned int new_random_seed = InitRND(random_seed);
11549 TapeStartRecording(new_random_seed);
11551 if (init_network_game)
11553 SendToServer_LevelFile();
11554 SendToServer_StartPlaying();
11562 static void GameActionsExt(void)
11565 static unsigned int game_frame_delay = 0;
11567 unsigned int game_frame_delay_value;
11568 byte *recorded_player_action;
11569 byte summarized_player_action = 0;
11570 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11573 // detect endless loops, caused by custom element programming
11574 if (recursion_loop_detected && recursion_loop_depth == 0)
11576 char *message = getStringCat3("Internal Error! Element ",
11577 EL_NAME(recursion_loop_element),
11578 " caused endless loop! Quit the game?");
11580 Warn("element '%s' caused endless loop in game engine",
11581 EL_NAME(recursion_loop_element));
11583 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11585 recursion_loop_detected = FALSE; // if game should be continued
11592 if (game.restart_level)
11593 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11595 CheckLevelSolved();
11597 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11600 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11603 if (game_status != GAME_MODE_PLAYING) // status might have changed
11606 game_frame_delay_value =
11607 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11609 if (tape.playing && tape.warp_forward && !tape.pausing)
11610 game_frame_delay_value = 0;
11612 SetVideoFrameDelay(game_frame_delay_value);
11614 // (de)activate virtual buttons depending on current game status
11615 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11617 if (game.all_players_gone) // if no players there to be controlled anymore
11618 SetOverlayActive(FALSE);
11619 else if (!tape.playing) // if game continues after tape stopped playing
11620 SetOverlayActive(TRUE);
11625 // ---------- main game synchronization point ----------
11627 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11629 Debug("game:playing:skip", "skip == %d", skip);
11632 // ---------- main game synchronization point ----------
11634 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11638 if (network_playing && !network_player_action_received)
11640 // try to get network player actions in time
11642 // last chance to get network player actions without main loop delay
11643 HandleNetworking();
11645 // game was quit by network peer
11646 if (game_status != GAME_MODE_PLAYING)
11649 // check if network player actions still missing and game still running
11650 if (!network_player_action_received && !checkGameEnded())
11651 return; // failed to get network player actions in time
11653 // do not yet reset "network_player_action_received" (for tape.pausing)
11659 // at this point we know that we really continue executing the game
11661 network_player_action_received = FALSE;
11663 // when playing tape, read previously recorded player input from tape data
11664 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11666 local_player->effective_mouse_action = local_player->mouse_action;
11668 if (recorded_player_action != NULL)
11669 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11670 recorded_player_action);
11672 // TapePlayAction() may return NULL when toggling to "pause before death"
11676 if (tape.set_centered_player)
11678 game.centered_player_nr_next = tape.centered_player_nr_next;
11679 game.set_centered_player = TRUE;
11682 for (i = 0; i < MAX_PLAYERS; i++)
11684 summarized_player_action |= stored_player[i].action;
11686 if (!network_playing && (game.team_mode || tape.playing))
11687 stored_player[i].effective_action = stored_player[i].action;
11690 if (network_playing && !checkGameEnded())
11691 SendToServer_MovePlayer(summarized_player_action);
11693 // summarize all actions at local players mapped input device position
11694 // (this allows using different input devices in single player mode)
11695 if (!network.enabled && !game.team_mode)
11696 stored_player[map_player_action[local_player->index_nr]].effective_action =
11697 summarized_player_action;
11699 // summarize all actions at centered player in local team mode
11700 if (tape.recording &&
11701 setup.team_mode && !network.enabled &&
11702 setup.input_on_focus &&
11703 game.centered_player_nr != -1)
11705 for (i = 0; i < MAX_PLAYERS; i++)
11706 stored_player[map_player_action[i]].effective_action =
11707 (i == game.centered_player_nr ? summarized_player_action : 0);
11710 if (recorded_player_action != NULL)
11711 for (i = 0; i < MAX_PLAYERS; i++)
11712 stored_player[i].effective_action = recorded_player_action[i];
11714 for (i = 0; i < MAX_PLAYERS; i++)
11716 tape_action[i] = stored_player[i].effective_action;
11718 /* (this may happen in the RND game engine if a player was not present on
11719 the playfield on level start, but appeared later from a custom element */
11720 if (setup.team_mode &&
11723 !tape.player_participates[i])
11724 tape.player_participates[i] = TRUE;
11727 SetTapeActionFromMouseAction(tape_action,
11728 &local_player->effective_mouse_action);
11730 // only record actions from input devices, but not programmed actions
11731 if (tape.recording)
11732 TapeRecordAction(tape_action);
11734 // remember if game was played (especially after tape stopped playing)
11735 if (!tape.playing && summarized_player_action)
11736 game.GamePlayed = TRUE;
11738 #if USE_NEW_PLAYER_ASSIGNMENTS
11739 // !!! also map player actions in single player mode !!!
11740 // if (game.team_mode)
11743 byte mapped_action[MAX_PLAYERS];
11745 #if DEBUG_PLAYER_ACTIONS
11746 for (i = 0; i < MAX_PLAYERS; i++)
11747 DebugContinued("", "%d, ", stored_player[i].effective_action);
11750 for (i = 0; i < MAX_PLAYERS; i++)
11751 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11753 for (i = 0; i < MAX_PLAYERS; i++)
11754 stored_player[i].effective_action = mapped_action[i];
11756 #if DEBUG_PLAYER_ACTIONS
11757 DebugContinued("", "=> ");
11758 for (i = 0; i < MAX_PLAYERS; i++)
11759 DebugContinued("", "%d, ", stored_player[i].effective_action);
11760 DebugContinued("game:playing:player", "\n");
11763 #if DEBUG_PLAYER_ACTIONS
11766 for (i = 0; i < MAX_PLAYERS; i++)
11767 DebugContinued("", "%d, ", stored_player[i].effective_action);
11768 DebugContinued("game:playing:player", "\n");
11773 for (i = 0; i < MAX_PLAYERS; i++)
11775 // allow engine snapshot in case of changed movement attempt
11776 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11777 (stored_player[i].effective_action & KEY_MOTION))
11778 game.snapshot.changed_action = TRUE;
11780 // allow engine snapshot in case of snapping/dropping attempt
11781 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11782 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11783 game.snapshot.changed_action = TRUE;
11785 game.snapshot.last_action[i] = stored_player[i].effective_action;
11788 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11790 GameActions_EM_Main();
11792 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11794 GameActions_SP_Main();
11796 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11798 GameActions_MM_Main();
11802 GameActions_RND_Main();
11805 BlitScreenToBitmap(backbuffer);
11807 CheckLevelSolved();
11810 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11812 if (global.show_frames_per_second)
11814 static unsigned int fps_counter = 0;
11815 static int fps_frames = 0;
11816 unsigned int fps_delay_ms = Counter() - fps_counter;
11820 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11822 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11825 fps_counter = Counter();
11827 // always draw FPS to screen after FPS value was updated
11828 redraw_mask |= REDRAW_FPS;
11831 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11832 if (GetDrawDeactivationMask() == REDRAW_NONE)
11833 redraw_mask |= REDRAW_FPS;
11837 static void GameActions_CheckSaveEngineSnapshot(void)
11839 if (!game.snapshot.save_snapshot)
11842 // clear flag for saving snapshot _before_ saving snapshot
11843 game.snapshot.save_snapshot = FALSE;
11845 SaveEngineSnapshotToList();
11848 void GameActions(void)
11852 GameActions_CheckSaveEngineSnapshot();
11855 void GameActions_EM_Main(void)
11857 byte effective_action[MAX_PLAYERS];
11858 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11861 for (i = 0; i < MAX_PLAYERS; i++)
11862 effective_action[i] = stored_player[i].effective_action;
11864 GameActions_EM(effective_action, warp_mode);
11867 void GameActions_SP_Main(void)
11869 byte effective_action[MAX_PLAYERS];
11870 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11873 for (i = 0; i < MAX_PLAYERS; i++)
11874 effective_action[i] = stored_player[i].effective_action;
11876 GameActions_SP(effective_action, warp_mode);
11878 for (i = 0; i < MAX_PLAYERS; i++)
11880 if (stored_player[i].force_dropping)
11881 stored_player[i].action |= KEY_BUTTON_DROP;
11883 stored_player[i].force_dropping = FALSE;
11887 void GameActions_MM_Main(void)
11889 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11891 GameActions_MM(local_player->effective_mouse_action, warp_mode);
11894 void GameActions_RND_Main(void)
11899 void GameActions_RND(void)
11901 static struct MouseActionInfo mouse_action_last = { 0 };
11902 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
11903 int magic_wall_x = 0, magic_wall_y = 0;
11904 int i, x, y, element, graphic, last_gfx_frame;
11906 InitPlayfieldScanModeVars();
11908 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
11910 SCAN_PLAYFIELD(x, y)
11912 ChangeCount[x][y] = 0;
11913 ChangeEvent[x][y] = -1;
11917 if (game.set_centered_player)
11919 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
11921 // switching to "all players" only possible if all players fit to screen
11922 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
11924 game.centered_player_nr_next = game.centered_player_nr;
11925 game.set_centered_player = FALSE;
11928 // do not switch focus to non-existing (or non-active) player
11929 if (game.centered_player_nr_next >= 0 &&
11930 !stored_player[game.centered_player_nr_next].active)
11932 game.centered_player_nr_next = game.centered_player_nr;
11933 game.set_centered_player = FALSE;
11937 if (game.set_centered_player &&
11938 ScreenMovPos == 0) // screen currently aligned at tile position
11942 if (game.centered_player_nr_next == -1)
11944 setScreenCenteredToAllPlayers(&sx, &sy);
11948 sx = stored_player[game.centered_player_nr_next].jx;
11949 sy = stored_player[game.centered_player_nr_next].jy;
11952 game.centered_player_nr = game.centered_player_nr_next;
11953 game.set_centered_player = FALSE;
11955 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
11956 DrawGameDoorValues();
11959 // check single step mode (set flag and clear again if any player is active)
11960 game.enter_single_step_mode =
11961 (tape.single_step && tape.recording && !tape.pausing);
11963 for (i = 0; i < MAX_PLAYERS; i++)
11965 int actual_player_action = stored_player[i].effective_action;
11968 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
11969 - rnd_equinox_tetrachloride 048
11970 - rnd_equinox_tetrachloride_ii 096
11971 - rnd_emanuel_schmieg 002
11972 - doctor_sloan_ww 001, 020
11974 if (stored_player[i].MovPos == 0)
11975 CheckGravityMovement(&stored_player[i]);
11978 // overwrite programmed action with tape action
11979 if (stored_player[i].programmed_action)
11980 actual_player_action = stored_player[i].programmed_action;
11982 PlayerActions(&stored_player[i], actual_player_action);
11984 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
11987 // single step pause mode may already have been toggled by "ScrollPlayer()"
11988 if (game.enter_single_step_mode && !tape.pausing)
11989 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
11991 ScrollScreen(NULL, SCROLL_GO_ON);
11993 /* for backwards compatibility, the following code emulates a fixed bug that
11994 occured when pushing elements (causing elements that just made their last
11995 pushing step to already (if possible) make their first falling step in the
11996 same game frame, which is bad); this code is also needed to use the famous
11997 "spring push bug" which is used in older levels and might be wanted to be
11998 used also in newer levels, but in this case the buggy pushing code is only
11999 affecting the "spring" element and no other elements */
12001 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12003 for (i = 0; i < MAX_PLAYERS; i++)
12005 struct PlayerInfo *player = &stored_player[i];
12006 int x = player->jx;
12007 int y = player->jy;
12009 if (player->active && player->is_pushing && player->is_moving &&
12011 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12012 Tile[x][y] == EL_SPRING))
12014 ContinueMoving(x, y);
12016 // continue moving after pushing (this is actually a bug)
12017 if (!IS_MOVING(x, y))
12018 Stop[x][y] = FALSE;
12023 SCAN_PLAYFIELD(x, y)
12025 Last[x][y] = Tile[x][y];
12027 ChangeCount[x][y] = 0;
12028 ChangeEvent[x][y] = -1;
12030 // this must be handled before main playfield loop
12031 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12034 if (MovDelay[x][y] <= 0)
12038 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12041 if (MovDelay[x][y] <= 0)
12044 TEST_DrawLevelField(x, y);
12046 TestIfElementTouchesCustomElement(x, y); // for empty space
12051 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12053 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12055 Debug("game:playing:GameActions_RND", "This should never happen!");
12057 ChangePage[x][y] = -1;
12061 Stop[x][y] = FALSE;
12062 if (WasJustMoving[x][y] > 0)
12063 WasJustMoving[x][y]--;
12064 if (WasJustFalling[x][y] > 0)
12065 WasJustFalling[x][y]--;
12066 if (CheckCollision[x][y] > 0)
12067 CheckCollision[x][y]--;
12068 if (CheckImpact[x][y] > 0)
12069 CheckImpact[x][y]--;
12073 /* reset finished pushing action (not done in ContinueMoving() to allow
12074 continuous pushing animation for elements with zero push delay) */
12075 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12077 ResetGfxAnimation(x, y);
12078 TEST_DrawLevelField(x, y);
12082 if (IS_BLOCKED(x, y))
12086 Blocked2Moving(x, y, &oldx, &oldy);
12087 if (!IS_MOVING(oldx, oldy))
12089 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12090 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12091 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12092 Debug("game:playing:GameActions_RND", "This should never happen!");
12098 if (mouse_action.button)
12100 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12102 x = mouse_action.lx;
12103 y = mouse_action.ly;
12104 element = Tile[x][y];
12108 CheckElementChange(x, y, element, EL_UNDEFINED, CE_CLICKED_BY_MOUSE);
12109 CheckTriggeredElementChange(x, y, element, CE_MOUSE_CLICKED_ON_X);
12112 CheckElementChange(x, y, element, EL_UNDEFINED, CE_PRESSED_BY_MOUSE);
12113 CheckTriggeredElementChange(x, y, element, CE_MOUSE_PRESSED_ON_X);
12116 SCAN_PLAYFIELD(x, y)
12118 element = Tile[x][y];
12119 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12120 last_gfx_frame = GfxFrame[x][y];
12122 ResetGfxFrame(x, y);
12124 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12125 DrawLevelGraphicAnimation(x, y, graphic);
12127 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12128 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12129 ResetRandomAnimationValue(x, y);
12131 SetRandomAnimationValue(x, y);
12133 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12135 if (IS_INACTIVE(element))
12137 if (IS_ANIMATED(graphic))
12138 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12143 // this may take place after moving, so 'element' may have changed
12144 if (IS_CHANGING(x, y) &&
12145 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12147 int page = element_info[element].event_page_nr[CE_DELAY];
12149 HandleElementChange(x, y, page);
12151 element = Tile[x][y];
12152 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12155 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12159 element = Tile[x][y];
12160 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12162 if (IS_ANIMATED(graphic) &&
12163 !IS_MOVING(x, y) &&
12165 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12167 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12168 TEST_DrawTwinkleOnField(x, y);
12170 else if (element == EL_ACID)
12173 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12175 else if ((element == EL_EXIT_OPEN ||
12176 element == EL_EM_EXIT_OPEN ||
12177 element == EL_SP_EXIT_OPEN ||
12178 element == EL_STEEL_EXIT_OPEN ||
12179 element == EL_EM_STEEL_EXIT_OPEN ||
12180 element == EL_SP_TERMINAL ||
12181 element == EL_SP_TERMINAL_ACTIVE ||
12182 element == EL_EXTRA_TIME ||
12183 element == EL_SHIELD_NORMAL ||
12184 element == EL_SHIELD_DEADLY) &&
12185 IS_ANIMATED(graphic))
12186 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12187 else if (IS_MOVING(x, y))
12188 ContinueMoving(x, y);
12189 else if (IS_ACTIVE_BOMB(element))
12190 CheckDynamite(x, y);
12191 else if (element == EL_AMOEBA_GROWING)
12192 AmoebaGrowing(x, y);
12193 else if (element == EL_AMOEBA_SHRINKING)
12194 AmoebaShrinking(x, y);
12196 #if !USE_NEW_AMOEBA_CODE
12197 else if (IS_AMOEBALIVE(element))
12198 AmoebaReproduce(x, y);
12201 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12203 else if (element == EL_EXIT_CLOSED)
12205 else if (element == EL_EM_EXIT_CLOSED)
12207 else if (element == EL_STEEL_EXIT_CLOSED)
12208 CheckExitSteel(x, y);
12209 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12210 CheckExitSteelEM(x, y);
12211 else if (element == EL_SP_EXIT_CLOSED)
12213 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12214 element == EL_EXPANDABLE_STEELWALL_GROWING)
12215 MauerWaechst(x, y);
12216 else if (element == EL_EXPANDABLE_WALL ||
12217 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12218 element == EL_EXPANDABLE_WALL_VERTICAL ||
12219 element == EL_EXPANDABLE_WALL_ANY ||
12220 element == EL_BD_EXPANDABLE_WALL)
12221 MauerAbleger(x, y);
12222 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12223 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12224 element == EL_EXPANDABLE_STEELWALL_ANY)
12225 MauerAblegerStahl(x, y);
12226 else if (element == EL_FLAMES)
12227 CheckForDragon(x, y);
12228 else if (element == EL_EXPLOSION)
12229 ; // drawing of correct explosion animation is handled separately
12230 else if (element == EL_ELEMENT_SNAPPING ||
12231 element == EL_DIAGONAL_SHRINKING ||
12232 element == EL_DIAGONAL_GROWING)
12234 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12236 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12238 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12239 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12241 if (IS_BELT_ACTIVE(element))
12242 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12244 if (game.magic_wall_active)
12246 int jx = local_player->jx, jy = local_player->jy;
12248 // play the element sound at the position nearest to the player
12249 if ((element == EL_MAGIC_WALL_FULL ||
12250 element == EL_MAGIC_WALL_ACTIVE ||
12251 element == EL_MAGIC_WALL_EMPTYING ||
12252 element == EL_BD_MAGIC_WALL_FULL ||
12253 element == EL_BD_MAGIC_WALL_ACTIVE ||
12254 element == EL_BD_MAGIC_WALL_EMPTYING ||
12255 element == EL_DC_MAGIC_WALL_FULL ||
12256 element == EL_DC_MAGIC_WALL_ACTIVE ||
12257 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12258 ABS(x - jx) + ABS(y - jy) <
12259 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12267 #if USE_NEW_AMOEBA_CODE
12268 // new experimental amoeba growth stuff
12269 if (!(FrameCounter % 8))
12271 static unsigned int random = 1684108901;
12273 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12275 x = RND(lev_fieldx);
12276 y = RND(lev_fieldy);
12277 element = Tile[x][y];
12279 if (!IS_PLAYER(x,y) &&
12280 (element == EL_EMPTY ||
12281 CAN_GROW_INTO(element) ||
12282 element == EL_QUICKSAND_EMPTY ||
12283 element == EL_QUICKSAND_FAST_EMPTY ||
12284 element == EL_ACID_SPLASH_LEFT ||
12285 element == EL_ACID_SPLASH_RIGHT))
12287 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12288 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12289 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12290 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12291 Tile[x][y] = EL_AMOEBA_DROP;
12294 random = random * 129 + 1;
12299 game.explosions_delayed = FALSE;
12301 SCAN_PLAYFIELD(x, y)
12303 element = Tile[x][y];
12305 if (ExplodeField[x][y])
12306 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12307 else if (element == EL_EXPLOSION)
12308 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12310 ExplodeField[x][y] = EX_TYPE_NONE;
12313 game.explosions_delayed = TRUE;
12315 if (game.magic_wall_active)
12317 if (!(game.magic_wall_time_left % 4))
12319 int element = Tile[magic_wall_x][magic_wall_y];
12321 if (element == EL_BD_MAGIC_WALL_FULL ||
12322 element == EL_BD_MAGIC_WALL_ACTIVE ||
12323 element == EL_BD_MAGIC_WALL_EMPTYING)
12324 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12325 else if (element == EL_DC_MAGIC_WALL_FULL ||
12326 element == EL_DC_MAGIC_WALL_ACTIVE ||
12327 element == EL_DC_MAGIC_WALL_EMPTYING)
12328 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12330 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12333 if (game.magic_wall_time_left > 0)
12335 game.magic_wall_time_left--;
12337 if (!game.magic_wall_time_left)
12339 SCAN_PLAYFIELD(x, y)
12341 element = Tile[x][y];
12343 if (element == EL_MAGIC_WALL_ACTIVE ||
12344 element == EL_MAGIC_WALL_FULL)
12346 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12347 TEST_DrawLevelField(x, y);
12349 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12350 element == EL_BD_MAGIC_WALL_FULL)
12352 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12353 TEST_DrawLevelField(x, y);
12355 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12356 element == EL_DC_MAGIC_WALL_FULL)
12358 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12359 TEST_DrawLevelField(x, y);
12363 game.magic_wall_active = FALSE;
12368 if (game.light_time_left > 0)
12370 game.light_time_left--;
12372 if (game.light_time_left == 0)
12373 RedrawAllLightSwitchesAndInvisibleElements();
12376 if (game.timegate_time_left > 0)
12378 game.timegate_time_left--;
12380 if (game.timegate_time_left == 0)
12381 CloseAllOpenTimegates();
12384 if (game.lenses_time_left > 0)
12386 game.lenses_time_left--;
12388 if (game.lenses_time_left == 0)
12389 RedrawAllInvisibleElementsForLenses();
12392 if (game.magnify_time_left > 0)
12394 game.magnify_time_left--;
12396 if (game.magnify_time_left == 0)
12397 RedrawAllInvisibleElementsForMagnifier();
12400 for (i = 0; i < MAX_PLAYERS; i++)
12402 struct PlayerInfo *player = &stored_player[i];
12404 if (SHIELD_ON(player))
12406 if (player->shield_deadly_time_left)
12407 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12408 else if (player->shield_normal_time_left)
12409 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12413 #if USE_DELAYED_GFX_REDRAW
12414 SCAN_PLAYFIELD(x, y)
12416 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12418 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12419 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12421 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12422 DrawLevelField(x, y);
12424 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12425 DrawLevelFieldCrumbled(x, y);
12427 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12428 DrawLevelFieldCrumbledNeighbours(x, y);
12430 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12431 DrawTwinkleOnField(x, y);
12434 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12439 PlayAllPlayersSound();
12441 for (i = 0; i < MAX_PLAYERS; i++)
12443 struct PlayerInfo *player = &stored_player[i];
12445 if (player->show_envelope != 0 && (!player->active ||
12446 player->MovPos == 0))
12448 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12450 player->show_envelope = 0;
12454 // use random number generator in every frame to make it less predictable
12455 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12458 mouse_action_last = mouse_action;
12461 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12463 int min_x = x, min_y = y, max_x = x, max_y = y;
12464 int scr_fieldx = getScreenFieldSizeX();
12465 int scr_fieldy = getScreenFieldSizeY();
12468 for (i = 0; i < MAX_PLAYERS; i++)
12470 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12472 if (!stored_player[i].active || &stored_player[i] == player)
12475 min_x = MIN(min_x, jx);
12476 min_y = MIN(min_y, jy);
12477 max_x = MAX(max_x, jx);
12478 max_y = MAX(max_y, jy);
12481 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12484 static boolean AllPlayersInVisibleScreen(void)
12488 for (i = 0; i < MAX_PLAYERS; i++)
12490 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12492 if (!stored_player[i].active)
12495 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12502 void ScrollLevel(int dx, int dy)
12504 int scroll_offset = 2 * TILEX_VAR;
12507 BlitBitmap(drawto_field, drawto_field,
12508 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12509 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12510 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12511 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12512 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12513 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12517 x = (dx == 1 ? BX1 : BX2);
12518 for (y = BY1; y <= BY2; y++)
12519 DrawScreenField(x, y);
12524 y = (dy == 1 ? BY1 : BY2);
12525 for (x = BX1; x <= BX2; x++)
12526 DrawScreenField(x, y);
12529 redraw_mask |= REDRAW_FIELD;
12532 static boolean canFallDown(struct PlayerInfo *player)
12534 int jx = player->jx, jy = player->jy;
12536 return (IN_LEV_FIELD(jx, jy + 1) &&
12537 (IS_FREE(jx, jy + 1) ||
12538 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12539 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12540 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12543 static boolean canPassField(int x, int y, int move_dir)
12545 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12546 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12547 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12548 int nextx = x + dx;
12549 int nexty = y + dy;
12550 int element = Tile[x][y];
12552 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12553 !CAN_MOVE(element) &&
12554 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12555 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12556 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12559 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12561 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12562 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12563 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12567 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12568 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12569 (IS_DIGGABLE(Tile[newx][newy]) ||
12570 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12571 canPassField(newx, newy, move_dir)));
12574 static void CheckGravityMovement(struct PlayerInfo *player)
12576 if (player->gravity && !player->programmed_action)
12578 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12579 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12580 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12581 int jx = player->jx, jy = player->jy;
12582 boolean player_is_moving_to_valid_field =
12583 (!player_is_snapping &&
12584 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12585 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12586 boolean player_can_fall_down = canFallDown(player);
12588 if (player_can_fall_down &&
12589 !player_is_moving_to_valid_field)
12590 player->programmed_action = MV_DOWN;
12594 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12596 return CheckGravityMovement(player);
12598 if (player->gravity && !player->programmed_action)
12600 int jx = player->jx, jy = player->jy;
12601 boolean field_under_player_is_free =
12602 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12603 boolean player_is_standing_on_valid_field =
12604 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12605 (IS_WALKABLE(Tile[jx][jy]) &&
12606 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12608 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12609 player->programmed_action = MV_DOWN;
12614 MovePlayerOneStep()
12615 -----------------------------------------------------------------------------
12616 dx, dy: direction (non-diagonal) to try to move the player to
12617 real_dx, real_dy: direction as read from input device (can be diagonal)
12620 boolean MovePlayerOneStep(struct PlayerInfo *player,
12621 int dx, int dy, int real_dx, int real_dy)
12623 int jx = player->jx, jy = player->jy;
12624 int new_jx = jx + dx, new_jy = jy + dy;
12626 boolean player_can_move = !player->cannot_move;
12628 if (!player->active || (!dx && !dy))
12629 return MP_NO_ACTION;
12631 player->MovDir = (dx < 0 ? MV_LEFT :
12632 dx > 0 ? MV_RIGHT :
12634 dy > 0 ? MV_DOWN : MV_NONE);
12636 if (!IN_LEV_FIELD(new_jx, new_jy))
12637 return MP_NO_ACTION;
12639 if (!player_can_move)
12641 if (player->MovPos == 0)
12643 player->is_moving = FALSE;
12644 player->is_digging = FALSE;
12645 player->is_collecting = FALSE;
12646 player->is_snapping = FALSE;
12647 player->is_pushing = FALSE;
12651 if (!network.enabled && game.centered_player_nr == -1 &&
12652 !AllPlayersInSight(player, new_jx, new_jy))
12653 return MP_NO_ACTION;
12655 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12656 if (can_move != MP_MOVING)
12659 // check if DigField() has caused relocation of the player
12660 if (player->jx != jx || player->jy != jy)
12661 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12663 StorePlayer[jx][jy] = 0;
12664 player->last_jx = jx;
12665 player->last_jy = jy;
12666 player->jx = new_jx;
12667 player->jy = new_jy;
12668 StorePlayer[new_jx][new_jy] = player->element_nr;
12670 if (player->move_delay_value_next != -1)
12672 player->move_delay_value = player->move_delay_value_next;
12673 player->move_delay_value_next = -1;
12677 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12679 player->step_counter++;
12681 PlayerVisit[jx][jy] = FrameCounter;
12683 player->is_moving = TRUE;
12686 // should better be called in MovePlayer(), but this breaks some tapes
12687 ScrollPlayer(player, SCROLL_INIT);
12693 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12695 int jx = player->jx, jy = player->jy;
12696 int old_jx = jx, old_jy = jy;
12697 int moved = MP_NO_ACTION;
12699 if (!player->active)
12704 if (player->MovPos == 0)
12706 player->is_moving = FALSE;
12707 player->is_digging = FALSE;
12708 player->is_collecting = FALSE;
12709 player->is_snapping = FALSE;
12710 player->is_pushing = FALSE;
12716 if (player->move_delay > 0)
12719 player->move_delay = -1; // set to "uninitialized" value
12721 // store if player is automatically moved to next field
12722 player->is_auto_moving = (player->programmed_action != MV_NONE);
12724 // remove the last programmed player action
12725 player->programmed_action = 0;
12727 if (player->MovPos)
12729 // should only happen if pre-1.2 tape recordings are played
12730 // this is only for backward compatibility
12732 int original_move_delay_value = player->move_delay_value;
12735 Debug("game:playing:MovePlayer",
12736 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12740 // scroll remaining steps with finest movement resolution
12741 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12743 while (player->MovPos)
12745 ScrollPlayer(player, SCROLL_GO_ON);
12746 ScrollScreen(NULL, SCROLL_GO_ON);
12748 AdvanceFrameAndPlayerCounters(player->index_nr);
12751 BackToFront_WithFrameDelay(0);
12754 player->move_delay_value = original_move_delay_value;
12757 player->is_active = FALSE;
12759 if (player->last_move_dir & MV_HORIZONTAL)
12761 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12762 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12766 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12767 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12770 if (!moved && !player->is_active)
12772 player->is_moving = FALSE;
12773 player->is_digging = FALSE;
12774 player->is_collecting = FALSE;
12775 player->is_snapping = FALSE;
12776 player->is_pushing = FALSE;
12782 if (moved & MP_MOVING && !ScreenMovPos &&
12783 (player->index_nr == game.centered_player_nr ||
12784 game.centered_player_nr == -1))
12786 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12788 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12790 // actual player has left the screen -- scroll in that direction
12791 if (jx != old_jx) // player has moved horizontally
12792 scroll_x += (jx - old_jx);
12793 else // player has moved vertically
12794 scroll_y += (jy - old_jy);
12798 int offset_raw = game.scroll_delay_value;
12800 if (jx != old_jx) // player has moved horizontally
12802 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12803 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12804 int new_scroll_x = jx - MIDPOSX + offset_x;
12806 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12807 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12808 scroll_x = new_scroll_x;
12810 // don't scroll over playfield boundaries
12811 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12813 // don't scroll more than one field at a time
12814 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12816 // don't scroll against the player's moving direction
12817 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12818 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12819 scroll_x = old_scroll_x;
12821 else // player has moved vertically
12823 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12824 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12825 int new_scroll_y = jy - MIDPOSY + offset_y;
12827 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12828 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12829 scroll_y = new_scroll_y;
12831 // don't scroll over playfield boundaries
12832 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12834 // don't scroll more than one field at a time
12835 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12837 // don't scroll against the player's moving direction
12838 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12839 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12840 scroll_y = old_scroll_y;
12844 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12846 if (!network.enabled && game.centered_player_nr == -1 &&
12847 !AllPlayersInVisibleScreen())
12849 scroll_x = old_scroll_x;
12850 scroll_y = old_scroll_y;
12854 ScrollScreen(player, SCROLL_INIT);
12855 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12860 player->StepFrame = 0;
12862 if (moved & MP_MOVING)
12864 if (old_jx != jx && old_jy == jy)
12865 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
12866 else if (old_jx == jx && old_jy != jy)
12867 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
12869 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
12871 player->last_move_dir = player->MovDir;
12872 player->is_moving = TRUE;
12873 player->is_snapping = FALSE;
12874 player->is_switching = FALSE;
12875 player->is_dropping = FALSE;
12876 player->is_dropping_pressed = FALSE;
12877 player->drop_pressed_delay = 0;
12880 // should better be called here than above, but this breaks some tapes
12881 ScrollPlayer(player, SCROLL_INIT);
12886 CheckGravityMovementWhenNotMoving(player);
12888 player->is_moving = FALSE;
12890 /* at this point, the player is allowed to move, but cannot move right now
12891 (e.g. because of something blocking the way) -- ensure that the player
12892 is also allowed to move in the next frame (in old versions before 3.1.1,
12893 the player was forced to wait again for eight frames before next try) */
12895 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12896 player->move_delay = 0; // allow direct movement in the next frame
12899 if (player->move_delay == -1) // not yet initialized by DigField()
12900 player->move_delay = player->move_delay_value;
12902 if (game.engine_version < VERSION_IDENT(3,0,7,0))
12904 TestIfPlayerTouchesBadThing(jx, jy);
12905 TestIfPlayerTouchesCustomElement(jx, jy);
12908 if (!player->active)
12909 RemovePlayer(player);
12914 void ScrollPlayer(struct PlayerInfo *player, int mode)
12916 int jx = player->jx, jy = player->jy;
12917 int last_jx = player->last_jx, last_jy = player->last_jy;
12918 int move_stepsize = TILEX / player->move_delay_value;
12920 if (!player->active)
12923 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
12926 if (mode == SCROLL_INIT)
12928 player->actual_frame_counter = FrameCounter;
12929 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
12931 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
12932 Tile[last_jx][last_jy] == EL_EMPTY)
12934 int last_field_block_delay = 0; // start with no blocking at all
12935 int block_delay_adjustment = player->block_delay_adjustment;
12937 // if player blocks last field, add delay for exactly one move
12938 if (player->block_last_field)
12940 last_field_block_delay += player->move_delay_value;
12942 // when blocking enabled, prevent moving up despite gravity
12943 if (player->gravity && player->MovDir == MV_UP)
12944 block_delay_adjustment = -1;
12947 // add block delay adjustment (also possible when not blocking)
12948 last_field_block_delay += block_delay_adjustment;
12950 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
12951 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
12954 if (player->MovPos != 0) // player has not yet reached destination
12957 else if (!FrameReached(&player->actual_frame_counter, 1))
12960 if (player->MovPos != 0)
12962 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
12963 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
12965 // before DrawPlayer() to draw correct player graphic for this case
12966 if (player->MovPos == 0)
12967 CheckGravityMovement(player);
12970 if (player->MovPos == 0) // player reached destination field
12972 if (player->move_delay_reset_counter > 0)
12974 player->move_delay_reset_counter--;
12976 if (player->move_delay_reset_counter == 0)
12978 // continue with normal speed after quickly moving through gate
12979 HALVE_PLAYER_SPEED(player);
12981 // be able to make the next move without delay
12982 player->move_delay = 0;
12986 player->last_jx = jx;
12987 player->last_jy = jy;
12989 if (Tile[jx][jy] == EL_EXIT_OPEN ||
12990 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
12991 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
12992 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
12993 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
12994 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
12995 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
12996 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
12998 ExitPlayer(player);
13000 if (game.players_still_needed == 0 &&
13001 (game.friends_still_needed == 0 ||
13002 IS_SP_ELEMENT(Tile[jx][jy])))
13006 // this breaks one level: "machine", level 000
13008 int move_direction = player->MovDir;
13009 int enter_side = MV_DIR_OPPOSITE(move_direction);
13010 int leave_side = move_direction;
13011 int old_jx = last_jx;
13012 int old_jy = last_jy;
13013 int old_element = Tile[old_jx][old_jy];
13014 int new_element = Tile[jx][jy];
13016 if (IS_CUSTOM_ELEMENT(old_element))
13017 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13019 player->index_bit, leave_side);
13021 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13022 CE_PLAYER_LEAVES_X,
13023 player->index_bit, leave_side);
13025 if (IS_CUSTOM_ELEMENT(new_element))
13026 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13027 player->index_bit, enter_side);
13029 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13030 CE_PLAYER_ENTERS_X,
13031 player->index_bit, enter_side);
13033 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13034 CE_MOVE_OF_X, move_direction);
13037 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13039 TestIfPlayerTouchesBadThing(jx, jy);
13040 TestIfPlayerTouchesCustomElement(jx, jy);
13042 /* needed because pushed element has not yet reached its destination,
13043 so it would trigger a change event at its previous field location */
13044 if (!player->is_pushing)
13045 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13047 if (!player->active)
13048 RemovePlayer(player);
13051 if (!game.LevelSolved && level.use_step_counter)
13061 if (TimeLeft <= 10 && setup.time_limit)
13062 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13064 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13066 DisplayGameControlValues();
13068 if (!TimeLeft && setup.time_limit)
13069 for (i = 0; i < MAX_PLAYERS; i++)
13070 KillPlayer(&stored_player[i]);
13072 else if (game.no_time_limit && !game.all_players_gone)
13074 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13076 DisplayGameControlValues();
13080 if (tape.single_step && tape.recording && !tape.pausing &&
13081 !player->programmed_action)
13082 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13084 if (!player->programmed_action)
13085 CheckSaveEngineSnapshot(player);
13089 void ScrollScreen(struct PlayerInfo *player, int mode)
13091 static unsigned int screen_frame_counter = 0;
13093 if (mode == SCROLL_INIT)
13095 // set scrolling step size according to actual player's moving speed
13096 ScrollStepSize = TILEX / player->move_delay_value;
13098 screen_frame_counter = FrameCounter;
13099 ScreenMovDir = player->MovDir;
13100 ScreenMovPos = player->MovPos;
13101 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13104 else if (!FrameReached(&screen_frame_counter, 1))
13109 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13110 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13111 redraw_mask |= REDRAW_FIELD;
13114 ScreenMovDir = MV_NONE;
13117 void TestIfPlayerTouchesCustomElement(int x, int y)
13119 static int xy[4][2] =
13126 static int trigger_sides[4][2] =
13128 // center side border side
13129 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13130 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13131 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13132 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13134 static int touch_dir[4] =
13136 MV_LEFT | MV_RIGHT,
13141 int center_element = Tile[x][y]; // should always be non-moving!
13144 for (i = 0; i < NUM_DIRECTIONS; i++)
13146 int xx = x + xy[i][0];
13147 int yy = y + xy[i][1];
13148 int center_side = trigger_sides[i][0];
13149 int border_side = trigger_sides[i][1];
13150 int border_element;
13152 if (!IN_LEV_FIELD(xx, yy))
13155 if (IS_PLAYER(x, y)) // player found at center element
13157 struct PlayerInfo *player = PLAYERINFO(x, y);
13159 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13160 border_element = Tile[xx][yy]; // may be moving!
13161 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13162 border_element = Tile[xx][yy];
13163 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13164 border_element = MovingOrBlocked2Element(xx, yy);
13166 continue; // center and border element do not touch
13168 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13169 player->index_bit, border_side);
13170 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13171 CE_PLAYER_TOUCHES_X,
13172 player->index_bit, border_side);
13175 /* use player element that is initially defined in the level playfield,
13176 not the player element that corresponds to the runtime player number
13177 (example: a level that contains EL_PLAYER_3 as the only player would
13178 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13179 int player_element = PLAYERINFO(x, y)->initial_element;
13181 CheckElementChangeBySide(xx, yy, border_element, player_element,
13182 CE_TOUCHING_X, border_side);
13185 else if (IS_PLAYER(xx, yy)) // player found at border element
13187 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13189 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13191 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13192 continue; // center and border element do not touch
13195 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13196 player->index_bit, center_side);
13197 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13198 CE_PLAYER_TOUCHES_X,
13199 player->index_bit, center_side);
13202 /* use player element that is initially defined in the level playfield,
13203 not the player element that corresponds to the runtime player number
13204 (example: a level that contains EL_PLAYER_3 as the only player would
13205 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13206 int player_element = PLAYERINFO(xx, yy)->initial_element;
13208 CheckElementChangeBySide(x, y, center_element, player_element,
13209 CE_TOUCHING_X, center_side);
13217 void TestIfElementTouchesCustomElement(int x, int y)
13219 static int xy[4][2] =
13226 static int trigger_sides[4][2] =
13228 // center side border side
13229 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13230 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13231 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13232 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13234 static int touch_dir[4] =
13236 MV_LEFT | MV_RIGHT,
13241 boolean change_center_element = FALSE;
13242 int center_element = Tile[x][y]; // should always be non-moving!
13243 int border_element_old[NUM_DIRECTIONS];
13246 for (i = 0; i < NUM_DIRECTIONS; i++)
13248 int xx = x + xy[i][0];
13249 int yy = y + xy[i][1];
13250 int border_element;
13252 border_element_old[i] = -1;
13254 if (!IN_LEV_FIELD(xx, yy))
13257 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13258 border_element = Tile[xx][yy]; // may be moving!
13259 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13260 border_element = Tile[xx][yy];
13261 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13262 border_element = MovingOrBlocked2Element(xx, yy);
13264 continue; // center and border element do not touch
13266 border_element_old[i] = border_element;
13269 for (i = 0; i < NUM_DIRECTIONS; i++)
13271 int xx = x + xy[i][0];
13272 int yy = y + xy[i][1];
13273 int center_side = trigger_sides[i][0];
13274 int border_element = border_element_old[i];
13276 if (border_element == -1)
13279 // check for change of border element
13280 CheckElementChangeBySide(xx, yy, border_element, center_element,
13281 CE_TOUCHING_X, center_side);
13283 // (center element cannot be player, so we dont have to check this here)
13286 for (i = 0; i < NUM_DIRECTIONS; i++)
13288 int xx = x + xy[i][0];
13289 int yy = y + xy[i][1];
13290 int border_side = trigger_sides[i][1];
13291 int border_element = border_element_old[i];
13293 if (border_element == -1)
13296 // check for change of center element (but change it only once)
13297 if (!change_center_element)
13298 change_center_element =
13299 CheckElementChangeBySide(x, y, center_element, border_element,
13300 CE_TOUCHING_X, border_side);
13302 if (IS_PLAYER(xx, yy))
13304 /* use player element that is initially defined in the level playfield,
13305 not the player element that corresponds to the runtime player number
13306 (example: a level that contains EL_PLAYER_3 as the only player would
13307 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13308 int player_element = PLAYERINFO(xx, yy)->initial_element;
13310 CheckElementChangeBySide(x, y, center_element, player_element,
13311 CE_TOUCHING_X, border_side);
13316 void TestIfElementHitsCustomElement(int x, int y, int direction)
13318 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13319 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13320 int hitx = x + dx, hity = y + dy;
13321 int hitting_element = Tile[x][y];
13322 int touched_element;
13324 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13327 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13328 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13330 if (IN_LEV_FIELD(hitx, hity))
13332 int opposite_direction = MV_DIR_OPPOSITE(direction);
13333 int hitting_side = direction;
13334 int touched_side = opposite_direction;
13335 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13336 MovDir[hitx][hity] != direction ||
13337 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13343 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13344 CE_HITTING_X, touched_side);
13346 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13347 CE_HIT_BY_X, hitting_side);
13349 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13350 CE_HIT_BY_SOMETHING, opposite_direction);
13352 if (IS_PLAYER(hitx, hity))
13354 /* use player element that is initially defined in the level playfield,
13355 not the player element that corresponds to the runtime player number
13356 (example: a level that contains EL_PLAYER_3 as the only player would
13357 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13358 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13360 CheckElementChangeBySide(x, y, hitting_element, player_element,
13361 CE_HITTING_X, touched_side);
13366 // "hitting something" is also true when hitting the playfield border
13367 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13368 CE_HITTING_SOMETHING, direction);
13371 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13373 int i, kill_x = -1, kill_y = -1;
13375 int bad_element = -1;
13376 static int test_xy[4][2] =
13383 static int test_dir[4] =
13391 for (i = 0; i < NUM_DIRECTIONS; i++)
13393 int test_x, test_y, test_move_dir, test_element;
13395 test_x = good_x + test_xy[i][0];
13396 test_y = good_y + test_xy[i][1];
13398 if (!IN_LEV_FIELD(test_x, test_y))
13402 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13404 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13406 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13407 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13409 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13410 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13414 bad_element = test_element;
13420 if (kill_x != -1 || kill_y != -1)
13422 if (IS_PLAYER(good_x, good_y))
13424 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13426 if (player->shield_deadly_time_left > 0 &&
13427 !IS_INDESTRUCTIBLE(bad_element))
13428 Bang(kill_x, kill_y);
13429 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13430 KillPlayer(player);
13433 Bang(good_x, good_y);
13437 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13439 int i, kill_x = -1, kill_y = -1;
13440 int bad_element = Tile[bad_x][bad_y];
13441 static int test_xy[4][2] =
13448 static int touch_dir[4] =
13450 MV_LEFT | MV_RIGHT,
13455 static int test_dir[4] =
13463 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13466 for (i = 0; i < NUM_DIRECTIONS; i++)
13468 int test_x, test_y, test_move_dir, test_element;
13470 test_x = bad_x + test_xy[i][0];
13471 test_y = bad_y + test_xy[i][1];
13473 if (!IN_LEV_FIELD(test_x, test_y))
13477 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13479 test_element = Tile[test_x][test_y];
13481 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13482 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13484 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13485 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13487 // good thing is player or penguin that does not move away
13488 if (IS_PLAYER(test_x, test_y))
13490 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13492 if (bad_element == EL_ROBOT && player->is_moving)
13493 continue; // robot does not kill player if he is moving
13495 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13497 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13498 continue; // center and border element do not touch
13506 else if (test_element == EL_PENGUIN)
13516 if (kill_x != -1 || kill_y != -1)
13518 if (IS_PLAYER(kill_x, kill_y))
13520 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13522 if (player->shield_deadly_time_left > 0 &&
13523 !IS_INDESTRUCTIBLE(bad_element))
13524 Bang(bad_x, bad_y);
13525 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13526 KillPlayer(player);
13529 Bang(kill_x, kill_y);
13533 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13535 int bad_element = Tile[bad_x][bad_y];
13536 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13537 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13538 int test_x = bad_x + dx, test_y = bad_y + dy;
13539 int test_move_dir, test_element;
13540 int kill_x = -1, kill_y = -1;
13542 if (!IN_LEV_FIELD(test_x, test_y))
13546 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13548 test_element = Tile[test_x][test_y];
13550 if (test_move_dir != bad_move_dir)
13552 // good thing can be player or penguin that does not move away
13553 if (IS_PLAYER(test_x, test_y))
13555 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13557 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13558 player as being hit when he is moving towards the bad thing, because
13559 the "get hit by" condition would be lost after the player stops) */
13560 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13561 return; // player moves away from bad thing
13566 else if (test_element == EL_PENGUIN)
13573 if (kill_x != -1 || kill_y != -1)
13575 if (IS_PLAYER(kill_x, kill_y))
13577 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13579 if (player->shield_deadly_time_left > 0 &&
13580 !IS_INDESTRUCTIBLE(bad_element))
13581 Bang(bad_x, bad_y);
13582 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13583 KillPlayer(player);
13586 Bang(kill_x, kill_y);
13590 void TestIfPlayerTouchesBadThing(int x, int y)
13592 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13595 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13597 TestIfGoodThingHitsBadThing(x, y, move_dir);
13600 void TestIfBadThingTouchesPlayer(int x, int y)
13602 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13605 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13607 TestIfBadThingHitsGoodThing(x, y, move_dir);
13610 void TestIfFriendTouchesBadThing(int x, int y)
13612 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13615 void TestIfBadThingTouchesFriend(int x, int y)
13617 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13620 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13622 int i, kill_x = bad_x, kill_y = bad_y;
13623 static int xy[4][2] =
13631 for (i = 0; i < NUM_DIRECTIONS; i++)
13635 x = bad_x + xy[i][0];
13636 y = bad_y + xy[i][1];
13637 if (!IN_LEV_FIELD(x, y))
13640 element = Tile[x][y];
13641 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13642 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13650 if (kill_x != bad_x || kill_y != bad_y)
13651 Bang(bad_x, bad_y);
13654 void KillPlayer(struct PlayerInfo *player)
13656 int jx = player->jx, jy = player->jy;
13658 if (!player->active)
13662 Debug("game:playing:KillPlayer",
13663 "0: killed == %d, active == %d, reanimated == %d",
13664 player->killed, player->active, player->reanimated);
13667 /* the following code was introduced to prevent an infinite loop when calling
13669 -> CheckTriggeredElementChangeExt()
13670 -> ExecuteCustomElementAction()
13672 -> (infinitely repeating the above sequence of function calls)
13673 which occurs when killing the player while having a CE with the setting
13674 "kill player X when explosion of <player X>"; the solution using a new
13675 field "player->killed" was chosen for backwards compatibility, although
13676 clever use of the fields "player->active" etc. would probably also work */
13678 if (player->killed)
13682 player->killed = TRUE;
13684 // remove accessible field at the player's position
13685 Tile[jx][jy] = EL_EMPTY;
13687 // deactivate shield (else Bang()/Explode() would not work right)
13688 player->shield_normal_time_left = 0;
13689 player->shield_deadly_time_left = 0;
13692 Debug("game:playing:KillPlayer",
13693 "1: killed == %d, active == %d, reanimated == %d",
13694 player->killed, player->active, player->reanimated);
13700 Debug("game:playing:KillPlayer",
13701 "2: killed == %d, active == %d, reanimated == %d",
13702 player->killed, player->active, player->reanimated);
13705 if (player->reanimated) // killed player may have been reanimated
13706 player->killed = player->reanimated = FALSE;
13708 BuryPlayer(player);
13711 static void KillPlayerUnlessEnemyProtected(int x, int y)
13713 if (!PLAYER_ENEMY_PROTECTED(x, y))
13714 KillPlayer(PLAYERINFO(x, y));
13717 static void KillPlayerUnlessExplosionProtected(int x, int y)
13719 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13720 KillPlayer(PLAYERINFO(x, y));
13723 void BuryPlayer(struct PlayerInfo *player)
13725 int jx = player->jx, jy = player->jy;
13727 if (!player->active)
13730 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13731 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13733 RemovePlayer(player);
13735 player->buried = TRUE;
13737 if (game.all_players_gone)
13738 game.GameOver = TRUE;
13741 void RemovePlayer(struct PlayerInfo *player)
13743 int jx = player->jx, jy = player->jy;
13744 int i, found = FALSE;
13746 player->present = FALSE;
13747 player->active = FALSE;
13749 // required for some CE actions (even if the player is not active anymore)
13750 player->MovPos = 0;
13752 if (!ExplodeField[jx][jy])
13753 StorePlayer[jx][jy] = 0;
13755 if (player->is_moving)
13756 TEST_DrawLevelField(player->last_jx, player->last_jy);
13758 for (i = 0; i < MAX_PLAYERS; i++)
13759 if (stored_player[i].active)
13764 game.all_players_gone = TRUE;
13765 game.GameOver = TRUE;
13768 game.exit_x = game.robot_wheel_x = jx;
13769 game.exit_y = game.robot_wheel_y = jy;
13772 void ExitPlayer(struct PlayerInfo *player)
13774 DrawPlayer(player); // needed here only to cleanup last field
13775 RemovePlayer(player);
13777 if (game.players_still_needed > 0)
13778 game.players_still_needed--;
13781 static void setFieldForSnapping(int x, int y, int element, int direction)
13783 struct ElementInfo *ei = &element_info[element];
13784 int direction_bit = MV_DIR_TO_BIT(direction);
13785 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13786 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13787 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13789 Tile[x][y] = EL_ELEMENT_SNAPPING;
13790 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13792 ResetGfxAnimation(x, y);
13794 GfxElement[x][y] = element;
13795 GfxAction[x][y] = action;
13796 GfxDir[x][y] = direction;
13797 GfxFrame[x][y] = -1;
13801 =============================================================================
13802 checkDiagonalPushing()
13803 -----------------------------------------------------------------------------
13804 check if diagonal input device direction results in pushing of object
13805 (by checking if the alternative direction is walkable, diggable, ...)
13806 =============================================================================
13809 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13810 int x, int y, int real_dx, int real_dy)
13812 int jx, jy, dx, dy, xx, yy;
13814 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13817 // diagonal direction: check alternative direction
13822 xx = jx + (dx == 0 ? real_dx : 0);
13823 yy = jy + (dy == 0 ? real_dy : 0);
13825 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
13829 =============================================================================
13831 -----------------------------------------------------------------------------
13832 x, y: field next to player (non-diagonal) to try to dig to
13833 real_dx, real_dy: direction as read from input device (can be diagonal)
13834 =============================================================================
13837 static int DigField(struct PlayerInfo *player,
13838 int oldx, int oldy, int x, int y,
13839 int real_dx, int real_dy, int mode)
13841 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
13842 boolean player_was_pushing = player->is_pushing;
13843 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
13844 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
13845 int jx = oldx, jy = oldy;
13846 int dx = x - jx, dy = y - jy;
13847 int nextx = x + dx, nexty = y + dy;
13848 int move_direction = (dx == -1 ? MV_LEFT :
13849 dx == +1 ? MV_RIGHT :
13851 dy == +1 ? MV_DOWN : MV_NONE);
13852 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
13853 int dig_side = MV_DIR_OPPOSITE(move_direction);
13854 int old_element = Tile[jx][jy];
13855 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
13858 if (is_player) // function can also be called by EL_PENGUIN
13860 if (player->MovPos == 0)
13862 player->is_digging = FALSE;
13863 player->is_collecting = FALSE;
13866 if (player->MovPos == 0) // last pushing move finished
13867 player->is_pushing = FALSE;
13869 if (mode == DF_NO_PUSH) // player just stopped pushing
13871 player->is_switching = FALSE;
13872 player->push_delay = -1;
13874 return MP_NO_ACTION;
13878 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
13879 old_element = Back[jx][jy];
13881 // in case of element dropped at player position, check background
13882 else if (Back[jx][jy] != EL_EMPTY &&
13883 game.engine_version >= VERSION_IDENT(2,2,0,0))
13884 old_element = Back[jx][jy];
13886 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
13887 return MP_NO_ACTION; // field has no opening in this direction
13889 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
13890 return MP_NO_ACTION; // field has no opening in this direction
13892 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
13896 Tile[jx][jy] = player->artwork_element;
13897 InitMovingField(jx, jy, MV_DOWN);
13898 Store[jx][jy] = EL_ACID;
13899 ContinueMoving(jx, jy);
13900 BuryPlayer(player);
13902 return MP_DONT_RUN_INTO;
13905 if (player_can_move && DONT_RUN_INTO(element))
13907 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
13909 return MP_DONT_RUN_INTO;
13912 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
13913 return MP_NO_ACTION;
13915 collect_count = element_info[element].collect_count_initial;
13917 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
13918 return MP_NO_ACTION;
13920 if (game.engine_version < VERSION_IDENT(2,2,0,0))
13921 player_can_move = player_can_move_or_snap;
13923 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
13924 game.engine_version >= VERSION_IDENT(2,2,0,0))
13926 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
13927 player->index_bit, dig_side);
13928 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13929 player->index_bit, dig_side);
13931 if (element == EL_DC_LANDMINE)
13934 if (Tile[x][y] != element) // field changed by snapping
13937 return MP_NO_ACTION;
13940 if (player->gravity && is_player && !player->is_auto_moving &&
13941 canFallDown(player) && move_direction != MV_DOWN &&
13942 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
13943 return MP_NO_ACTION; // player cannot walk here due to gravity
13945 if (player_can_move &&
13946 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
13948 int sound_element = SND_ELEMENT(element);
13949 int sound_action = ACTION_WALKING;
13951 if (IS_RND_GATE(element))
13953 if (!player->key[RND_GATE_NR(element)])
13954 return MP_NO_ACTION;
13956 else if (IS_RND_GATE_GRAY(element))
13958 if (!player->key[RND_GATE_GRAY_NR(element)])
13959 return MP_NO_ACTION;
13961 else if (IS_RND_GATE_GRAY_ACTIVE(element))
13963 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
13964 return MP_NO_ACTION;
13966 else if (element == EL_EXIT_OPEN ||
13967 element == EL_EM_EXIT_OPEN ||
13968 element == EL_EM_EXIT_OPENING ||
13969 element == EL_STEEL_EXIT_OPEN ||
13970 element == EL_EM_STEEL_EXIT_OPEN ||
13971 element == EL_EM_STEEL_EXIT_OPENING ||
13972 element == EL_SP_EXIT_OPEN ||
13973 element == EL_SP_EXIT_OPENING)
13975 sound_action = ACTION_PASSING; // player is passing exit
13977 else if (element == EL_EMPTY)
13979 sound_action = ACTION_MOVING; // nothing to walk on
13982 // play sound from background or player, whatever is available
13983 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
13984 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
13986 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
13988 else if (player_can_move &&
13989 IS_PASSABLE(element) && canPassField(x, y, move_direction))
13991 if (!ACCESS_FROM(element, opposite_direction))
13992 return MP_NO_ACTION; // field not accessible from this direction
13994 if (CAN_MOVE(element)) // only fixed elements can be passed!
13995 return MP_NO_ACTION;
13997 if (IS_EM_GATE(element))
13999 if (!player->key[EM_GATE_NR(element)])
14000 return MP_NO_ACTION;
14002 else if (IS_EM_GATE_GRAY(element))
14004 if (!player->key[EM_GATE_GRAY_NR(element)])
14005 return MP_NO_ACTION;
14007 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14009 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14010 return MP_NO_ACTION;
14012 else if (IS_EMC_GATE(element))
14014 if (!player->key[EMC_GATE_NR(element)])
14015 return MP_NO_ACTION;
14017 else if (IS_EMC_GATE_GRAY(element))
14019 if (!player->key[EMC_GATE_GRAY_NR(element)])
14020 return MP_NO_ACTION;
14022 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14024 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14025 return MP_NO_ACTION;
14027 else if (element == EL_DC_GATE_WHITE ||
14028 element == EL_DC_GATE_WHITE_GRAY ||
14029 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14031 if (player->num_white_keys == 0)
14032 return MP_NO_ACTION;
14034 player->num_white_keys--;
14036 else if (IS_SP_PORT(element))
14038 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14039 element == EL_SP_GRAVITY_PORT_RIGHT ||
14040 element == EL_SP_GRAVITY_PORT_UP ||
14041 element == EL_SP_GRAVITY_PORT_DOWN)
14042 player->gravity = !player->gravity;
14043 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14044 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14045 element == EL_SP_GRAVITY_ON_PORT_UP ||
14046 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14047 player->gravity = TRUE;
14048 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14049 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14050 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14051 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14052 player->gravity = FALSE;
14055 // automatically move to the next field with double speed
14056 player->programmed_action = move_direction;
14058 if (player->move_delay_reset_counter == 0)
14060 player->move_delay_reset_counter = 2; // two double speed steps
14062 DOUBLE_PLAYER_SPEED(player);
14065 PlayLevelSoundAction(x, y, ACTION_PASSING);
14067 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14071 if (mode != DF_SNAP)
14073 GfxElement[x][y] = GFX_ELEMENT(element);
14074 player->is_digging = TRUE;
14077 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14079 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14080 player->index_bit, dig_side);
14082 // if digging triggered player relocation, finish digging tile
14083 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14084 setFieldForSnapping(x, y, element, move_direction);
14086 if (mode == DF_SNAP)
14088 if (level.block_snap_field)
14089 setFieldForSnapping(x, y, element, move_direction);
14091 TestIfElementTouchesCustomElement(x, y); // for empty space
14093 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14094 player->index_bit, dig_side);
14097 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14101 if (is_player && mode != DF_SNAP)
14103 GfxElement[x][y] = element;
14104 player->is_collecting = TRUE;
14107 if (element == EL_SPEED_PILL)
14109 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14111 else if (element == EL_EXTRA_TIME && level.time > 0)
14113 TimeLeft += level.extra_time;
14115 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14117 DisplayGameControlValues();
14119 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14121 player->shield_normal_time_left += level.shield_normal_time;
14122 if (element == EL_SHIELD_DEADLY)
14123 player->shield_deadly_time_left += level.shield_deadly_time;
14125 else if (element == EL_DYNAMITE ||
14126 element == EL_EM_DYNAMITE ||
14127 element == EL_SP_DISK_RED)
14129 if (player->inventory_size < MAX_INVENTORY_SIZE)
14130 player->inventory_element[player->inventory_size++] = element;
14132 DrawGameDoorValues();
14134 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14136 player->dynabomb_count++;
14137 player->dynabombs_left++;
14139 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14141 player->dynabomb_size++;
14143 else if (element == EL_DYNABOMB_INCREASE_POWER)
14145 player->dynabomb_xl = TRUE;
14147 else if (IS_KEY(element))
14149 player->key[KEY_NR(element)] = TRUE;
14151 DrawGameDoorValues();
14153 else if (element == EL_DC_KEY_WHITE)
14155 player->num_white_keys++;
14157 // display white keys?
14158 // DrawGameDoorValues();
14160 else if (IS_ENVELOPE(element))
14162 player->show_envelope = element;
14164 else if (element == EL_EMC_LENSES)
14166 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14168 RedrawAllInvisibleElementsForLenses();
14170 else if (element == EL_EMC_MAGNIFIER)
14172 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14174 RedrawAllInvisibleElementsForMagnifier();
14176 else if (IS_DROPPABLE(element) ||
14177 IS_THROWABLE(element)) // can be collected and dropped
14181 if (collect_count == 0)
14182 player->inventory_infinite_element = element;
14184 for (i = 0; i < collect_count; i++)
14185 if (player->inventory_size < MAX_INVENTORY_SIZE)
14186 player->inventory_element[player->inventory_size++] = element;
14188 DrawGameDoorValues();
14190 else if (collect_count > 0)
14192 game.gems_still_needed -= collect_count;
14193 if (game.gems_still_needed < 0)
14194 game.gems_still_needed = 0;
14196 game.snapshot.collected_item = TRUE;
14198 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14200 DisplayGameControlValues();
14203 RaiseScoreElement(element);
14204 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14208 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14209 player->index_bit, dig_side);
14211 // if collecting triggered player relocation, finish collecting tile
14212 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14213 setFieldForSnapping(x, y, element, move_direction);
14216 if (mode == DF_SNAP)
14218 if (level.block_snap_field)
14219 setFieldForSnapping(x, y, element, move_direction);
14221 TestIfElementTouchesCustomElement(x, y); // for empty space
14223 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14224 player->index_bit, dig_side);
14227 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14229 if (mode == DF_SNAP && element != EL_BD_ROCK)
14230 return MP_NO_ACTION;
14232 if (CAN_FALL(element) && dy)
14233 return MP_NO_ACTION;
14235 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14236 !(element == EL_SPRING && level.use_spring_bug))
14237 return MP_NO_ACTION;
14239 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14240 ((move_direction & MV_VERTICAL &&
14241 ((element_info[element].move_pattern & MV_LEFT &&
14242 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14243 (element_info[element].move_pattern & MV_RIGHT &&
14244 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14245 (move_direction & MV_HORIZONTAL &&
14246 ((element_info[element].move_pattern & MV_UP &&
14247 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14248 (element_info[element].move_pattern & MV_DOWN &&
14249 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14250 return MP_NO_ACTION;
14252 // do not push elements already moving away faster than player
14253 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14254 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14255 return MP_NO_ACTION;
14257 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14259 if (player->push_delay_value == -1 || !player_was_pushing)
14260 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14262 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14264 if (player->push_delay_value == -1)
14265 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14267 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14269 if (!player->is_pushing)
14270 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14273 player->is_pushing = TRUE;
14274 player->is_active = TRUE;
14276 if (!(IN_LEV_FIELD(nextx, nexty) &&
14277 (IS_FREE(nextx, nexty) ||
14278 (IS_SB_ELEMENT(element) &&
14279 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14280 (IS_CUSTOM_ELEMENT(element) &&
14281 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14282 return MP_NO_ACTION;
14284 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14285 return MP_NO_ACTION;
14287 if (player->push_delay == -1) // new pushing; restart delay
14288 player->push_delay = 0;
14290 if (player->push_delay < player->push_delay_value &&
14291 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14292 element != EL_SPRING && element != EL_BALLOON)
14294 // make sure that there is no move delay before next try to push
14295 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14296 player->move_delay = 0;
14298 return MP_NO_ACTION;
14301 if (IS_CUSTOM_ELEMENT(element) &&
14302 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14304 if (!DigFieldByCE(nextx, nexty, element))
14305 return MP_NO_ACTION;
14308 if (IS_SB_ELEMENT(element))
14310 boolean sokoban_task_solved = FALSE;
14312 if (element == EL_SOKOBAN_FIELD_FULL)
14314 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14316 IncrementSokobanFieldsNeeded();
14317 IncrementSokobanObjectsNeeded();
14320 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14322 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14324 DecrementSokobanFieldsNeeded();
14325 DecrementSokobanObjectsNeeded();
14327 // sokoban object was pushed from empty field to sokoban field
14328 if (Back[x][y] == EL_EMPTY)
14329 sokoban_task_solved = TRUE;
14332 Tile[x][y] = EL_SOKOBAN_OBJECT;
14334 if (Back[x][y] == Back[nextx][nexty])
14335 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14336 else if (Back[x][y] != 0)
14337 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14340 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14343 if (sokoban_task_solved &&
14344 game.sokoban_fields_still_needed == 0 &&
14345 game.sokoban_objects_still_needed == 0 &&
14346 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14348 game.players_still_needed = 0;
14352 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14356 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14358 InitMovingField(x, y, move_direction);
14359 GfxAction[x][y] = ACTION_PUSHING;
14361 if (mode == DF_SNAP)
14362 ContinueMoving(x, y);
14364 MovPos[x][y] = (dx != 0 ? dx : dy);
14366 Pushed[x][y] = TRUE;
14367 Pushed[nextx][nexty] = TRUE;
14369 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14370 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14372 player->push_delay_value = -1; // get new value later
14374 // check for element change _after_ element has been pushed
14375 if (game.use_change_when_pushing_bug)
14377 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14378 player->index_bit, dig_side);
14379 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14380 player->index_bit, dig_side);
14383 else if (IS_SWITCHABLE(element))
14385 if (PLAYER_SWITCHING(player, x, y))
14387 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14388 player->index_bit, dig_side);
14393 player->is_switching = TRUE;
14394 player->switch_x = x;
14395 player->switch_y = y;
14397 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14399 if (element == EL_ROBOT_WHEEL)
14401 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14403 game.robot_wheel_x = x;
14404 game.robot_wheel_y = y;
14405 game.robot_wheel_active = TRUE;
14407 TEST_DrawLevelField(x, y);
14409 else if (element == EL_SP_TERMINAL)
14413 SCAN_PLAYFIELD(xx, yy)
14415 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14419 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14421 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14423 ResetGfxAnimation(xx, yy);
14424 TEST_DrawLevelField(xx, yy);
14428 else if (IS_BELT_SWITCH(element))
14430 ToggleBeltSwitch(x, y);
14432 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14433 element == EL_SWITCHGATE_SWITCH_DOWN ||
14434 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14435 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14437 ToggleSwitchgateSwitch(x, y);
14439 else if (element == EL_LIGHT_SWITCH ||
14440 element == EL_LIGHT_SWITCH_ACTIVE)
14442 ToggleLightSwitch(x, y);
14444 else if (element == EL_TIMEGATE_SWITCH ||
14445 element == EL_DC_TIMEGATE_SWITCH)
14447 ActivateTimegateSwitch(x, y);
14449 else if (element == EL_BALLOON_SWITCH_LEFT ||
14450 element == EL_BALLOON_SWITCH_RIGHT ||
14451 element == EL_BALLOON_SWITCH_UP ||
14452 element == EL_BALLOON_SWITCH_DOWN ||
14453 element == EL_BALLOON_SWITCH_NONE ||
14454 element == EL_BALLOON_SWITCH_ANY)
14456 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14457 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14458 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14459 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14460 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14463 else if (element == EL_LAMP)
14465 Tile[x][y] = EL_LAMP_ACTIVE;
14466 game.lights_still_needed--;
14468 ResetGfxAnimation(x, y);
14469 TEST_DrawLevelField(x, y);
14471 else if (element == EL_TIME_ORB_FULL)
14473 Tile[x][y] = EL_TIME_ORB_EMPTY;
14475 if (level.time > 0 || level.use_time_orb_bug)
14477 TimeLeft += level.time_orb_time;
14478 game.no_time_limit = FALSE;
14480 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14482 DisplayGameControlValues();
14485 ResetGfxAnimation(x, y);
14486 TEST_DrawLevelField(x, y);
14488 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14489 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14493 game.ball_active = !game.ball_active;
14495 SCAN_PLAYFIELD(xx, yy)
14497 int e = Tile[xx][yy];
14499 if (game.ball_active)
14501 if (e == EL_EMC_MAGIC_BALL)
14502 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14503 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14504 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14508 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14509 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14510 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14511 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14516 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14517 player->index_bit, dig_side);
14519 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14520 player->index_bit, dig_side);
14522 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14523 player->index_bit, dig_side);
14529 if (!PLAYER_SWITCHING(player, x, y))
14531 player->is_switching = TRUE;
14532 player->switch_x = x;
14533 player->switch_y = y;
14535 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14536 player->index_bit, dig_side);
14537 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14538 player->index_bit, dig_side);
14540 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14541 player->index_bit, dig_side);
14542 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14543 player->index_bit, dig_side);
14546 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14547 player->index_bit, dig_side);
14548 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14549 player->index_bit, dig_side);
14551 return MP_NO_ACTION;
14554 player->push_delay = -1;
14556 if (is_player) // function can also be called by EL_PENGUIN
14558 if (Tile[x][y] != element) // really digged/collected something
14560 player->is_collecting = !player->is_digging;
14561 player->is_active = TRUE;
14568 static boolean DigFieldByCE(int x, int y, int digging_element)
14570 int element = Tile[x][y];
14572 if (!IS_FREE(x, y))
14574 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14575 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14578 // no element can dig solid indestructible elements
14579 if (IS_INDESTRUCTIBLE(element) &&
14580 !IS_DIGGABLE(element) &&
14581 !IS_COLLECTIBLE(element))
14584 if (AmoebaNr[x][y] &&
14585 (element == EL_AMOEBA_FULL ||
14586 element == EL_BD_AMOEBA ||
14587 element == EL_AMOEBA_GROWING))
14589 AmoebaCnt[AmoebaNr[x][y]]--;
14590 AmoebaCnt2[AmoebaNr[x][y]]--;
14593 if (IS_MOVING(x, y))
14594 RemoveMovingField(x, y);
14598 TEST_DrawLevelField(x, y);
14601 // if digged element was about to explode, prevent the explosion
14602 ExplodeField[x][y] = EX_TYPE_NONE;
14604 PlayLevelSoundAction(x, y, action);
14607 Store[x][y] = EL_EMPTY;
14609 // this makes it possible to leave the removed element again
14610 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14611 Store[x][y] = element;
14616 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14618 int jx = player->jx, jy = player->jy;
14619 int x = jx + dx, y = jy + dy;
14620 int snap_direction = (dx == -1 ? MV_LEFT :
14621 dx == +1 ? MV_RIGHT :
14623 dy == +1 ? MV_DOWN : MV_NONE);
14624 boolean can_continue_snapping = (level.continuous_snapping &&
14625 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14627 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14630 if (!player->active || !IN_LEV_FIELD(x, y))
14638 if (player->MovPos == 0)
14639 player->is_pushing = FALSE;
14641 player->is_snapping = FALSE;
14643 if (player->MovPos == 0)
14645 player->is_moving = FALSE;
14646 player->is_digging = FALSE;
14647 player->is_collecting = FALSE;
14653 // prevent snapping with already pressed snap key when not allowed
14654 if (player->is_snapping && !can_continue_snapping)
14657 player->MovDir = snap_direction;
14659 if (player->MovPos == 0)
14661 player->is_moving = FALSE;
14662 player->is_digging = FALSE;
14663 player->is_collecting = FALSE;
14666 player->is_dropping = FALSE;
14667 player->is_dropping_pressed = FALSE;
14668 player->drop_pressed_delay = 0;
14670 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14673 player->is_snapping = TRUE;
14674 player->is_active = TRUE;
14676 if (player->MovPos == 0)
14678 player->is_moving = FALSE;
14679 player->is_digging = FALSE;
14680 player->is_collecting = FALSE;
14683 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14684 TEST_DrawLevelField(player->last_jx, player->last_jy);
14686 TEST_DrawLevelField(x, y);
14691 static boolean DropElement(struct PlayerInfo *player)
14693 int old_element, new_element;
14694 int dropx = player->jx, dropy = player->jy;
14695 int drop_direction = player->MovDir;
14696 int drop_side = drop_direction;
14697 int drop_element = get_next_dropped_element(player);
14699 /* do not drop an element on top of another element; when holding drop key
14700 pressed without moving, dropped element must move away before the next
14701 element can be dropped (this is especially important if the next element
14702 is dynamite, which can be placed on background for historical reasons) */
14703 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14706 if (IS_THROWABLE(drop_element))
14708 dropx += GET_DX_FROM_DIR(drop_direction);
14709 dropy += GET_DY_FROM_DIR(drop_direction);
14711 if (!IN_LEV_FIELD(dropx, dropy))
14715 old_element = Tile[dropx][dropy]; // old element at dropping position
14716 new_element = drop_element; // default: no change when dropping
14718 // check if player is active, not moving and ready to drop
14719 if (!player->active || player->MovPos || player->drop_delay > 0)
14722 // check if player has anything that can be dropped
14723 if (new_element == EL_UNDEFINED)
14726 // only set if player has anything that can be dropped
14727 player->is_dropping_pressed = TRUE;
14729 // check if drop key was pressed long enough for EM style dynamite
14730 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14733 // check if anything can be dropped at the current position
14734 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14737 // collected custom elements can only be dropped on empty fields
14738 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14741 if (old_element != EL_EMPTY)
14742 Back[dropx][dropy] = old_element; // store old element on this field
14744 ResetGfxAnimation(dropx, dropy);
14745 ResetRandomAnimationValue(dropx, dropy);
14747 if (player->inventory_size > 0 ||
14748 player->inventory_infinite_element != EL_UNDEFINED)
14750 if (player->inventory_size > 0)
14752 player->inventory_size--;
14754 DrawGameDoorValues();
14756 if (new_element == EL_DYNAMITE)
14757 new_element = EL_DYNAMITE_ACTIVE;
14758 else if (new_element == EL_EM_DYNAMITE)
14759 new_element = EL_EM_DYNAMITE_ACTIVE;
14760 else if (new_element == EL_SP_DISK_RED)
14761 new_element = EL_SP_DISK_RED_ACTIVE;
14764 Tile[dropx][dropy] = new_element;
14766 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14767 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14768 el2img(Tile[dropx][dropy]), 0);
14770 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14772 // needed if previous element just changed to "empty" in the last frame
14773 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14775 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14776 player->index_bit, drop_side);
14777 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14779 player->index_bit, drop_side);
14781 TestIfElementTouchesCustomElement(dropx, dropy);
14783 else // player is dropping a dyna bomb
14785 player->dynabombs_left--;
14787 Tile[dropx][dropy] = new_element;
14789 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14790 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14791 el2img(Tile[dropx][dropy]), 0);
14793 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14796 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14797 InitField_WithBug1(dropx, dropy, FALSE);
14799 new_element = Tile[dropx][dropy]; // element might have changed
14801 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14802 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14804 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14805 MovDir[dropx][dropy] = drop_direction;
14807 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14809 // do not cause impact style collision by dropping elements that can fall
14810 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14813 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
14814 player->is_dropping = TRUE;
14816 player->drop_pressed_delay = 0;
14817 player->is_dropping_pressed = FALSE;
14819 player->drop_x = dropx;
14820 player->drop_y = dropy;
14825 // ----------------------------------------------------------------------------
14826 // game sound playing functions
14827 // ----------------------------------------------------------------------------
14829 static int *loop_sound_frame = NULL;
14830 static int *loop_sound_volume = NULL;
14832 void InitPlayLevelSound(void)
14834 int num_sounds = getSoundListSize();
14836 checked_free(loop_sound_frame);
14837 checked_free(loop_sound_volume);
14839 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
14840 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
14843 static void PlayLevelSound(int x, int y, int nr)
14845 int sx = SCREENX(x), sy = SCREENY(y);
14846 int volume, stereo_position;
14847 int max_distance = 8;
14848 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
14850 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
14851 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
14854 if (!IN_LEV_FIELD(x, y) ||
14855 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
14856 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
14859 volume = SOUND_MAX_VOLUME;
14861 if (!IN_SCR_FIELD(sx, sy))
14863 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
14864 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
14866 volume -= volume * (dx > dy ? dx : dy) / max_distance;
14869 stereo_position = (SOUND_MAX_LEFT +
14870 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
14871 (SCR_FIELDX + 2 * max_distance));
14873 if (IS_LOOP_SOUND(nr))
14875 /* This assures that quieter loop sounds do not overwrite louder ones,
14876 while restarting sound volume comparison with each new game frame. */
14878 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
14881 loop_sound_volume[nr] = volume;
14882 loop_sound_frame[nr] = FrameCounter;
14885 PlaySoundExt(nr, volume, stereo_position, type);
14888 static void PlayLevelSoundNearest(int x, int y, int sound_action)
14890 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
14891 x > LEVELX(BX2) ? LEVELX(BX2) : x,
14892 y < LEVELY(BY1) ? LEVELY(BY1) :
14893 y > LEVELY(BY2) ? LEVELY(BY2) : y,
14897 static void PlayLevelSoundAction(int x, int y, int action)
14899 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
14902 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
14904 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
14906 if (sound_effect != SND_UNDEFINED)
14907 PlayLevelSound(x, y, sound_effect);
14910 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
14913 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
14915 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
14916 PlayLevelSound(x, y, sound_effect);
14919 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
14921 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
14923 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
14924 PlayLevelSound(x, y, sound_effect);
14927 static void StopLevelSoundActionIfLoop(int x, int y, int action)
14929 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
14931 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
14932 StopSound(sound_effect);
14935 static int getLevelMusicNr(void)
14937 if (levelset.music[level_nr] != MUS_UNDEFINED)
14938 return levelset.music[level_nr]; // from config file
14940 return MAP_NOCONF_MUSIC(level_nr); // from music dir
14943 static void FadeLevelSounds(void)
14948 static void FadeLevelMusic(void)
14950 int music_nr = getLevelMusicNr();
14951 char *curr_music = getCurrentlyPlayingMusicFilename();
14952 char *next_music = getMusicInfoEntryFilename(music_nr);
14954 if (!strEqual(curr_music, next_music))
14958 void FadeLevelSoundsAndMusic(void)
14964 static void PlayLevelMusic(void)
14966 int music_nr = getLevelMusicNr();
14967 char *curr_music = getCurrentlyPlayingMusicFilename();
14968 char *next_music = getMusicInfoEntryFilename(music_nr);
14970 if (!strEqual(curr_music, next_music))
14971 PlayMusicLoop(music_nr);
14974 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
14976 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
14978 int x = xx - offset;
14979 int y = yy - offset;
14984 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
14988 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14992 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
14996 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15000 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15004 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15008 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15011 case SOUND_android_clone:
15012 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15015 case SOUND_android_move:
15016 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15020 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15024 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15028 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15031 case SOUND_eater_eat:
15032 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15036 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15039 case SOUND_collect:
15040 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15043 case SOUND_diamond:
15044 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15048 // !!! CHECK THIS !!!
15050 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15052 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15056 case SOUND_wonderfall:
15057 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15061 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15065 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15069 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15073 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15077 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15081 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15085 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15089 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15092 case SOUND_exit_open:
15093 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15096 case SOUND_exit_leave:
15097 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15100 case SOUND_dynamite:
15101 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15105 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15109 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15113 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15117 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15121 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15125 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15129 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15134 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15136 int element = map_element_SP_to_RND(element_sp);
15137 int action = map_action_SP_to_RND(action_sp);
15138 int offset = (setup.sp_show_border_elements ? 0 : 1);
15139 int x = xx - offset;
15140 int y = yy - offset;
15142 PlayLevelSoundElementAction(x, y, element, action);
15145 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15147 int element = map_element_MM_to_RND(element_mm);
15148 int action = map_action_MM_to_RND(action_mm);
15150 int x = xx - offset;
15151 int y = yy - offset;
15153 if (!IS_MM_ELEMENT(element))
15154 element = EL_MM_DEFAULT;
15156 PlayLevelSoundElementAction(x, y, element, action);
15159 void PlaySound_MM(int sound_mm)
15161 int sound = map_sound_MM_to_RND(sound_mm);
15163 if (sound == SND_UNDEFINED)
15169 void PlaySoundLoop_MM(int sound_mm)
15171 int sound = map_sound_MM_to_RND(sound_mm);
15173 if (sound == SND_UNDEFINED)
15176 PlaySoundLoop(sound);
15179 void StopSound_MM(int sound_mm)
15181 int sound = map_sound_MM_to_RND(sound_mm);
15183 if (sound == SND_UNDEFINED)
15189 void RaiseScore(int value)
15191 game.score += value;
15193 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15195 DisplayGameControlValues();
15198 void RaiseScoreElement(int element)
15203 case EL_BD_DIAMOND:
15204 case EL_EMERALD_YELLOW:
15205 case EL_EMERALD_RED:
15206 case EL_EMERALD_PURPLE:
15207 case EL_SP_INFOTRON:
15208 RaiseScore(level.score[SC_EMERALD]);
15211 RaiseScore(level.score[SC_DIAMOND]);
15214 RaiseScore(level.score[SC_CRYSTAL]);
15217 RaiseScore(level.score[SC_PEARL]);
15220 case EL_BD_BUTTERFLY:
15221 case EL_SP_ELECTRON:
15222 RaiseScore(level.score[SC_BUG]);
15225 case EL_BD_FIREFLY:
15226 case EL_SP_SNIKSNAK:
15227 RaiseScore(level.score[SC_SPACESHIP]);
15230 case EL_DARK_YAMYAM:
15231 RaiseScore(level.score[SC_YAMYAM]);
15234 RaiseScore(level.score[SC_ROBOT]);
15237 RaiseScore(level.score[SC_PACMAN]);
15240 RaiseScore(level.score[SC_NUT]);
15243 case EL_EM_DYNAMITE:
15244 case EL_SP_DISK_RED:
15245 case EL_DYNABOMB_INCREASE_NUMBER:
15246 case EL_DYNABOMB_INCREASE_SIZE:
15247 case EL_DYNABOMB_INCREASE_POWER:
15248 RaiseScore(level.score[SC_DYNAMITE]);
15250 case EL_SHIELD_NORMAL:
15251 case EL_SHIELD_DEADLY:
15252 RaiseScore(level.score[SC_SHIELD]);
15254 case EL_EXTRA_TIME:
15255 RaiseScore(level.extra_time_score);
15269 case EL_DC_KEY_WHITE:
15270 RaiseScore(level.score[SC_KEY]);
15273 RaiseScore(element_info[element].collect_score);
15278 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15280 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15282 // closing door required in case of envelope style request dialogs
15285 // prevent short reactivation of overlay buttons while closing door
15286 SetOverlayActive(FALSE);
15288 CloseDoor(DOOR_CLOSE_1);
15291 if (network.enabled)
15292 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15296 FadeSkipNextFadeIn();
15298 SetGameStatus(GAME_MODE_MAIN);
15303 else // continue playing the game
15305 if (tape.playing && tape.deactivate_display)
15306 TapeDeactivateDisplayOff(TRUE);
15308 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15310 if (tape.playing && tape.deactivate_display)
15311 TapeDeactivateDisplayOn();
15315 void RequestQuitGame(boolean ask_if_really_quit)
15317 boolean quick_quit = (!ask_if_really_quit || level_editor_test_game);
15318 boolean skip_request = game.all_players_gone || quick_quit;
15320 RequestQuitGameExt(skip_request, quick_quit,
15321 "Do you really want to quit the game?");
15324 void RequestRestartGame(char *message)
15326 game.restart_game_message = NULL;
15328 boolean has_started_game = hasStartedNetworkGame();
15329 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15331 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15333 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15337 // needed in case of envelope request to close game panel
15338 CloseDoor(DOOR_CLOSE_1);
15340 SetGameStatus(GAME_MODE_MAIN);
15346 void CheckGameOver(void)
15348 static boolean last_game_over = FALSE;
15349 static int game_over_delay = 0;
15350 int game_over_delay_value = 50;
15351 boolean game_over = checkGameFailed();
15353 // do not handle game over if request dialog is already active
15354 if (game.request_active)
15357 // do not ask to play again if game was never actually played
15358 if (!game.GamePlayed)
15363 last_game_over = FALSE;
15364 game_over_delay = game_over_delay_value;
15369 if (game_over_delay > 0)
15376 if (last_game_over != game_over)
15377 game.restart_game_message = (hasStartedNetworkGame() ?
15378 "Game over! Play it again?" :
15381 last_game_over = game_over;
15384 boolean checkGameSolved(void)
15386 // set for all game engines if level was solved
15387 return game.LevelSolved_GameEnd;
15390 boolean checkGameFailed(void)
15392 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15393 return (game_em.game_over && !game_em.level_solved);
15394 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15395 return (game_sp.game_over && !game_sp.level_solved);
15396 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15397 return (game_mm.game_over && !game_mm.level_solved);
15398 else // GAME_ENGINE_TYPE_RND
15399 return (game.GameOver && !game.LevelSolved);
15402 boolean checkGameEnded(void)
15404 return (checkGameSolved() || checkGameFailed());
15408 // ----------------------------------------------------------------------------
15409 // random generator functions
15410 // ----------------------------------------------------------------------------
15412 unsigned int InitEngineRandom_RND(int seed)
15414 game.num_random_calls = 0;
15416 return InitEngineRandom(seed);
15419 unsigned int RND(int max)
15423 game.num_random_calls++;
15425 return GetEngineRandom(max);
15432 // ----------------------------------------------------------------------------
15433 // game engine snapshot handling functions
15434 // ----------------------------------------------------------------------------
15436 struct EngineSnapshotInfo
15438 // runtime values for custom element collect score
15439 int collect_score[NUM_CUSTOM_ELEMENTS];
15441 // runtime values for group element choice position
15442 int choice_pos[NUM_GROUP_ELEMENTS];
15444 // runtime values for belt position animations
15445 int belt_graphic[4][NUM_BELT_PARTS];
15446 int belt_anim_mode[4][NUM_BELT_PARTS];
15449 static struct EngineSnapshotInfo engine_snapshot_rnd;
15450 static char *snapshot_level_identifier = NULL;
15451 static int snapshot_level_nr = -1;
15453 static void SaveEngineSnapshotValues_RND(void)
15455 static int belt_base_active_element[4] =
15457 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15458 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15459 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15460 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15464 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15466 int element = EL_CUSTOM_START + i;
15468 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15471 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15473 int element = EL_GROUP_START + i;
15475 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15478 for (i = 0; i < 4; i++)
15480 for (j = 0; j < NUM_BELT_PARTS; j++)
15482 int element = belt_base_active_element[i] + j;
15483 int graphic = el2img(element);
15484 int anim_mode = graphic_info[graphic].anim_mode;
15486 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15487 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15492 static void LoadEngineSnapshotValues_RND(void)
15494 unsigned int num_random_calls = game.num_random_calls;
15497 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15499 int element = EL_CUSTOM_START + i;
15501 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15504 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15506 int element = EL_GROUP_START + i;
15508 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15511 for (i = 0; i < 4; i++)
15513 for (j = 0; j < NUM_BELT_PARTS; j++)
15515 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15516 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15518 graphic_info[graphic].anim_mode = anim_mode;
15522 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15524 InitRND(tape.random_seed);
15525 for (i = 0; i < num_random_calls; i++)
15529 if (game.num_random_calls != num_random_calls)
15531 Error("number of random calls out of sync");
15532 Error("number of random calls should be %d", num_random_calls);
15533 Error("number of random calls is %d", game.num_random_calls);
15535 Fail("this should not happen -- please debug");
15539 void FreeEngineSnapshotSingle(void)
15541 FreeSnapshotSingle();
15543 setString(&snapshot_level_identifier, NULL);
15544 snapshot_level_nr = -1;
15547 void FreeEngineSnapshotList(void)
15549 FreeSnapshotList();
15552 static ListNode *SaveEngineSnapshotBuffers(void)
15554 ListNode *buffers = NULL;
15556 // copy some special values to a structure better suited for the snapshot
15558 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15559 SaveEngineSnapshotValues_RND();
15560 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15561 SaveEngineSnapshotValues_EM();
15562 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15563 SaveEngineSnapshotValues_SP(&buffers);
15564 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15565 SaveEngineSnapshotValues_MM(&buffers);
15567 // save values stored in special snapshot structure
15569 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15570 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15571 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15572 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15573 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15574 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15575 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15576 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15578 // save further RND engine values
15580 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15581 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15582 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15584 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15585 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15586 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15587 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15588 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15590 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15591 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15592 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15594 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15596 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15597 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15599 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15600 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15601 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15602 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15603 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15604 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15605 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15606 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15607 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15608 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15609 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15610 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15611 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15612 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15613 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15614 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15615 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15616 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15618 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15619 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15621 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15622 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15623 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15625 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15626 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15628 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15629 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15630 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15631 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15632 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15634 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15635 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15638 ListNode *node = engine_snapshot_list_rnd;
15641 while (node != NULL)
15643 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15648 Debug("game:playing:SaveEngineSnapshotBuffers",
15649 "size of engine snapshot: %d bytes", num_bytes);
15655 void SaveEngineSnapshotSingle(void)
15657 ListNode *buffers = SaveEngineSnapshotBuffers();
15659 // finally save all snapshot buffers to single snapshot
15660 SaveSnapshotSingle(buffers);
15662 // save level identification information
15663 setString(&snapshot_level_identifier, leveldir_current->identifier);
15664 snapshot_level_nr = level_nr;
15667 boolean CheckSaveEngineSnapshotToList(void)
15669 boolean save_snapshot =
15670 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15671 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15672 game.snapshot.changed_action) ||
15673 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15674 game.snapshot.collected_item));
15676 game.snapshot.changed_action = FALSE;
15677 game.snapshot.collected_item = FALSE;
15678 game.snapshot.save_snapshot = save_snapshot;
15680 return save_snapshot;
15683 void SaveEngineSnapshotToList(void)
15685 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15689 ListNode *buffers = SaveEngineSnapshotBuffers();
15691 // finally save all snapshot buffers to snapshot list
15692 SaveSnapshotToList(buffers);
15695 void SaveEngineSnapshotToListInitial(void)
15697 FreeEngineSnapshotList();
15699 SaveEngineSnapshotToList();
15702 static void LoadEngineSnapshotValues(void)
15704 // restore special values from snapshot structure
15706 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15707 LoadEngineSnapshotValues_RND();
15708 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15709 LoadEngineSnapshotValues_EM();
15710 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15711 LoadEngineSnapshotValues_SP();
15712 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15713 LoadEngineSnapshotValues_MM();
15716 void LoadEngineSnapshotSingle(void)
15718 LoadSnapshotSingle();
15720 LoadEngineSnapshotValues();
15723 static void LoadEngineSnapshot_Undo(int steps)
15725 LoadSnapshotFromList_Older(steps);
15727 LoadEngineSnapshotValues();
15730 static void LoadEngineSnapshot_Redo(int steps)
15732 LoadSnapshotFromList_Newer(steps);
15734 LoadEngineSnapshotValues();
15737 boolean CheckEngineSnapshotSingle(void)
15739 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15740 snapshot_level_nr == level_nr);
15743 boolean CheckEngineSnapshotList(void)
15745 return CheckSnapshotList();
15749 // ---------- new game button stuff -------------------------------------------
15756 boolean *setup_value;
15757 boolean allowed_on_tape;
15758 boolean is_touch_button;
15760 } gamebutton_info[NUM_GAME_BUTTONS] =
15763 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15764 GAME_CTRL_ID_STOP, NULL,
15765 TRUE, FALSE, "stop game"
15768 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15769 GAME_CTRL_ID_PAUSE, NULL,
15770 TRUE, FALSE, "pause game"
15773 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15774 GAME_CTRL_ID_PLAY, NULL,
15775 TRUE, FALSE, "play game"
15778 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15779 GAME_CTRL_ID_UNDO, NULL,
15780 TRUE, FALSE, "undo step"
15783 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15784 GAME_CTRL_ID_REDO, NULL,
15785 TRUE, FALSE, "redo step"
15788 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15789 GAME_CTRL_ID_SAVE, NULL,
15790 TRUE, FALSE, "save game"
15793 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15794 GAME_CTRL_ID_PAUSE2, NULL,
15795 TRUE, FALSE, "pause game"
15798 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15799 GAME_CTRL_ID_LOAD, NULL,
15800 TRUE, FALSE, "load game"
15803 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15804 GAME_CTRL_ID_PANEL_STOP, NULL,
15805 FALSE, FALSE, "stop game"
15808 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15809 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15810 FALSE, FALSE, "pause game"
15813 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
15814 GAME_CTRL_ID_PANEL_PLAY, NULL,
15815 FALSE, FALSE, "play game"
15818 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
15819 GAME_CTRL_ID_TOUCH_STOP, NULL,
15820 FALSE, TRUE, "stop game"
15823 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
15824 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
15825 FALSE, TRUE, "pause game"
15828 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
15829 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
15830 TRUE, FALSE, "background music on/off"
15833 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
15834 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
15835 TRUE, FALSE, "sound loops on/off"
15838 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
15839 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
15840 TRUE, FALSE, "normal sounds on/off"
15843 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
15844 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
15845 FALSE, FALSE, "background music on/off"
15848 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
15849 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
15850 FALSE, FALSE, "sound loops on/off"
15853 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
15854 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
15855 FALSE, FALSE, "normal sounds on/off"
15859 void CreateGameButtons(void)
15863 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15865 int graphic = gamebutton_info[i].graphic;
15866 struct GraphicInfo *gfx = &graphic_info[graphic];
15867 struct XY *pos = gamebutton_info[i].pos;
15868 struct GadgetInfo *gi;
15871 unsigned int event_mask;
15872 boolean is_touch_button = gamebutton_info[i].is_touch_button;
15873 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
15874 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
15875 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
15876 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
15877 int gd_x = gfx->src_x;
15878 int gd_y = gfx->src_y;
15879 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
15880 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
15881 int gd_xa = gfx->src_x + gfx->active_xoffset;
15882 int gd_ya = gfx->src_y + gfx->active_yoffset;
15883 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
15884 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
15885 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
15886 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
15889 if (gfx->bitmap == NULL)
15891 game_gadget[id] = NULL;
15896 if (id == GAME_CTRL_ID_STOP ||
15897 id == GAME_CTRL_ID_PANEL_STOP ||
15898 id == GAME_CTRL_ID_TOUCH_STOP ||
15899 id == GAME_CTRL_ID_PLAY ||
15900 id == GAME_CTRL_ID_PANEL_PLAY ||
15901 id == GAME_CTRL_ID_SAVE ||
15902 id == GAME_CTRL_ID_LOAD)
15904 button_type = GD_TYPE_NORMAL_BUTTON;
15906 event_mask = GD_EVENT_RELEASED;
15908 else if (id == GAME_CTRL_ID_UNDO ||
15909 id == GAME_CTRL_ID_REDO)
15911 button_type = GD_TYPE_NORMAL_BUTTON;
15913 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
15917 button_type = GD_TYPE_CHECK_BUTTON;
15918 checked = (gamebutton_info[i].setup_value != NULL ?
15919 *gamebutton_info[i].setup_value : FALSE);
15920 event_mask = GD_EVENT_PRESSED;
15923 gi = CreateGadget(GDI_CUSTOM_ID, id,
15924 GDI_IMAGE_ID, graphic,
15925 GDI_INFO_TEXT, gamebutton_info[i].infotext,
15928 GDI_WIDTH, gfx->width,
15929 GDI_HEIGHT, gfx->height,
15930 GDI_TYPE, button_type,
15931 GDI_STATE, GD_BUTTON_UNPRESSED,
15932 GDI_CHECKED, checked,
15933 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
15934 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
15935 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
15936 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
15937 GDI_DIRECT_DRAW, FALSE,
15938 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
15939 GDI_EVENT_MASK, event_mask,
15940 GDI_CALLBACK_ACTION, HandleGameButtons,
15944 Fail("cannot create gadget");
15946 game_gadget[id] = gi;
15950 void FreeGameButtons(void)
15954 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15955 FreeGadget(game_gadget[i]);
15958 static void UnmapGameButtonsAtSamePosition(int id)
15962 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15964 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
15965 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
15966 UnmapGadget(game_gadget[i]);
15969 static void UnmapGameButtonsAtSamePosition_All(void)
15971 if (setup.show_snapshot_buttons)
15973 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
15974 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
15975 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
15979 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
15980 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
15981 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
15983 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
15984 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
15985 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
15989 static void MapGameButtonsAtSamePosition(int id)
15993 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15995 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
15996 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
15997 MapGadget(game_gadget[i]);
15999 UnmapGameButtonsAtSamePosition_All();
16002 void MapUndoRedoButtons(void)
16004 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16005 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16007 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16008 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16011 void UnmapUndoRedoButtons(void)
16013 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16014 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16016 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16017 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16020 void ModifyPauseButtons(void)
16024 GAME_CTRL_ID_PAUSE,
16025 GAME_CTRL_ID_PAUSE2,
16026 GAME_CTRL_ID_PANEL_PAUSE,
16027 GAME_CTRL_ID_TOUCH_PAUSE,
16032 for (i = 0; ids[i] > -1; i++)
16033 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16036 static void MapGameButtonsExt(boolean on_tape)
16040 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16041 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16042 i != GAME_CTRL_ID_UNDO &&
16043 i != GAME_CTRL_ID_REDO)
16044 MapGadget(game_gadget[i]);
16046 UnmapGameButtonsAtSamePosition_All();
16048 RedrawGameButtons();
16051 static void UnmapGameButtonsExt(boolean on_tape)
16055 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16056 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16057 UnmapGadget(game_gadget[i]);
16060 static void RedrawGameButtonsExt(boolean on_tape)
16064 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16065 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16066 RedrawGadget(game_gadget[i]);
16069 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16074 gi->checked = state;
16077 static void RedrawSoundButtonGadget(int id)
16079 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16080 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16081 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16082 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16083 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16084 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16087 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16088 RedrawGadget(game_gadget[id2]);
16091 void MapGameButtons(void)
16093 MapGameButtonsExt(FALSE);
16096 void UnmapGameButtons(void)
16098 UnmapGameButtonsExt(FALSE);
16101 void RedrawGameButtons(void)
16103 RedrawGameButtonsExt(FALSE);
16106 void MapGameButtonsOnTape(void)
16108 MapGameButtonsExt(TRUE);
16111 void UnmapGameButtonsOnTape(void)
16113 UnmapGameButtonsExt(TRUE);
16116 void RedrawGameButtonsOnTape(void)
16118 RedrawGameButtonsExt(TRUE);
16121 static void GameUndoRedoExt(void)
16123 ClearPlayerAction();
16125 tape.pausing = TRUE;
16128 UpdateAndDisplayGameControlValues();
16130 DrawCompleteVideoDisplay();
16131 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16132 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16133 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16138 static void GameUndo(int steps)
16140 if (!CheckEngineSnapshotList())
16143 LoadEngineSnapshot_Undo(steps);
16148 static void GameRedo(int steps)
16150 if (!CheckEngineSnapshotList())
16153 LoadEngineSnapshot_Redo(steps);
16158 static void HandleGameButtonsExt(int id, int button)
16160 static boolean game_undo_executed = FALSE;
16161 int steps = BUTTON_STEPSIZE(button);
16162 boolean handle_game_buttons =
16163 (game_status == GAME_MODE_PLAYING ||
16164 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16166 if (!handle_game_buttons)
16171 case GAME_CTRL_ID_STOP:
16172 case GAME_CTRL_ID_PANEL_STOP:
16173 case GAME_CTRL_ID_TOUCH_STOP:
16174 if (game_status == GAME_MODE_MAIN)
16180 RequestQuitGame(TRUE);
16184 case GAME_CTRL_ID_PAUSE:
16185 case GAME_CTRL_ID_PAUSE2:
16186 case GAME_CTRL_ID_PANEL_PAUSE:
16187 case GAME_CTRL_ID_TOUCH_PAUSE:
16188 if (network.enabled && game_status == GAME_MODE_PLAYING)
16191 SendToServer_ContinuePlaying();
16193 SendToServer_PausePlaying();
16196 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16198 game_undo_executed = FALSE;
16202 case GAME_CTRL_ID_PLAY:
16203 case GAME_CTRL_ID_PANEL_PLAY:
16204 if (game_status == GAME_MODE_MAIN)
16206 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16208 else if (tape.pausing)
16210 if (network.enabled)
16211 SendToServer_ContinuePlaying();
16213 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16217 case GAME_CTRL_ID_UNDO:
16218 // Important: When using "save snapshot when collecting an item" mode,
16219 // load last (current) snapshot for first "undo" after pressing "pause"
16220 // (else the last-but-one snapshot would be loaded, because the snapshot
16221 // pointer already points to the last snapshot when pressing "pause",
16222 // which is fine for "every step/move" mode, but not for "every collect")
16223 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16224 !game_undo_executed)
16227 game_undo_executed = TRUE;
16232 case GAME_CTRL_ID_REDO:
16236 case GAME_CTRL_ID_SAVE:
16240 case GAME_CTRL_ID_LOAD:
16244 case SOUND_CTRL_ID_MUSIC:
16245 case SOUND_CTRL_ID_PANEL_MUSIC:
16246 if (setup.sound_music)
16248 setup.sound_music = FALSE;
16252 else if (audio.music_available)
16254 setup.sound = setup.sound_music = TRUE;
16256 SetAudioMode(setup.sound);
16258 if (game_status == GAME_MODE_PLAYING)
16262 RedrawSoundButtonGadget(id);
16266 case SOUND_CTRL_ID_LOOPS:
16267 case SOUND_CTRL_ID_PANEL_LOOPS:
16268 if (setup.sound_loops)
16269 setup.sound_loops = FALSE;
16270 else if (audio.loops_available)
16272 setup.sound = setup.sound_loops = TRUE;
16274 SetAudioMode(setup.sound);
16277 RedrawSoundButtonGadget(id);
16281 case SOUND_CTRL_ID_SIMPLE:
16282 case SOUND_CTRL_ID_PANEL_SIMPLE:
16283 if (setup.sound_simple)
16284 setup.sound_simple = FALSE;
16285 else if (audio.sound_available)
16287 setup.sound = setup.sound_simple = TRUE;
16289 SetAudioMode(setup.sound);
16292 RedrawSoundButtonGadget(id);
16301 static void HandleGameButtons(struct GadgetInfo *gi)
16303 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16306 void HandleSoundButtonKeys(Key key)
16308 if (key == setup.shortcut.sound_simple)
16309 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16310 else if (key == setup.shortcut.sound_loops)
16311 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16312 else if (key == setup.shortcut.sound_music)
16313 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);